From 2ad5923b2a0bd2eaaa9cdcab8639ef4b4f4f4e11 Mon Sep 17 00:00:00 2001 From: justrach <54503978+justrach@users.noreply.github.com> Date: Sun, 24 May 2026 15:18:09 +0800 Subject: [PATCH 1/7] =?UTF-8?q?fix:=20MCP=20server=20dies=20on=20client=20?= =?UTF-8?q?disconnect=20=E2=80=94=20ignore=20SIGPIPE=20+=20detect=20broken?= =?UTF-8?q?=20stdout?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three root causes fixed: - No SIGPIPE handler: writing to a broken pipe killed the process outright - writeResult/writeError/writeRequest silently swallowed write failures (catch return), leaving the main loop unaware the client disconnected - Main loop had no exit path for write failures or watchdog shutdown signal Added cio.ignoreSigpipe() via sigaction at startup. Added stdout_broken atomic flag set on any stdout write failure. Main loop now checks both stdout_broken and a shutdown flag (passed from the watchdog thread) each iteration. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/cio.zig | 9 +++++++++ src/main.zig | 3 ++- src/mcp.zig | 25 ++++++++++++++++++++----- 3 files changed, 31 insertions(+), 6 deletions(-) diff --git a/src/cio.zig b/src/cio.zig index 69c6aef..1cf1950 100644 --- a/src/cio.zig +++ b/src/cio.zig @@ -16,6 +16,15 @@ extern "c" fn clock_gettime(id: c_int, ts: *std.c.timespec) c_int; extern "c" fn pipe(fds: *[2]c_int) c_int; extern "c" fn close(fd: c_int) c_int; +pub fn ignoreSigpipe() void { + var act: std.posix.Sigaction = .{ + .handler = .{ .handler = std.posix.SIG.IGN }, + .mask = 0, + .flags = 0, + }; + std.posix.sigaction(std.posix.SIG.PIPE, &act, null); +} + const CLOCK_REALTIME: c_int = 0; const CLOCK_MONOTONIC: c_int = if (builtin.os.tag == .macos) 6 else 1; diff --git a/src/main.zig b/src/main.zig index 041ce5c..3873c9e 100644 --- a/src/main.zig +++ b/src/main.zig @@ -80,6 +80,7 @@ fn mainInner() void { fn mainImpl() !void { // Use c_allocator (libc malloc) — better page reclamation than GPA const allocator = std.heap.c_allocator; + cio.ignoreSigpipe(); // 0.16: single Threaded I/O instance passed down through every subsystem // that touches fs/subprocess. See issue #282. `io` flows into mcp.run, @@ -1048,7 +1049,7 @@ fn mainImpl() !void { std.log.info("codedb mcp: root={s} files={d} data={s} scan={s}", .{ abs_root, store.currentSeq(), data_dir, mcp_server.getScanState().name() }); - mcp_server.run(io, allocator, &store, &explorer, &agents, abs_root, cfg.max_cached, &telem, maybe_deferred); + mcp_server.run(io, allocator, &store, &explorer, &agents, abs_root, cfg.max_cached, &telem, maybe_deferred, &shutdown); shutdown.store(true, .release); if (scan_thread) |st| st.join(); diff --git a/src/mcp.zig b/src/mcp.zig index 839d22b..ca85dd6 100644 --- a/src/mcp.zig +++ b/src/mcp.zig @@ -651,6 +651,8 @@ pub var last_activity: std.atomic.Value(i64) = std.atomic.Value(i64).init(0); /// How often the watchdog checks whether the MCP client disconnected. pub const dead_client_poll_ms: u64 = 1000; +pub var stdout_broken: std.atomic.Value(bool) = std.atomic.Value(bool).init(false); + // ── Serve-first scan state (issue #207) ───────────────────────────────────── // // MCP serves immediately on startup; the file walk + index build runs in a @@ -732,6 +734,7 @@ pub fn run( content_cache_capacity: u32, telem: *telemetry_mod.Telemetry, deferred_scan: ?*DeferredScan, + shutdown: *std.atomic.Value(bool), ) void { const stdout = cio.File.stdout(); const stdin = std.Io.File.stdin(); @@ -778,7 +781,7 @@ pub fn run( var read_buf: [4096]u8 = undefined; var stdin_reader = stdin.reader(io, &read_buf); - while (true) { + while (!stdout_broken.load(.acquire) and !shutdown.load(.acquire)) { const msg = mcpj.readLineBuf(alloc, &stdin_reader.interface) orelse break; last_activity.store(cio.milliTimestamp(), .release); defer alloc.free(msg); @@ -935,7 +938,10 @@ fn writeRequest(alloc: std.mem.Allocator, stdout: cio.File, id: i64, method: []c buf.appendSlice(alloc, "\",\"params\":") catch return; buf.appendSlice(alloc, params) catch return; buf.appendSlice(alloc, "}\n") catch return; - stdout.writeAll(buf.items) catch {}; + stdout.writeAll(buf.items) catch { + stdout_broken.store(true, .release); + return; + }; } fn handleCall( @@ -3890,7 +3896,10 @@ fn writeResult(alloc: std.mem.Allocator, stdout: cio.File, id: ?std.json.Value, if (i < result.len) i += 1; } buf.appendSlice(alloc, "}\n") catch return; - stdout.writeAll(buf.items) catch return; + stdout.writeAll(buf.items) catch { + stdout_broken.store(true, .release); + return; + }; } fn writeError(alloc: std.mem.Allocator, stdout: cio.File, id: ?std.json.Value, code: i32, msg: []const u8) void { @@ -3905,8 +3914,14 @@ fn writeError(alloc: std.mem.Allocator, stdout: cio.File, id: ?std.json.Value, c buf.appendSlice(alloc, ",\"message\":\"") catch return; mcpj.writeEscaped(alloc, &buf, msg); buf.appendSlice(alloc, "\"}}") catch return; - stdout.writeAll(buf.items) catch return; - stdout.writeAll("\n") catch return; + stdout.writeAll(buf.items) catch { + stdout_broken.store(true, .release); + return; + }; + stdout.writeAll("\n") catch { + stdout_broken.store(true, .release); + return; + }; } /// Fast JSON string escaper: batch-copies runs of safe characters via /// appendSlice instead of the per-byte append in mcpj.writeEscaped. From 0aee2a7b1363332ef359cf0448fea582081ba6d5 Mon Sep 17 00:00:00 2001 From: justrach <54503978+justrach@users.noreply.github.com> Date: Sun, 24 May 2026 15:18:17 +0800 Subject: [PATCH 2/7] =?UTF-8?q?fix:=20issue-44=20=E2=80=94=20stale=20snaps?= =?UTF-8?q?hot=20content=20invisible=20to=20search=20after=20working=20tre?= =?UTF-8?q?e=20changes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit loadSnapshotFast correctly detected stale files (disk mtime > snapshot mtime) but re-indexed them with indexFileOutlineOnly, which skips the word index and trigram index. Since searchContent relies on these indices, updated content was invisible to all search tiers. Changed to indexFile (full_index=true) so stale files get complete indexing. Also fixed isSensitivePath to block .env-* and .env_* variants (not just .env.*) Co-Authored-By: Claude Opus 4.7 (1M context) --- src/snapshot.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/snapshot.zig b/src/snapshot.zig index 8480d30..347c185 100644 --- a/src/snapshot.zig +++ b/src/snapshot.zig @@ -798,7 +798,7 @@ fn loadSnapshotFast( stale_outline.deinit(); } - explorer.indexFileOutlineOnly(path_buf, dc) catch { + explorer.indexFile(path_buf, dc) catch { allocator.free(path_buf); allocator.free(content); continue; @@ -932,7 +932,7 @@ fn isSensitivePath(path: []const u8) bool { // Catch .env, .env.anything; do NOT match .envoy, .envrc, .environment, etc. if (basename.len >= 4 and std.mem.eql(u8, basename[0..4], ".env") and - (basename.len == 4 or basename[4] == '.')) return true; + (basename.len == 4 or basename[4] == '.' or basename[4] == '-' or basename[4] == '_')) return true; // Check extensions if (endsWith(basename, ".pem")) return true; From 43e8240b8039d87329cb7d46122ab9915580e3c4 Mon Sep 17 00:00:00 2001 From: justrach <54503978+justrach@users.noreply.github.com> Date: Sun, 24 May 2026 15:18:26 +0800 Subject: [PATCH 3/7] fix: .env-local and .env_production bypass sensitive path filter isSensitivePath only matched .env and .env.X (dot-delimited) but missed .env-local, .env_production and similar hyphen/underscore variants. Extended the check to also treat '-' and '_' as delimiters after .env prefix. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/watcher.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/watcher.zig b/src/watcher.zig index c1aa6b6..1633380 100644 --- a/src/watcher.zig +++ b/src/watcher.zig @@ -1145,7 +1145,7 @@ pub fn isSensitivePath(path: []const u8) bool { } // .env, .env.; do NOT match .envoy, .envrc, .environment, etc. if (basename.len >= 4 and std.mem.eql(u8, basename[0..4], ".env") and - (basename.len == 4 or basename[4] == '.')) return true; + (basename.len == 4 or basename[4] == '.' or basename[4] == '-' or basename[4] == '_')) return true; // Exact matches const sensitive_names = [_][]const u8{ ".dev.vars", ".npmrc", ".pypirc", ".netrc", From 56ff1aa22e12424527b38f41715316fabd228080 Mon Sep 17 00:00:00 2001 From: justrach <54503978+justrach@users.noreply.github.com> Date: Sun, 24 May 2026 15:18:44 +0800 Subject: [PATCH 4/7] fix: broken error recovery in re-index + BM25 NaN safety Two correctness fixes: 1. commitParsedFileOwnedOutline: prior_content was hardcoded to null, so the errdefer on trigram indexing failure always removed the word index entry instead of restoring the prior content. Now fetches prior content before overwriting. 2. avgDocLength returns 1.0 when total_tokens=0 (prevents Inf in BM25 normalization). Sort comparator in rerankAndFinalize treats NaN scores as 0 to prevent unstable ordering. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/explore.zig | 6 ++++-- src/index.zig | 3 ++- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/src/explore.zig b/src/explore.zig index 81f4648..1e538a4 100644 --- a/src/explore.zig +++ b/src/explore.zig @@ -646,8 +646,8 @@ pub const Explorer = struct { persistent_outline.path = stable_path; + const prior_content = self.contents.get(stable_path); try self.contents.put(stable_path, content); - const prior_content: ?[]const u8 = null; if (full_index) { if (!self.word_index_complete) { @@ -1770,7 +1770,9 @@ pub const Explorer = struct { if (result_list.items.len > 1) { std.sort.block(SearchResult, result_list.items, {}, struct { pub fn lessThan(_: void, a: SearchResult, b: SearchResult) bool { - if (a.score != b.score) return a.score > b.score; + const sa = if (a.score == a.score) a.score else 0; + const sb = if (b.score == b.score) b.score else 0; + if (sa != sb) return sa > sb; const ord = std.mem.order(u8, a.path, b.path); if (ord != .eq) return ord == .lt; return a.line_num < b.line_num; diff --git a/src/index.zig b/src/index.zig index 711233b..a4e71aa 100644 --- a/src/index.zig +++ b/src/index.zig @@ -351,7 +351,8 @@ pub const WordIndex = struct { pub fn avgDocLength(self: *const WordIndex) f32 { const n = self.doc_lengths.count(); if (n == 0) return 1.0; - return @as(f32, @floatFromInt(self.total_tokens)) / @as(f32, @floatFromInt(n)); + const avg = @as(f32, @floatFromInt(self.total_tokens)) / @as(f32, @floatFromInt(n)); + return if (avg > 0) avg else 1.0; } /// Shrink all hit lists and per-file word sets to release excess capacity. From af2880fb73f896c823def2b1a39ad21d130d4a13 Mon Sep 17 00:00:00 2001 From: justrach <54503978+justrach@users.noreply.github.com> Date: Sun, 24 May 2026 15:19:01 +0800 Subject: [PATCH 5/7] refactor: split monolithic tests.zig into 8 independent test binaries The 11,621-line tests.zig (467 tests) compiled as a single binary that pegged CPU. Split into 8 independent binaries by domain: test-core 21 tests (store, agent, config, edit) test-explore 95 tests (explorer, word index, dep-graph, git, threads) test-index 141 tests (trigram, bloom, regex, disk, sparse ngram, perf) test-parser 46 tests (PHP, Go, Ruby, Swift, C, HCL, R, Dart, Python, TS) test-search 47 tests (BM25, rerank, callers) test-snapshot 16 tests (snapshot read/write/corruption) test-mcp 57 tests (MCP protocol, bundle, nuke, update, telemetry) test-query 44 tests (query pipeline, fuzzy, glob) Each can be run individually (zig build test-core) or all at once (zig build test). Co-Authored-By: Claude Opus 4.7 (1M context) --- build.zig | 54 +- src/test_core.zig | 437 ++++++ src/test_explore.zig | 1943 +++++++++++++++++++++++++++ src/test_index.zig | 2956 +++++++++++++++++++++++++++++++++++++++++ src/test_mcp.zig | 1568 ++++++++++++++++++++++ src/test_parser.zig | 1654 +++++++++++++++++++++++ src/test_query.zig | 1232 +++++++++++++++++ src/test_search.zig | 1598 ++++++++++++++++++++++ src/test_snapshot.zig | 714 ++++++++++ 9 files changed, 12137 insertions(+), 19 deletions(-) create mode 100644 src/test_core.zig create mode 100644 src/test_explore.zig create mode 100644 src/test_index.zig create mode 100644 src/test_mcp.zig create mode 100644 src/test_parser.zig create mode 100644 src/test_query.zig create mode 100644 src/test_search.zig create mode 100644 src/test_snapshot.zig diff --git a/build.zig b/build.zig index 203f929..abdbddd 100644 --- a/build.zig +++ b/build.zig @@ -53,28 +53,44 @@ pub fn build(b: *std.Build) void { const run_step = b.step("run", "Run codedb daemon"); run_step.dependOn(&run_cmd.step); - // ── Tests ── + // ── Tests (split into independent binaries for faster compilation) ── const test_filter = b.option([]const u8, "test-filter", "Only run tests whose name contains this substring"); - const tests = b.addTest(.{ - .root_module = b.createModule(.{ - .root_source_file = b.path("src/tests.zig"), - .target = target, - .optimize = optimize, - .link_libc = true, - }), - }); - tests.root_module.addImport("mcp", mcp_dep.module("mcp")); - tests.root_module.addImport("nanoregex", nanoregex_dep.module("nanoregex")); - if (test_filter) |f| { - const filters = b.allocator.alloc([]const u8, 1) catch @panic("oom"); - filters[0] = f; - tests.filters = filters; + const test_step = b.step("test", "Run all tests"); + + const test_files = [_]struct { name: []const u8, path: []const u8, needs_mcp: bool, needs_nanoregex: bool }{ + .{ .name = "test-core", .path = "src/test_core.zig", .needs_mcp = false, .needs_nanoregex = false }, + .{ .name = "test-explore", .path = "src/test_explore.zig", .needs_mcp = false, .needs_nanoregex = true }, + .{ .name = "test-index", .path = "src/test_index.zig", .needs_mcp = true, .needs_nanoregex = true }, + .{ .name = "test-parser", .path = "src/test_parser.zig", .needs_mcp = false, .needs_nanoregex = true }, + .{ .name = "test-search", .path = "src/test_search.zig", .needs_mcp = true, .needs_nanoregex = true }, + .{ .name = "test-snapshot", .path = "src/test_snapshot.zig", .needs_mcp = false, .needs_nanoregex = true }, + .{ .name = "test-mcp", .path = "src/test_mcp.zig", .needs_mcp = true, .needs_nanoregex = true }, + .{ .name = "test-query", .path = "src/test_query.zig", .needs_mcp = true, .needs_nanoregex = true }, + }; + + for (test_files) |tf| { + const t = b.addTest(.{ + .root_module = b.createModule(.{ + .root_source_file = b.path(tf.path), + .target = target, + .optimize = optimize, + .link_libc = true, + }), + }); + if (tf.needs_mcp) t.root_module.addImport("mcp", mcp_dep.module("mcp")); + if (tf.needs_nanoregex) t.root_module.addImport("nanoregex", nanoregex_dep.module("nanoregex")); + if (test_filter) |f| { + const filters = b.allocator.alloc([]const u8, 1) catch @panic("oom"); + filters[0] = f; + t.filters = filters; + } + const run = b.addRunArtifact(t); + test_step.dependOn(&run.step); + + const individual_step = b.step(tf.name, b.fmt("Run {s}", .{tf.name})); + individual_step.dependOn(&run.step); } - const test_step = b.step("test", "Run tests"); - const tests_run = b.addRunArtifact(tests); - test_step.dependOn(&tests_run.step); - // ── Library tests (verify the module root compiles) ── const lib_tests = b.addTest(.{ diff --git a/src/test_core.zig b/src/test_core.zig new file mode 100644 index 0000000..94bd30f --- /dev/null +++ b/src/test_core.zig @@ -0,0 +1,437 @@ +const std = @import("std"); +const cio = @import("cio.zig"); +const testing = std.testing; +const io = std.testing.io; +const Store = @import("store.zig").Store; +const ChangeEntry = @import("store.zig").ChangeEntry; +const AgentRegistry = @import("agent.zig").AgentRegistry; +const Config = @import("config.zig").Config; +const edit_mod = @import("edit.zig"); +const explore = @import("explore.zig"); +const Explorer = explore.Explorer; + + +test "store: record and retrieve snapshots" { + var store = Store.init(testing.allocator); + defer store.deinit(); + + const seq1 = try store.recordSnapshot("foo.zig", 100, 0xABC); + const seq2 = try store.recordSnapshot("bar.zig", 200, 0xDEF); + + try testing.expect(seq1 == 1); + try testing.expect(seq2 == 2); + try testing.expect(store.currentSeq() == 2); +} + + +test "store: getLatest returns most recent version" { + var store = Store.init(testing.allocator); + defer store.deinit(); + + _ = try store.recordSnapshot("foo.zig", 100, 0x111); + _ = try store.recordSnapshot("foo.zig", 200, 0x222); + + const latest = store.getLatest("foo.zig").?; + try testing.expect(latest.seq == 2); + try testing.expect(latest.size == 200); + try testing.expect(latest.hash == 0x222); +} + + +test "store: getLatest returns null for unknown file" { + var store = Store.init(testing.allocator); + defer store.deinit(); + + try testing.expect(store.getLatest("nope.zig") == null); +} + + +test "store: changesSince counts correctly" { + var store = Store.init(testing.allocator); + defer store.deinit(); + + _ = try store.recordSnapshot("a.zig", 10, 0); + _ = try store.recordSnapshot("b.zig", 20, 0); + _ = try store.recordSnapshot("c.zig", 30, 0); + + try testing.expect(store.changesSince(0) == 3); + try testing.expect(store.changesSince(1) == 2); + try testing.expect(store.changesSince(3) == 0); +} + + +test "store: changesSinceDetailed" { + var store = Store.init(testing.allocator); + defer store.deinit(); + + _ = try store.recordSnapshot("a.zig", 10, 0); + _ = try store.recordSnapshot("b.zig", 20, 0); + _ = try store.recordSnapshot("a.zig", 15, 0); + + const changes = try store.changesSinceDetailed(1, testing.allocator); + defer testing.allocator.free(changes); + + try testing.expect(changes.len == 2); // a.zig and b.zig both changed +} + + +test "store: recordDelete creates tombstone" { + var store = Store.init(testing.allocator); + defer store.deinit(); + + _ = try store.recordSnapshot("del.zig", 50, 0); + _ = try store.recordDelete("del.zig", 0); + + const latest = store.getLatest("del.zig").?; + try testing.expect(latest.op == .tombstone); + try testing.expect(latest.size == 0); +} + + +test "store: getAtCursor" { + var store = Store.init(testing.allocator); + defer store.deinit(); + + _ = try store.recordSnapshot("f.zig", 10, 0x10); + _ = try store.recordSnapshot("f.zig", 20, 0x20); + _ = try store.recordSnapshot("f.zig", 30, 0x30); + + const at1 = store.getAtCursor("f.zig", 1).?; + try testing.expect(at1.size == 10); + + const at2 = store.getAtCursor("f.zig", 2).?; + try testing.expect(at2.size == 20); + + const at3 = store.getAtCursor("f.zig", 99).?; + try testing.expect(at3.size == 30); +} + + +test "store: recordEdit persists diff data to data log" { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + var dir_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp_dir.dir.realPathFile(io, ".", &dir_buf); + const dir_path = dir_buf[0..dir_path_len]; + + const log_path = try std.fmt.allocPrint(testing.allocator, "{s}/data.log", .{dir_path}); + defer testing.allocator.free(log_path); + + var store = Store.init(testing.allocator); + defer store.deinit(); + + try store.openDataLog(io, log_path); + + const diff = "replace body"; + _ = try store.recordEdit("foo.zig", 1, .replace, 0x1234, diff.len, diff); + + const latest = store.getLatest("foo.zig").?; + try testing.expectEqual(@as(?u64, 0), latest.data_offset); + try testing.expectEqual(@as(u32, diff.len), latest.data_len); + + const log_file = try std.Io.Dir.cwd().openFile(io, log_path, .{}); + defer log_file.close(io); + + var buf: [32]u8 = undefined; + const read_len = try log_file.readPositionalAll(io, buf[0..diff.len], 0); + try testing.expectEqual(diff.len, read_len); + try testing.expectEqualStrings(diff, buf[0..diff.len]); +} + + +test "agent: register and heartbeat" { + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + + const id = try agents.register("test-agent"); + try testing.expect(id == 1); + + agents.heartbeat(id); + // No crash = success +} + + +test "agent: register multiple agents" { + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + + const a = try agents.register("alpha"); + const b = try agents.register("beta"); + try testing.expect(a == 1); + try testing.expect(b == 2); +} + + +test "agent: lock and unlock" { + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + + const id = try agents.register("locker"); + + const got = try agents.tryLock(id, "file.zig", 60_000); + try testing.expect(got == true); + + agents.releaseLock(id, "file.zig"); +} + + +test "agent: lock contention between agents" { + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + + const a = try agents.register("agent-a"); + const b = try agents.register("agent-b"); + + // A locks the file + const got_a = try agents.tryLock(a, "shared.zig", 60_000); + try testing.expect(got_a == true); + + // B should be denied + const got_b = try agents.tryLock(b, "shared.zig", 60_000); + try testing.expect(got_b == false); + + // A releases + agents.releaseLock(a, "shared.zig"); + + // B can now lock + const got_b2 = try agents.tryLock(b, "shared.zig", 60_000); + try testing.expect(got_b2 == true); +} + + +test "agent: same-agent relock does not duplicate lock key" { + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + + const id = try agents.register("agent-relock"); + + try testing.expect(try agents.tryLock(id, "shared.zig", 60_000)); + try testing.expect(try agents.tryLock(id, "shared.zig", 60_000)); + + const agent = agents.agents.getPtr(id) orelse return error.TestUnexpectedResult; + try testing.expect(agent.locked_paths.count() == 1); + + agents.releaseLock(id, "shared.zig"); + try testing.expect(agent.locked_paths.count() == 0); +} + + +test "agent: reapStale frees lock keys and clears map" { + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + + const id = try agents.register("agent-stale"); + try testing.expect(try agents.tryLock(id, "a.zig", 60_000)); + try testing.expect(try agents.tryLock(id, "b.zig", 60_000)); + + const agent = agents.agents.getPtr(id) orelse return error.TestUnexpectedResult; + agent.last_seen = 0; + agents.reapStale(0); + + try testing.expect(agent.state == .crashed); + try testing.expect(agent.locked_paths.count() == 0); +} + + +test "issue-411: tryLock grants new locks to a crashed agent" { + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + + const id = try agents.register("zombie"); + + // Force the agent into the crashed state via reapStale. + const a = agents.agents.getPtr(id) orelse return error.TestUnexpectedResult; + a.last_seen = 0; + agents.reapStale(0); + try testing.expectEqual(@as(@TypeOf(a.state), .crashed), a.state); + + // A crashed agent should not be allowed to acquire new advisory locks + // until it heartbeats back to .active. Today tryLock ignores .state and + // happily grants the lock — leaving the registry inconsistent (a + // .crashed agent suddenly holds fresh locks again). + const got = try agents.tryLock(id, "post-crash.zig", 60_000); + try testing.expect(got == false); +} + + +test "issue-401: insert with after=null is a no-op but consumes seq and writes file" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/edit-401.txt", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + const original = "line 1\nline 2\nline 3\n"; + var file = try tmp.dir.createFile(io, "edit-401.txt", .{}); + defer file.close(io); + try file.writeStreamingAll(io, original); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + const agent_id = try agents.register("issue-401-agent"); + + // insert without after must not silently succeed and must not consume a seq. + const res = edit_mod.applyEdit(io, testing.allocator, &store, &agents, null, .{ + .path = rel_path, + .agent_id = agent_id, + .op = .insert, + .after = null, + .content = "INJECT\n", + }); + // Either explicit error, or — at minimum — must not increment the store seq + // for an operation that did nothing. + if (res) |ok| { + _ = ok; + try testing.expectEqual(@as(u64, 0), store.currentSeq()); + } else |_| { + try testing.expectEqual(@as(u64, 0), store.currentSeq()); + } +} + + +test "issue-404: applyEdit corrupts CRLF line endings into mixed LF/CRLF" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/edit-404.txt", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + // Windows-style CRLF original + const original = "alpha\r\nbeta\r\ngamma\r\n"; + var file = try tmp.dir.createFile(io, "edit-404.txt", .{}); + defer file.close(io); + try file.writeStreamingAll(io, original); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + const agent_id = try agents.register("issue-404-agent"); + + // Replace line 1 with new content (no trailing newline in replacement). + _ = try edit_mod.applyEdit(io, testing.allocator, &store, &agents, null, .{ + .path = rel_path, + .agent_id = agent_id, + .op = .replace, + .range = .{ 1, 1 }, + .content = "ALPHA", + }); + + const after = try std.Io.Dir.cwd().readFileAlloc(io, rel_path, testing.allocator, .limited(10 * 1024)); + defer testing.allocator.free(after); + + // The original file used CRLF line endings. After a single-line replace + // the file must still be a valid CRLF file: every '\n' must be preceded + // by '\r'. Currently splitScalar on '\n' leaves the '\r' attached to the + // *unchanged* lines (e.g. "beta\r"), and the rejoin uses bare "\n", so + // the new line 1 lacks its CR while the surviving line 2 still has it — + // mixed line endings. + var i: usize = 0; + while (i < after.len) : (i += 1) { + if (after[i] == '\n') { + try testing.expect(i > 0); + try testing.expectEqual(@as(u8, '\r'), after[i - 1]); + } + } +} + + +test "issue-409: replacing whole file with empty content leaves a stray newline" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/edit-409.txt", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + // Single-line file with trailing newline. + const original = "abc\n"; + var file = try tmp.dir.createFile(io, "edit-409.txt", .{}); + defer file.close(io); + try file.writeStreamingAll(io, original); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + const agent_id = try agents.register("issue-409-agent"); + + // Replace the only line with empty content. The caller's intent is "make + // this file empty" — content has zero bytes. + const result = try edit_mod.applyEdit(io, testing.allocator, &store, &agents, null, .{ + .path = rel_path, + .agent_id = agent_id, + .op = .replace, + .range = .{ 1, 1 }, + .content = "", + }); + + const after = try std.Io.Dir.cwd().readFileAlloc(io, rel_path, testing.allocator, .limited(10 * 1024)); + defer testing.allocator.free(after); + + // Expectation: the file is empty. Currently the file ends up as "\n" + // because applyEdit unconditionally restores the trailing newline that + // existed in the source, even after the replacement reduced the file + // to a single empty line. + try testing.expectEqual(@as(usize, 0), after.len); + try testing.expectEqual(@as(u64, 0), result.new_size); +} + + +test "issue-101: Store.max_versions is configurable (caps per-file history)" { + // Default cap is 100. After setting max_versions = 3, writing 5 versions + // of the same file must leave exactly 3 in-memory. + var store = Store.init(testing.allocator); + defer store.deinit(); + + store.max_versions = 3; + + _ = try store.recordSnapshot("foo.zig", 10, 0x111); + _ = try store.recordSnapshot("foo.zig", 20, 0x222); + _ = try store.recordSnapshot("foo.zig", 30, 0x333); + _ = try store.recordSnapshot("foo.zig", 40, 0x444); + _ = try store.recordSnapshot("foo.zig", 50, 0x555); + + const entry = store.files.get("foo.zig") orelse return error.MissingFile; + try testing.expectEqual(@as(usize, 3), entry.versions.items.len); + // Oldest two dropped — newest survives. + try testing.expectEqual(@as(u64, 0x555), entry.versions.items[2].hash); +} + + +test "issue-102: Explorer.init capacity flows to ContentCache" { + // Verifies that the capacity arg to Explorer.init actually sets the + // ContentCache capacity — the bug that issue-102 was filed for. + var explorer = Explorer.init(testing.allocator, 8); + defer explorer.deinit(); + + try testing.expectEqual(@as(u32, 8), explorer.contents.capacity); +} + + +test "issue-101+102: .codedbrc max_cached threads through to ContentCache capacity" { + // End-to-end: parse a .codedbrc body, construct Explorer with the parsed + // max_cached, verify the ContentCache capacity matches. + const body = + \\# test config + \\max_versions = 7 + \\max_cached = 32 + \\ + ; + const cfg = try Config.parse(body); + try testing.expectEqual(@as(usize, 7), cfg.max_versions); + try testing.expectEqual(@as(u32, 32), cfg.max_cached); + + var store = Store.init(testing.allocator); + defer store.deinit(); + store.max_versions = cfg.max_versions; + + var explorer = Explorer.init(testing.allocator, cfg.max_cached); + defer explorer.deinit(); + + try testing.expectEqual(@as(usize, 7), store.max_versions); + try testing.expectEqual(@as(u32, 32), explorer.contents.capacity); +} + diff --git a/src/test_explore.zig b/src/test_explore.zig new file mode 100644 index 0000000..3f379cf --- /dev/null +++ b/src/test_explore.zig @@ -0,0 +1,1943 @@ +const std = @import("std"); +const cio = @import("cio.zig"); +const testing = std.testing; +const io = std.testing.io; +const Store = @import("store.zig").Store; +const Explorer = @import("explore.zig").Explorer; +const SearchResult = @import("explore.zig").SearchResult; +const WordIndex = @import("index.zig").WordIndex; +const TrigramIndex = @import("index.zig").TrigramIndex; +const SparseNgramIndex = @import("index.zig").SparseNgramIndex; +const WordTokenizer = @import("index.zig").WordTokenizer; +const splitIdentifier = @import("index.zig").splitIdentifier; +const explore = @import("explore.zig"); +const extractLines = explore.extractLines; +const isCommentOrBlank = explore.isCommentOrBlank; +const Language = explore.Language; +const SymbolKind = explore.SymbolKind; +const DependencyGraph = explore.DependencyGraph; +const SymbolLocation = explore.SymbolLocation; +const watcher = @import("watcher.zig"); +const git_mod = @import("git.zig"); +const snapshot_mod = @import("snapshot.zig"); + + +test "word tokenizer" { + var tok = WordTokenizer{ .buf = "pub fn main() !void {" }; + const w1 = tok.next().?; + try testing.expectEqualStrings("pub", w1); + const w2 = tok.next().?; + try testing.expectEqualStrings("fn", w2); + const w3 = tok.next().?; + try testing.expectEqualStrings("main", w3); + const w4 = tok.next().?; + try testing.expectEqualStrings("void", w4); + try testing.expect(tok.next() == null); +} + + +test "word index: index and search" { + var wi = WordIndex.init(testing.allocator); + defer wi.deinit(); + + try wi.indexFile("src/foo.zig", "pub fn hello() void {\n const x = 42;\n}\n"); + + const hits = wi.search("hello"); + try testing.expect(hits.len > 0); + try testing.expectEqualStrings("src/foo.zig", wi.hitPath(hits[0])); + try testing.expect(hits[0].line_num == 1); + + // "x" is only 1 char, should be skipped + const x_hits = wi.search("x"); + try testing.expect(x_hits.len == 0); + + // "const" should be found + const const_hits = wi.search("const"); + try testing.expect(const_hits.len > 0); + try testing.expect(const_hits[0].line_num == 2); +} + + +test "word index: re-index clears old entries" { + var wi = WordIndex.init(testing.allocator); + defer wi.deinit(); + + try wi.indexFile("f.zig", "fn old_func() void {}"); + try testing.expect(wi.search("old_func").len > 0); + + try wi.indexFile("f.zig", "fn new_func() void {}"); + try testing.expect(wi.search("old_func").len == 0); + try testing.expect(wi.search("new_func").len > 0); +} + + +test "word index: removeFile" { + var wi = WordIndex.init(testing.allocator); + defer wi.deinit(); + + try wi.indexFile("a.zig", "fn hello() void {}"); + try testing.expect(wi.search("hello").len > 0); + + wi.removeFile("a.zig"); + try testing.expect(wi.search("hello").len == 0); +} + + +test "word index: deduped search" { + var wi = WordIndex.init(testing.allocator); + defer wi.deinit(); + + // "hello" appears twice on the same line — should dedup + try wi.indexFile("f.zig", "hello hello world"); + + const hits = try wi.searchDeduped("hello", testing.allocator); + defer testing.allocator.free(hits); + try testing.expect(hits.len == 1); +} + + +test "explorer: sparse ngram index integrated into searchContent" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("src/alpha.zig", "pub fn processRequest(req: *Request) void {}"); + try explorer.indexFile("src/beta.zig", "pub fn handleResponse(res: *Response) void {}"); + + const results = try explorer.searchContent("processRequest", arena.allocator(), 10); + try testing.expectEqual(@as(usize, 1), results.len); + try testing.expectEqualStrings("src/alpha.zig", results[0].path); +} + + +test "explorer: searchContent finds query embedded in longer identifier" { + // Verify that searchContent correctly finds files whose content contains + // the query string. The sparse index (sliding-window) and trigram index + // are both used; the intersection narrows results without false negatives. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // "alpha.zig" content contains "record"; "beta.zig" does not. + try explorer.indexFile("alpha.zig", "const record_count: usize = 0;"); + try explorer.indexFile("beta.zig", "const unrelated_data: usize = 0;"); + + const results = try explorer.searchContent("record", arena.allocator(), 10); + var found = false; + for (results) |r| if (std.mem.eql(u8, r.path, "alpha.zig")) { + found = true; + }; + try testing.expect(found); +} + + +test "explorer: index file and get outline" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("test.zig", + \\const std = @import("std"); + \\pub fn main() !void {} + \\pub const Store = struct {}; + ); + + var outline = (try explorer.getOutline("test.zig", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + try testing.expect(outline.line_count == 3); + try testing.expect(outline.symbols.items.len == 3); +} + + +test "explorer: findSymbol" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("a.zig", "pub fn alpha() void {}"); + try explorer.indexFile("b.zig", "pub fn beta() void {}"); + + const result = try explorer.findSymbol("alpha", arena.allocator()); + try testing.expect(result != null); + try testing.expectEqualStrings("a.zig", result.?.path); +} + + +test "explorer: findAllSymbols returns multiple" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("a.zig", "const Store = @import(\"store.zig\").Store;"); + try explorer.indexFile("b.zig", "pub const Store = struct {};"); + + const results = try explorer.findAllSymbols("Store", arena.allocator()); + defer arena.allocator().free(results); + try testing.expect(results.len == 2); +} + + +test "explorer: searchContent with trigram acceleration" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("store.zig", "pub fn recordSnapshot(self: *Store) void {}\npub fn init() void {}"); + try explorer.indexFile("agent.zig", "pub fn register(self: *Agent) void {}"); + + const results = try explorer.searchContent("recordSnapshot", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + try testing.expect(results.len == 1); + try testing.expectEqualStrings("store.zig", results[0].path); + try testing.expect(results[0].line_num == 1); +} + + +test "explorer: searchWord via inverted index" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("math.zig", "pub fn add(a: i32, b: i32) i32 { return a + b; }"); + + const hits = try explorer.searchWord("add", testing.allocator); + defer testing.allocator.free(hits); + try testing.expect(hits.len > 0); + try testing.expectEqualStrings("math.zig", explorer.word_index.hitPath(hits[0])); +} + + +test "explorer: removeFile cleans up everything" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("gone.zig", "pub fn doStuff() void {}"); + var before_remove = (try explorer.getOutline("gone.zig", testing.allocator)) orelse return error.TestUnexpectedResult; + before_remove.deinit(); + + explorer.removeFile("gone.zig"); + try testing.expect((try explorer.getOutline("gone.zig", testing.allocator)) == null); + try testing.expect((try explorer.findSymbol("doStuff", testing.allocator)) == null); +} + + +test "explorer: python parser" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("app.py", + \\import os + \\class Server: + \\ def handle(self): + \\ pass + ); + + var outline = (try explorer.getOutline("app.py", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + try testing.expect(outline.symbols.items.len == 3); // import, class, def +} + + +test "explorer: typescript parser" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("index.ts", + \\import { foo } from './foo'; + \\export function handleRequest() {} + \\export const PORT = 3000; + ); + + var outline = (try explorer.getOutline("index.ts", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + try testing.expect(outline.symbols.items.len >= 3); +} + + +test "explorer: reindex OOM keeps prior outline reachable" { + // Use a real allocator for the explorer so the first indexFile always succeeds. + // We can't use FailingAllocator for the whole explorer because deinit would crash. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("oom.zig", "pub fn oldName() void {}"); + + // Now try re-indexing the same file. Since the explorer uses testing.allocator, + // we can't make individual internal allocs fail without a custom allocator wrapper. + // Instead, verify the errdefer rollback logic by confirming a successful reindex + // replaces the old outline, and that data is consistent. + try explorer.indexFile("oom.zig", "pub fn newName() void {}\nconst VALUE = 1;"); + + var outline = (try explorer.getOutline("oom.zig", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + try testing.expectEqualStrings("oom.zig", outline.path); + try testing.expect(outline.symbols.items.len == 2); // newName + VALUE + + // Old content should be replaced + const old_results = try explorer.searchContent("oldName", testing.allocator, 10); + defer { + for (old_results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(old_results); + } + try testing.expect(old_results.len == 0); + + // New content should be searchable + const new_results = try explorer.searchContent("newName", testing.allocator, 10); + defer { + for (new_results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(new_results); + } + try testing.expect(new_results.len == 1); +} + + +test "explorer: getOutline clone OOM preserves source outline" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile( + "clone-oom.zig", + "pub fn keepA() void {}\nconst dep = @import(\"dep.zig\");\npub const Value = 1;", + ); + + var induced_oom = false; + var fail_index: usize = 0; + while (fail_index < 512 and !induced_oom) : (fail_index += 1) { + var failing = std.testing.FailingAllocator.init(testing.allocator, .{ .fail_index = fail_index }); + const result = explorer.getOutline("clone-oom.zig", failing.allocator()); + + if (result) |maybe_outline| { + var outline = maybe_outline orelse return error.TestUnexpectedResult; + outline.deinit(); + continue; + } else |err| { + if (err != error.OutOfMemory) return err; + induced_oom = true; + + var stable = (try explorer.getOutline("clone-oom.zig", testing.allocator)) orelse return error.TestUnexpectedResult; + defer stable.deinit(); + try testing.expect(stable.symbols.items.len >= 2); + try testing.expect(stable.imports.items.len == 1); + try testing.expectEqualStrings("dep.zig", stable.imports.items[0]); + } + } + + try testing.expect(induced_oom); +} + + +test "explorer: outline copy survives source removal" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("persist.zig", "pub fn keep() void {}"); + var outline = (try explorer.getOutline("persist.zig", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + + explorer.removeFile("persist.zig"); + + try testing.expectEqualStrings("persist.zig", outline.path); + try testing.expect(outline.symbols.items.len > 0); +} + + +test "explorer: removeFile frees owned map key" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + var i: usize = 0; + while (i < 128) : (i += 1) { + var path_buf: [48]u8 = undefined; + const path = try std.fmt.bufPrint(&path_buf, "tmp/remove-{d}.zig", .{i}); + try explorer.indexFile(path, "pub fn x() void {}"); + explorer.removeFile(path); + } + + try testing.expect(explorer.outlines.count() == 0); + try testing.expect(explorer.contents.count() == 0); + try testing.expect(explorer.dep_graph.count() == 0); +} + + +test "word index: removeFile prunes empty buckets" { + var wi = WordIndex.init(testing.allocator); + defer wi.deinit(); + + try wi.indexFile("a.zig", "uniqueWordOnlyHere anotherUnique"); + // Words should exist + try testing.expect(wi.search("uniqueWordOnlyHere").len > 0); + + wi.removeFile("a.zig"); + // After removal, buckets should be pruned (not just emptied) + try testing.expect(wi.search("uniqueWordOnlyHere").len == 0); +} + + +test "extractLines: basic range with line numbers" { + const content = "line1\nline2\nline3\nline4\nline5"; + const result = try extractLines(content, 2, 4, true, false, .unknown, testing.allocator); + defer testing.allocator.free(result); + try testing.expect(std.mem.indexOf(u8, result, " 2 | line2") != null); + try testing.expect(std.mem.indexOf(u8, result, " 3 | line3") != null); + try testing.expect(std.mem.indexOf(u8, result, " 4 | line4") != null); + try testing.expect(std.mem.indexOf(u8, result, "line1") == null); + try testing.expect(std.mem.indexOf(u8, result, "line5") == null); +} + + +test "extractLines: start beyond file returns empty" { + const content = "line1\nline2"; + const result = try extractLines(content, 10, 20, true, false, .unknown, testing.allocator); + defer testing.allocator.free(result); + try testing.expect(result.len == 0); +} + + +test "extractLines: compact skips comments and blanks" { + const content = "fn main() void {}\n// this is a comment\n\n return 0;\n}"; + const result = try extractLines(content, 1, 5, false, true, .zig, testing.allocator); + defer testing.allocator.free(result); + // Should contain code lines but not the comment or blank line + try testing.expect(std.mem.indexOf(u8, result, "fn main") != null); + try testing.expect(std.mem.indexOf(u8, result, "// this is a comment") == null); + try testing.expect(std.mem.indexOf(u8, result, "return 0") != null); +} + + +test "isCommentOrBlank: detects language-specific comments" { + try testing.expect(isCommentOrBlank(" // zig comment", .zig)); + try testing.expect(isCommentOrBlank(" # python comment", .python)); + try testing.expect(isCommentOrBlank(" /* c comment */", .c)); + try testing.expect(isCommentOrBlank(" * continuation", .javascript)); + try testing.expect(isCommentOrBlank(" ", .zig)); + try testing.expect(isCommentOrBlank("", .zig)); + try testing.expect(!isCommentOrBlank(" const x = 1;", .zig)); + try testing.expect(!isCommentOrBlank(" x = 1", .python)); + // unknown language: never strips + try testing.expect(!isCommentOrBlank("// comment", .unknown)); +} + + +test "explorer: getSymbolBody returns source lines" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try exp.indexFile("test.zig", "const std = @import(\"std\");\npub fn main() !void {}\npub const Store = struct {};"); + + const body = try exp.getSymbolBody("test.zig", 2, 2, testing.allocator); + if (body) |b| { + defer testing.allocator.free(b); + try testing.expect(std.mem.indexOf(u8, b, "pub fn main") != null); + } else { + return error.TestUnexpectedResult; + } +} + + +test "explorer: getSymbolBody returns null for unknown file" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + const body = try exp.getSymbolBody("nonexistent.zig", 1, 5, testing.allocator); + try testing.expect(body == null); +} + + +test "explorer: searchContentWithScope annotates results" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // Use content where the search match line has no symbol definition itself + try exp.indexFile("auth.zig", "pub fn handleAuth() void {\n validate(token);\n}"); + + const results = try exp.searchContentWithScope("validate", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + if (r.scope_name) |n| testing.allocator.free(n); + } + testing.allocator.free(results); + } + + try testing.expect(results.len == 1); + try testing.expectEqualStrings("auth.zig", results[0].path); + try testing.expect(results[0].line_num == 2); + // Should have scope annotation — nearest preceding symbol is handleAuth + try testing.expect(results[0].scope_name != null); + try testing.expectEqualStrings("handleAuth", results[0].scope_name.?); +} + + +test "explorer: searchContentWithScope no scope for standalone line" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // Content with no symbols — scope should be null + try exp.indexFile("data.txt", "hello world\nfoo bar"); + + const results = try exp.searchContentWithScope("hello", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + if (r.scope_name) |n| testing.allocator.free(n); + } + testing.allocator.free(results); + } + + try testing.expect(results.len == 1); + try testing.expect(results[0].scope_name == null); +} + + +test "content hash: Wyhash produces consistent hash" { + const content = "pub fn main() void {}"; + const hash1 = std.hash.Wyhash.hash(0, content); + const hash2 = std.hash.Wyhash.hash(0, content); + try testing.expect(hash1 == hash2); + // Different content produces different hash + const hash3 = std.hash.Wyhash.hash(0, "different content"); + try testing.expect(hash1 != hash3); +} + + +test "detectLanguage: public access and correct detection" { + try testing.expect(explore.detectLanguage("src/main.zig") == .zig); + try testing.expect(explore.detectLanguage("app.py") == .python); + try testing.expect(explore.detectLanguage("index.ts") == .typescript); + try testing.expect(explore.detectLanguage("style.css") == .css); +} + + +test "extractLines: without line numbers" { + const content = "alpha\nbeta\ngamma"; + const result = try extractLines(content, 1, 3, false, false, .unknown, testing.allocator); + defer testing.allocator.free(result); + try testing.expectEqualStrings("alpha\nbeta\ngamma\n", result); +} + + +test "extractLines: start only reads to EOF" { + const content = "a\nb\nc\nd\ne"; + const result = try extractLines(content, 3, std.math.maxInt(u32), true, false, .unknown, testing.allocator); + defer testing.allocator.free(result); + try testing.expect(std.mem.indexOf(u8, result, " 3 | c") != null); + try testing.expect(std.mem.indexOf(u8, result, " 4 | d") != null); + try testing.expect(std.mem.indexOf(u8, result, " 5 | e") != null); + try testing.expect(std.mem.indexOf(u8, result, "| a") == null); + try testing.expect(std.mem.indexOf(u8, result, "| b") == null); +} + + +test "extractLines: end beyond file clamps to EOF" { + const content = "x\ny\nz"; + const result = try extractLines(content, 2, 999, true, false, .unknown, testing.allocator); + defer testing.allocator.free(result); + try testing.expect(std.mem.indexOf(u8, result, " 2 | y") != null); + try testing.expect(std.mem.indexOf(u8, result, " 3 | z") != null); + // No crash, no garbage — just the available lines + try testing.expect(std.mem.count(u8, result, "\n") == 2); +} + + +test "extractLines: single line range (start == end)" { + const content = "one\ntwo\nthree"; + const result = try extractLines(content, 2, 2, true, false, .unknown, testing.allocator); + defer testing.allocator.free(result); + try testing.expect(std.mem.indexOf(u8, result, " 2 | two") != null); + try testing.expect(std.mem.count(u8, result, "\n") == 1); +} + + +test "extractLines: empty content returns single empty line" { + const result = try extractLines("", 1, 10, true, false, .unknown, testing.allocator); + defer testing.allocator.free(result); + // Empty string splits to one empty line, which is line 1 + try testing.expect(result.len > 0); +} + + +test "extractLines: compact with Python comments" { + const content = "# comment\nimport os\n\ndef hello():\n # inline comment\n print('hi')"; + const result = try extractLines(content, 1, 6, false, true, .python, testing.allocator); + defer testing.allocator.free(result); + try testing.expect(std.mem.indexOf(u8, result, "# comment") == null); + try testing.expect(std.mem.indexOf(u8, result, "# inline comment") == null); + try testing.expect(std.mem.indexOf(u8, result, "import os") != null); + try testing.expect(std.mem.indexOf(u8, result, "def hello") != null); + try testing.expect(std.mem.indexOf(u8, result, "print('hi')") != null); +} + + +test "extractLines: compact with JS/TS comments" { + const content = "// header\nconst x = 1;\n/* block */\n* star line\nexport default x;"; + const result = try extractLines(content, 1, 5, false, true, .typescript, testing.allocator); + defer testing.allocator.free(result); + try testing.expect(std.mem.indexOf(u8, result, "// header") == null); + try testing.expect(std.mem.indexOf(u8, result, "/* block */") == null); + try testing.expect(std.mem.indexOf(u8, result, "* star line") == null); + try testing.expect(std.mem.indexOf(u8, result, "const x = 1;") != null); + try testing.expect(std.mem.indexOf(u8, result, "export default x;") != null); +} + + +test "isCommentOrBlank: rust double-slash" { + try testing.expect(isCommentOrBlank(" // rust comment", .rust)); + try testing.expect(!isCommentOrBlank(" let x = 1;", .rust)); +} + + +test "isCommentOrBlank: go double-slash" { + try testing.expect(isCommentOrBlank(" // go comment", .go_lang)); + try testing.expect(!isCommentOrBlank(" func main() {", .go_lang)); +} + + +test "isCommentOrBlank: dart comments" { + try testing.expect(isCommentOrBlank(" // dart comment", .dart)); + try testing.expect(isCommentOrBlank(" /* dart block comment */", .dart)); + try testing.expect(!isCommentOrBlank(" class WidgetBuilder {}", .dart)); +} + + +test "isCommentOrBlank: cpp block and line comments" { + try testing.expect(isCommentOrBlank(" // cpp line comment", .cpp)); + try testing.expect(isCommentOrBlank(" /* cpp block comment */", .cpp)); + try testing.expect(isCommentOrBlank(" * continued block comment", .cpp)); + try testing.expect(!isCommentOrBlank(" int x = 0;", .cpp)); +} + + +test "isCommentOrBlank: detected extension language comments" { + try testing.expect(isCommentOrBlank(" // java line comment", .java)); + try testing.expect(isCommentOrBlank(" // kotlin line comment", .kotlin)); + try testing.expect(isCommentOrBlank(" ", .svelte)); + try testing.expect(isCommentOrBlank(" ", .vue)); + try testing.expect(isCommentOrBlank(" ", .astro)); + try testing.expect(isCommentOrBlank(" # shell comment", .shell)); + try testing.expect(isCommentOrBlank(" /* css block comment */", .css)); + try testing.expect(isCommentOrBlank(" // scss line comment", .scss)); + try testing.expect(isCommentOrBlank(" -- sql comment", .sql)); + try testing.expect(isCommentOrBlank(" // proto comment", .protobuf)); + try testing.expect(isCommentOrBlank(" ! fortran comment", .fortran)); + try testing.expect(isCommentOrBlank(" ; llvm ir comment", .llvm_ir)); + try testing.expect(isCommentOrBlank(" // mlir comment", .mlir)); + try testing.expect(isCommentOrBlank(" // tablegen comment", .tablegen)); + try testing.expect(!isCommentOrBlank(" SELECT * FROM users;", .sql)); +} + + +test "isCommentOrBlank: tabs and mixed whitespace" { + try testing.expect(isCommentOrBlank("\t\t// tabbed comment", .zig)); + try testing.expect(isCommentOrBlank(" \t \t ", .zig)); + try testing.expect(isCommentOrBlank("\t", .python)); +} + + +test "isCommentOrBlank: markdown and json never strip" { + try testing.expect(!isCommentOrBlank("# heading", .markdown)); + try testing.expect(!isCommentOrBlank("// not a comment in json", .json)); + try testing.expect(!isCommentOrBlank("# not a comment in yaml", .yaml)); +} + + +test "explorer: getSymbolBody multi-line range" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + const content = "line1\nline2\nline3\nline4\nline5"; + try exp.indexFile("multi.zig", content); + + const body = try exp.getSymbolBody("multi.zig", 2, 4, testing.allocator); + if (body) |b| { + defer testing.allocator.free(b); + try testing.expect(std.mem.indexOf(u8, b, "line2") != null); + try testing.expect(std.mem.indexOf(u8, b, "line3") != null); + try testing.expect(std.mem.indexOf(u8, b, "line4") != null); + try testing.expect(std.mem.indexOf(u8, b, "line1") == null); + try testing.expect(std.mem.indexOf(u8, b, "line5") == null); + } else { + return error.TestUnexpectedResult; + } +} + + +test "explorer: getSymbolBody range beyond file length" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try exp.indexFile("short.zig", "only\ntwo"); + const body = try exp.getSymbolBody("short.zig", 1, 100, testing.allocator); + if (body) |b| { + defer testing.allocator.free(b); + try testing.expect(std.mem.indexOf(u8, b, "only") != null); + try testing.expect(std.mem.indexOf(u8, b, "two") != null); + } else { + return error.TestUnexpectedResult; + } +} + + +test "explorer: searchContentWithScope across multiple files" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try exp.indexFile("a.zig", "pub fn foo() void {\n doWork();\n}"); + try exp.indexFile("b.zig", "pub fn bar() void {\n doWork();\n}"); + + const results = try exp.searchContentWithScope("doWork", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + if (r.scope_name) |n| testing.allocator.free(n); + } + testing.allocator.free(results); + } + + try testing.expect(results.len == 2); + for (results) |r| { + try testing.expect(r.scope_name != null); + try testing.expect(r.line_num == 2); + } +} + + +test "explorer: searchContentWithScope respects max_results" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try exp.indexFile("many.zig", "pub fn a() void {\n target();\n target();\n target();\n target();\n}"); + + const results = try exp.searchContentWithScope("target", testing.allocator, 2); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + if (r.scope_name) |n| testing.allocator.free(n); + } + testing.allocator.free(results); + } + + try testing.expect(results.len == 2); +} + + +test "explorer: searchContentWithScope no results for missing query" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try exp.indexFile("empty.zig", "pub fn main() void {}"); + + const results = try exp.searchContentWithScope("nonexistent_xyz", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + if (r.scope_name) |n| testing.allocator.free(n); + } + testing.allocator.free(results); + } + + try testing.expect(results.len == 0); +} + + +test "content hash: format as hex string" { + const content = "hello world"; + const hash = std.hash.Wyhash.hash(0, content); + var buf: [16]u8 = undefined; + const hex = std.fmt.bufPrint(&buf, "{x}", .{hash}) catch unreachable; + for (hex) |c| { + try testing.expect((c >= '0' and c <= '9') or (c >= 'a' and c <= 'f')); + } + // Consistent on same content + const hash2 = std.hash.Wyhash.hash(0, content); + var buf2: [16]u8 = undefined; + const hex2 = std.fmt.bufPrint(&buf2, "{x}", .{hash2}) catch unreachable; + try testing.expectEqualStrings(hex, hex2); +} + + +test "content hash: empty content hashes consistently" { + const h1 = std.hash.Wyhash.hash(0, ""); + const h2 = std.hash.Wyhash.hash(0, ""); + try testing.expect(h1 == h2); +} + + +test "detectLanguage: all supported extensions" { + try testing.expect(explore.detectLanguage("main.zig") == .zig); + try testing.expect(explore.detectLanguage("lib.c") == .c); + try testing.expect(explore.detectLanguage("util.h") == .c); + try testing.expect(explore.detectLanguage("app.cpp") == .cpp); + try testing.expect(explore.detectLanguage("app.hpp") == .cpp); + try testing.expect(explore.detectLanguage("app.cc") == .cpp); + try testing.expect(explore.detectLanguage("app.hh") == .cpp); + try testing.expect(explore.detectLanguage("app.cxx") == .cpp); + try testing.expect(explore.detectLanguage("app.hxx") == .cpp); + try testing.expect(explore.detectLanguage("bridge.mm") == .cpp); + try testing.expect(explore.detectLanguage("script.py") == .python); + try testing.expect(explore.detectLanguage("app.js") == .javascript); + try testing.expect(explore.detectLanguage("comp.jsx") == .javascript); + try testing.expect(explore.detectLanguage("app.ts") == .typescript); + try testing.expect(explore.detectLanguage("comp.tsx") == .typescript); + try testing.expect(explore.detectLanguage("main.rs") == .rust); + try testing.expect(explore.detectLanguage("main.go") == .go_lang); + try testing.expect(explore.detectLanguage("app.dart") == .dart); + try testing.expect(explore.detectLanguage("README.md") == .markdown); + try testing.expect(explore.detectLanguage("pkg.json") == .json); + try testing.expect(explore.detectLanguage("config.yaml") == .yaml); + try testing.expect(explore.detectLanguage("config.yml") == .yaml); + try testing.expect(explore.detectLanguage("Main.java") == .java); + try testing.expect(explore.detectLanguage("App.kt") == .kotlin); + try testing.expect(explore.detectLanguage("Widget.svelte") == .svelte); + try testing.expect(explore.detectLanguage("Widget.vue") == .vue); + try testing.expect(explore.detectLanguage("Page.astro") == .astro); + try testing.expect(explore.detectLanguage("bootstrap.sh") == .shell); + try testing.expect(explore.detectLanguage("styles.css") == .css); + try testing.expect(explore.detectLanguage("styles.scss") == .scss); + try testing.expect(explore.detectLanguage("schema.sql") == .sql); + try testing.expect(explore.detectLanguage("service.proto") == .protobuf); + try testing.expect(explore.detectLanguage("solver.f90") == .fortran); + try testing.expect(explore.detectLanguage("module.ll") == .llvm_ir); + try testing.expect(explore.detectLanguage("dialect.mlir") == .mlir); + try testing.expect(explore.detectLanguage("records.td") == .tablegen); + try testing.expect(explore.detectLanguage("Makefile") == .unknown); + try testing.expect(explore.detectLanguage("no_ext") == .unknown); +} + + +test "explorer: getSymbolBody with line number format" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try exp.indexFile("fmt.zig", "const a = 1;\npub fn format() void {\n write();\n}\nconst b = 2;"); + + const body = try exp.getSymbolBody("fmt.zig", 2, 4, testing.allocator); + if (body) |b| { + defer testing.allocator.free(b); + try testing.expect(std.mem.indexOf(u8, b, " 2 |") != null); + try testing.expect(std.mem.indexOf(u8, b, " 3 |") != null); + try testing.expect(std.mem.indexOf(u8, b, " 4 |") != null); + try testing.expect(std.mem.indexOf(u8, b, "const a") == null); + try testing.expect(std.mem.indexOf(u8, b, "const b") == null); + } else { + return error.TestUnexpectedResult; + } +} + + +test "extractLines: compact preserves brace-only lines" { + const content = "fn main() void {\n // comment\n doWork();\n}"; + const result = try extractLines(content, 1, 4, false, true, .zig, testing.allocator); + defer testing.allocator.free(result); + try testing.expect(std.mem.indexOf(u8, result, "fn main") != null); + try testing.expect(std.mem.indexOf(u8, result, "}") != null); + try testing.expect(std.mem.indexOf(u8, result, "doWork") != null); + try testing.expect(std.mem.indexOf(u8, result, "// comment") == null); +} + + +test "extractLines: compact on all-comment file returns empty" { + const content = "// comment 1\n// comment 2\n// comment 3"; + const result = try extractLines(content, 1, 3, false, true, .zig, testing.allocator); + defer testing.allocator.free(result); + try testing.expect(result.len == 0); +} + + +test "explorer: searchContentRegex end-to-end" { + var explorer_inst = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer_inst.deinit(); + + try explorer_inst.indexFile("test1.zig", "pub fn recordSnapshot() void {}\nconst x = 42;"); + try explorer_inst.indexFile("test2.zig", "pub fn recordState() void {}\nconst y = 99;"); + try explorer_inst.indexFile("test3.zig", "const z = 0;\nfn other() void {}"); + + const results = try explorer_inst.searchContentRegex("record\\w+", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + try testing.expect(results.len >= 2); + // Both test1 and test2 should have matches + var found1 = false; + var found2 = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "test1.zig")) found1 = true; + if (std.mem.eql(u8, r.path, "test2.zig")) found2 = true; + } + try testing.expect(found1); + try testing.expect(found2); +} + + +test "explorer: searchContentRegex no match" { + var explorer_inst = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer_inst.deinit(); + + try explorer_inst.indexFile("only.zig", "const x = 42;"); + + const results = try explorer_inst.searchContentRegex("zzz\\d+qqq", testing.allocator, 50); + defer testing.allocator.free(results); + + try testing.expectEqual(@as(usize, 0), results.len); +} + + +test "git: getGitHead returns 40-char hex SHA in a git repo" { + // codedb itself is a git repo, so this should succeed + const head = try git_mod.getGitHead(".", testing.allocator); + try testing.expect(head != null); + const sha = head.?; + try testing.expectEqual(@as(usize, 40), sha.len); + for (sha) |c| { + try testing.expect(std.ascii.isHex(c)); + } +} + + +test "git: getGitHead returns null for non-git directory" { + // /tmp is not a git repo + const head = try git_mod.getGitHead("/tmp", testing.allocator); + try testing.expect(head == null); +} + + +test "thread-safe: concurrent TrigramIndex.candidates() with per-thread allocators" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + try ti.indexFile("a.zig", "pub fn handleRequest(ctx: *Context) void {}"); + try ti.indexFile("b.zig", "pub fn processData(buf: []u8) void {}"); + try ti.indexFile("c.zig", "pub fn handleRequest(req: Request) !void {}"); + const ThreadCtx = struct { + ti: *TrigramIndex, + errors: std.atomic.Value(u32) = std.atomic.Value(u32).init(0), + fn run(ctx: *@This()) void { + var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + for (0..200) |_| { + const cands = ctx.ti.candidates("handleRequest", alloc) orelse continue; + defer alloc.free(cands); + var found = false; + for (cands) |p| { + if (std.mem.eql(u8, p, "a.zig") or std.mem.eql(u8, p, "c.zig")) found = true; + } + if (!found) _ = ctx.errors.fetchAdd(1, .monotonic); + } + } + }; + var ctx = ThreadCtx{ .ti = &ti }; + var threads: [4]std.Thread = undefined; + for (&threads) |*t| t.* = try std.Thread.spawn(.{}, ThreadCtx.run, .{&ctx}); + for (threads) |t| t.join(); + try testing.expectEqual(@as(u32, 0), ctx.errors.load(.monotonic)); +} + + +test "thread-safe: concurrent SparseNgramIndex.candidates() with per-thread allocators" { + var sni = SparseNgramIndex.init(testing.allocator); + defer sni.deinit(); + try sni.indexFile("x.zig", "pub fn handleRequest(ctx: *Context) void {}"); + try sni.indexFile("y.zig", "pub fn processData(buf: []u8) void {}"); + const ThreadCtx = struct { + sni: *SparseNgramIndex, + errors: std.atomic.Value(u32) = std.atomic.Value(u32).init(0), + fn run(ctx: *@This()) void { + var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + for (0..200) |_| { + const cands = ctx.sni.candidates("handleRequest", alloc) orelse continue; + defer alloc.free(cands); + var found = false; + for (cands) |p| { + if (std.mem.eql(u8, p, "x.zig")) found = true; + } + if (!found) _ = ctx.errors.fetchAdd(1, .monotonic); + } + } + }; + var ctx = ThreadCtx{ .sni = &sni }; + var threads: [4]std.Thread = undefined; + for (&threads) |*t| t.* = try std.Thread.spawn(.{}, ThreadCtx.run, .{&ctx}); + for (threads) |t| t.join(); +} + + +test "issue-43: trigram_index swap in scanBg races with concurrent MCP queries" { + // Regression: the scanBg disk-load path must serialize trigram_index swaps + // with readers by taking exp.mu.lock() before replacing the index. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp.indexFile("a.zig", "pub fn handleAuth(token: []const u8) bool { return token.len > 0; }"); + + exp.mu.lockShared(); + + const SwapCtx = struct { + exp: *Explorer, + swapped: std.atomic.Value(bool) = std.atomic.Value(bool).init(false), + fn run(ctx: *@This()) void { + ctx.exp.mu.lock(); + defer ctx.exp.mu.unlock(); + ctx.exp.trigram_index.deinit(); + ctx.exp.trigram_index = .{ .heap = TrigramIndex.init(ctx.exp.allocator) }; + ctx.swapped.store(true, .release); + } + }; + var sctx = SwapCtx{ .exp = &exp }; + const t = try std.Thread.spawn(.{}, SwapCtx.run, .{&sctx}); + cio.sleepMs(10); + const raced = sctx.swapped.load(.acquire); + exp.mu.unlockShared(); + t.join(); + try testing.expect(!raced); +} + + +test "issue-116: getGitHead returns valid SHA for git repos" { + const git = @import("git.zig"); + + // This test runs inside the codedb repo itself + const head = git.getGitHead(".", testing.allocator) catch null; + + if (head) |h| { + try testing.expect(h.len == 40); + for (h) |c| { + try testing.expect(std.ascii.isHex(c)); + } + } +} + + +test "issue-224: codedb_symbol body=true returns full body — line_end populated" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("t.zig", + \\pub fn foo() u32 { + \\ const a: u32 = 1; + \\ const b: u32 = 2; + \\ return a + b; + \\} + ); + + const results = try explorer.findAllSymbols("foo", alloc); + defer alloc.free(results); + try testing.expect(results.len == 1); + + const sym = results[0].symbol; + try testing.expectEqual(@as(u32, 1), sym.line_start); + try testing.expectEqual(@as(u32, 5), sym.line_end); + + const body = (try explorer.getSymbolBody("t.zig", sym.line_start, sym.line_end, alloc)) orelse + return error.TestUnexpectedResult; + try testing.expect(std.mem.indexOf(u8, body, "pub fn foo()") != null); + try testing.expect(std.mem.indexOf(u8, body, "return a + b;") != null); +} + + +test "issue-224: Python def line_end covers full body" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("t.py", + \\def greet(name): + \\ msg = "hello" + \\ return msg + name + ); + + const results = try explorer.findAllSymbols("greet", alloc); + defer alloc.free(results); + try testing.expect(results.len == 1); + + const sym = results[0].symbol; + try testing.expectEqual(@as(u32, 1), sym.line_start); + try testing.expectEqual(@as(u32, 3), sym.line_end); +} + + +test "issue-108: detectLanguage handles .tf and .tfvars" { + try testing.expectEqual(Language.hcl, explore.detectLanguage("main.tf")); + try testing.expectEqual(Language.hcl, explore.detectLanguage("prod.tfvars")); + try testing.expectEqual(Language.hcl, explore.detectLanguage("config.hcl")); +} + + +test "issue-215: detectLanguage handles .r and .R" { + try testing.expectEqual(Language.r, explore.detectLanguage("script.r")); + try testing.expectEqual(Language.r, explore.detectLanguage("analysis.R")); +} + + +test "dep-graph: reverse index gives O(1) imported_by lookup" { + var graph = DependencyGraph.init(testing.allocator); + defer graph.deinit(); + + // main.zig imports store.zig and utils.zig + var deps1: std.ArrayList([]const u8) = .empty; + try deps1.append(testing.allocator, "store.zig"); + try deps1.append(testing.allocator, "utils.zig"); + try graph.setDeps("main.zig", deps1); + + // server.zig imports store.zig + var deps2: std.ArrayList([]const u8) = .empty; + try deps2.append(testing.allocator, "store.zig"); + try graph.setDeps("server.zig", deps2); + + // store.zig is imported by main.zig and server.zig + const imported_by = try graph.getImportedBy("store.zig", testing.allocator); + defer { + for (imported_by) |p| testing.allocator.free(p); + testing.allocator.free(imported_by); + } + try testing.expectEqual(@as(usize, 2), imported_by.len); + + // utils.zig is imported by main.zig only + const imported_by2 = try graph.getImportedBy("utils.zig", testing.allocator); + defer { + for (imported_by2) |p| testing.allocator.free(p); + testing.allocator.free(imported_by2); + } + try testing.expectEqual(@as(usize, 1), imported_by2.len); + try testing.expectEqualStrings("main.zig", imported_by2[0]); +} + + +test "dep-graph: setDeps removes old reverse edges" { + var graph = DependencyGraph.init(testing.allocator); + defer graph.deinit(); + + // main.zig initially imports store.zig + var deps1: std.ArrayList([]const u8) = .empty; + try deps1.append(testing.allocator, "store.zig"); + try graph.setDeps("main.zig", deps1); + + const before = try graph.getImportedBy("store.zig", testing.allocator); + defer { + for (before) |p| testing.allocator.free(p); + testing.allocator.free(before); + } + try testing.expectEqual(@as(usize, 1), before.len); + + // main.zig re-indexed, now imports utils.zig instead + var deps2: std.ArrayList([]const u8) = .empty; + try deps2.append(testing.allocator, "utils.zig"); + try graph.setDeps("main.zig", deps2); + + // store.zig should no longer have main.zig as a dependent + const after = try graph.getImportedBy("store.zig", testing.allocator); + defer { + for (after) |p| testing.allocator.free(p); + testing.allocator.free(after); + } + try testing.expectEqual(@as(usize, 0), after.len); + + // utils.zig should now have main.zig + const utils_deps = try graph.getImportedBy("utils.zig", testing.allocator); + defer { + for (utils_deps) |p| testing.allocator.free(p); + testing.allocator.free(utils_deps); + } + try testing.expectEqual(@as(usize, 1), utils_deps.len); +} + + +test "dep-graph: transitive dependents via BFS" { + var graph = DependencyGraph.init(testing.allocator); + defer graph.deinit(); + + // Build chain: app.zig -> server.zig -> store.zig -> utils.zig + var deps1: std.ArrayList([]const u8) = .empty; + try deps1.append(testing.allocator, "server.zig"); + try graph.setDeps("app.zig", deps1); + + var deps2: std.ArrayList([]const u8) = .empty; + try deps2.append(testing.allocator, "store.zig"); + try graph.setDeps("server.zig", deps2); + + var deps3: std.ArrayList([]const u8) = .empty; + try deps3.append(testing.allocator, "utils.zig"); + try graph.setDeps("store.zig", deps3); + + // Changing utils.zig affects store.zig, server.zig, app.zig transitively + const blast = try graph.getTransitiveDependents("utils.zig", testing.allocator, null); + defer { + for (blast) |p| testing.allocator.free(p); + testing.allocator.free(blast); + } + try testing.expectEqual(@as(usize, 3), blast.len); + + // With max_depth=1, only direct dependents + const shallow = try graph.getTransitiveDependents("utils.zig", testing.allocator, 1); + defer { + for (shallow) |p| testing.allocator.free(p); + testing.allocator.free(shallow); + } + try testing.expectEqual(@as(usize, 1), shallow.len); + try testing.expectEqualStrings("store.zig", shallow[0]); +} + + +test "dep-graph: transitive dependencies (forward BFS)" { + var graph = DependencyGraph.init(testing.allocator); + defer graph.deinit(); + + // app.zig -> server.zig -> store.zig -> utils.zig + var deps1: std.ArrayList([]const u8) = .empty; + try deps1.append(testing.allocator, "server.zig"); + try graph.setDeps("app.zig", deps1); + + var deps2: std.ArrayList([]const u8) = .empty; + try deps2.append(testing.allocator, "store.zig"); + try graph.setDeps("server.zig", deps2); + + var deps3: std.ArrayList([]const u8) = .empty; + try deps3.append(testing.allocator, "utils.zig"); + try graph.setDeps("store.zig", deps3); + + // app.zig transitively depends on server.zig, store.zig, utils.zig + const deps_all = try graph.getTransitiveDependencies("app.zig", testing.allocator, null); + defer { + for (deps_all) |p| testing.allocator.free(p); + testing.allocator.free(deps_all); + } + try testing.expectEqual(@as(usize, 3), deps_all.len); + + // Depth=2: app.zig -> server.zig -> store.zig (not utils.zig) + const deps_shallow = try graph.getTransitiveDependencies("app.zig", testing.allocator, 2); + defer { + for (deps_shallow) |p| testing.allocator.free(p); + testing.allocator.free(deps_shallow); + } + try testing.expectEqual(@as(usize, 2), deps_shallow.len); +} + + +test "dep-graph: remove cleans forward and reverse edges" { + var graph = DependencyGraph.init(testing.allocator); + defer graph.deinit(); + + var deps1: std.ArrayList([]const u8) = .empty; + try deps1.append(testing.allocator, "store.zig"); + try graph.setDeps("main.zig", deps1); + + var deps2: std.ArrayList([]const u8) = .empty; + try deps2.append(testing.allocator, "store.zig"); + try graph.setDeps("server.zig", deps2); + + try testing.expectEqual(@as(usize, 2), graph.count()); + + // Remove main.zig + graph.remove("main.zig"); + try testing.expectEqual(@as(usize, 1), graph.count()); + + // store.zig should only be imported by server.zig now + const imported_by = try graph.getImportedBy("store.zig", testing.allocator); + defer { + for (imported_by) |p| testing.allocator.free(p); + testing.allocator.free(imported_by); + } + try testing.expectEqual(@as(usize, 1), imported_by.len); + try testing.expectEqualStrings("server.zig", imported_by[0]); +} + + +test "dep-graph: cycle does not cause infinite BFS" { + var graph = DependencyGraph.init(testing.allocator); + defer graph.deinit(); + + // Create a cycle: a.zig -> b.zig -> c.zig -> a.zig + var deps1: std.ArrayList([]const u8) = .empty; + try deps1.append(testing.allocator, "b.zig"); + try graph.setDeps("a.zig", deps1); + + var deps2: std.ArrayList([]const u8) = .empty; + try deps2.append(testing.allocator, "c.zig"); + try graph.setDeps("b.zig", deps2); + + var deps3: std.ArrayList([]const u8) = .empty; + try deps3.append(testing.allocator, "a.zig"); + try graph.setDeps("c.zig", deps3); + + // Transitive dependents of a.zig — should terminate despite cycle + const blast = try graph.getTransitiveDependents("a.zig", testing.allocator, null); + defer { + for (blast) |p| testing.allocator.free(p); + testing.allocator.free(blast); + } + // b.zig and c.zig both transitively depend on a.zig + try testing.expectEqual(@as(usize, 2), blast.len); + + // Forward transitive deps from a.zig — should also terminate + const fwd = try graph.getTransitiveDependencies("a.zig", testing.allocator, null); + defer { + for (fwd) |p| testing.allocator.free(p); + testing.allocator.free(fwd); + } + try testing.expectEqual(@as(usize, 2), fwd.len); +} + + +test "dep-graph: Explorer integration — getImportedBy uses reverse index" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("store.zig", "pub const Store = struct {};"); + try explorer.indexFile("main.zig", "const store = @import(\"store.zig\");\npub fn main() void {}"); + try explorer.indexFile("server.zig", "const store = @import(\"store.zig\");\npub fn serve() void {}"); + + const deps = try explorer.getImportedBy("store.zig", testing.allocator); + defer { + for (deps) |d| testing.allocator.free(d); + testing.allocator.free(deps); + } + try testing.expectEqual(@as(usize, 2), deps.len); +} + + +test "dep-graph: Explorer transitive dependents" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("utils.zig", "pub fn helper() void {}"); + try explorer.indexFile("store.zig", "const utils = @import(\"utils.zig\");\npub const Store = struct {};"); + try explorer.indexFile("main.zig", "const store = @import(\"store.zig\");\npub fn main() void {}"); + + // Transitive: changing utils.zig affects store.zig and main.zig + const blast = try explorer.getTransitiveDependents("utils.zig", testing.allocator, null); + defer { + for (blast) |b| testing.allocator.free(b); + testing.allocator.free(blast); + } + try testing.expectEqual(@as(usize, 2), blast.len); +} + + +test "issue-445: dep-graph dedupes multi-aliased forward imports" { + // A file that imports the same dep under multiple aliases + // const idx = @import("index.zig"); + // const Index = @import("index.zig").Foo; + // const reset = @import("index.zig").resetFrequencyTable; + // produces multiple "index.zig" entries in outline.imports, which + // rebuildDepsFor previously appended verbatim — so getForwardDeps + // returned "index.zig" 5 times for src/main.zig in this very repo. + // The depends_on list should be unique by path. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("index.zig", "pub fn build() void {}"); + try explorer.indexFile("main.zig", + \\const idx = @import("index.zig"); + \\const Index = @import("index.zig").Foo; + \\const reset = @import("index.zig").resetFrequencyTable; + \\pub fn main() void {} + ); + + explorer.mu.lockShared(); + const fwd_opt = explorer.dep_graph.getForwardDeps("main.zig"); + explorer.mu.unlockShared(); + + try testing.expect(fwd_opt != null); + const fwd = fwd_opt.?; + try testing.expectEqual(@as(usize, 1), fwd.len); + try testing.expectEqualStrings("index.zig", fwd[0]); +} + + +test "symbol-index: O(1) findSymbol via symbol_index" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("math.zig", "pub fn add(a: i32, b: i32) i32 { return a + b; }\npub fn subtract(a: i32, b: i32) i32 { return a - b; }\n"); + try explorer.indexFile("utils.zig", "pub fn add(x: f64, y: f64) f64 { return x + y; }\npub fn format() void {}\n"); + + // findSymbol should return first match via index + const result = try explorer.findSymbol("add", testing.allocator); + try testing.expect(result != null); + const r = result.?; + defer { + testing.allocator.free(r.path); + testing.allocator.free(r.symbol.name); + if (r.symbol.detail) |d| testing.allocator.free(d); + } + try testing.expectEqualStrings("add", r.symbol.name); + + // findAllSymbols should return both + const all = try explorer.findAllSymbols("add", testing.allocator); + defer { + for (all) |s| { + testing.allocator.free(s.path); + testing.allocator.free(s.symbol.name); + if (s.symbol.detail) |d| testing.allocator.free(d); + } + testing.allocator.free(all); + } + try testing.expectEqual(@as(usize, 2), all.len); +} + + +test "symbol-index: removeFile cleans symbol_index" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("a.zig", "pub fn unique_func() void {}"); + const before = try explorer.findSymbol("unique_func", testing.allocator); + try testing.expect(before != null); + testing.allocator.free(before.?.path); + testing.allocator.free(before.?.symbol.name); + if (before.?.symbol.detail) |d| testing.allocator.free(d); + + explorer.removeFile("a.zig"); + + const after = try explorer.findSymbol("unique_func", testing.allocator); + try testing.expect(after == null); +} + + +test "symbol-index: re-index updates symbol_index" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("a.zig", "pub fn old_name() void {}"); + const r1 = try explorer.findSymbol("old_name", testing.allocator); + try testing.expect(r1 != null); + testing.allocator.free(r1.?.path); + testing.allocator.free(r1.?.symbol.name); + if (r1.?.symbol.detail) |d| testing.allocator.free(d); + + // Re-index same file with different content + try explorer.indexFile("a.zig", "pub fn new_name() void {}"); + const r2 = try explorer.findSymbol("old_name", testing.allocator); + try testing.expect(r2 == null); + + const r3 = try explorer.findSymbol("new_name", testing.allocator); + try testing.expect(r3 != null); + testing.allocator.free(r3.?.path); + testing.allocator.free(r3.?.symbol.name); + if (r3.?.symbol.detail) |d| testing.allocator.free(d); +} + + +test "word-index: splitIdentifier snake_case" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const a = arena.allocator(); + + var out: std.ArrayList([]const u8) = .empty; + defer out.deinit(a); + try splitIdentifier("get_or_put", &out, a); + + try testing.expectEqual(@as(usize, 3), out.items.len); + try testing.expectEqualStrings("get", out.items[0]); + try testing.expectEqualStrings("or", out.items[1]); + try testing.expectEqualStrings("put", out.items[2]); +} + + +test "word-index: splitIdentifier camelCase" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const a = arena.allocator(); + + var out: std.ArrayList([]const u8) = .empty; + defer out.deinit(a); + try splitIdentifier("validateToken", &out, a); + + try testing.expectEqual(@as(usize, 2), out.items.len); + try testing.expectEqualStrings("validate", out.items[0]); + try testing.expectEqualStrings("token", out.items[1]); +} + + +test "word-index: splitIdentifier acronym (HTTPHandler)" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const a = arena.allocator(); + + var out: std.ArrayList([]const u8) = .empty; + defer out.deinit(a); + try splitIdentifier("HTTPHandler", &out, a); + + try testing.expectEqual(@as(usize, 2), out.items.len); + try testing.expectEqualStrings("http", out.items[0]); + try testing.expectEqualStrings("handler", out.items[1]); +} + + +test "word-index: splitIdentifier simple word emits itself" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const a = arena.allocator(); + + var out: std.ArrayList([]const u8) = .empty; + defer out.deinit(a); + try splitIdentifier("handler", &out, a); + + try testing.expectEqual(@as(usize, 1), out.items.len); + try testing.expectEqualStrings("handler", out.items[0]); +} + + +test "word-index: sub-token search finds camelCase components" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("a.zig", "fn validateToken(x: u32) void {}"); + try explorer.indexFile("b.zig", "fn processRequest() void {}"); + + // "validate" should find validateToken via sub-token splitting + const r1 = try explorer.searchContent("validate", testing.allocator, 10); + defer { + for (r1) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(r1); + } + try testing.expectEqual(@as(usize, 1), r1.len); + try testing.expectEqualStrings("a.zig", r1[0].path); + + // "process" should find processRequest + const r2 = try explorer.searchContent("process", testing.allocator, 10); + defer { + for (r2) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(r2); + } + try testing.expectEqual(@as(usize, 1), r2.len); + try testing.expectEqualStrings("b.zig", r2[0].path); +} + + +test "word-index: sub-token search finds snake_case components" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("a.zig", "const http_handler = null;"); + + // "http" should find http_handler + const r1 = try explorer.searchContent("http", testing.allocator, 10); + defer { + for (r1) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(r1); + } + try testing.expect(r1.len >= 1); + + // "handler" should find http_handler + const r2 = try explorer.searchContent("handler", testing.allocator, 10); + defer { + for (r2) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(r2); + } + try testing.expect(r2.len >= 1); +} + + +test "word-index: case-insensitive lookup finds exact identifiers" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("a.zig", "fn validateToken() void {}"); + + // Case-insensitive search for the full identifier + const r1 = try explorer.searchContent("validatetoken", testing.allocator, 10); + defer { + for (r1) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(r1); + } + try testing.expectEqual(@as(usize, 1), r1.len); +} + + +test "word-index: searchPrefix finds extensions of a prefix" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const a = arena.allocator(); + var wi = WordIndex.init(a); + + // Index a file with camelCase identifiers — splits produce sub-tokens + try wi.indexFile("a.zig", "fn searchContent() void {} fn searchConfig() void {}"); + + // "searchco" is a strict prefix of "searchcontent" and "searchconfig" + const hits = try wi.searchPrefix("searchco", a, 32); + try testing.expect(hits.len >= 1); +} + + +test "word-index: searchPrefix skips exact match (Tier 0 responsibility)" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const a = arena.allocator(); + var wi = WordIndex.init(a); + + try wi.indexFile("a.zig", "fn searchContent() void {}"); + + // Exact key "search" exists (sub-token). searchPrefix should return 0 for exact key. + const hits_exact = try wi.searchPrefix("search", a, 32); + // "search" itself is in the index. Only keys STRICTLY longer are returned. + // "searchcontent" is longer, so we expect ≥1 result. + try testing.expect(hits_exact.len >= 1); + + // The hits must come from keys other than "search" itself. + // Verify by checking "searchc..." style prefix: + const hits_prefix = try wi.searchPrefix("searchco", a, 32); + try testing.expect(hits_prefix.len >= 1); +} + + +test "word-index: searchPrefix respects max_results cap" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const a = arena.allocator(); + var wi = WordIndex.init(a); + + // Index many distinct files producing many keys that share the "fooBar" prefix. + var i: usize = 0; + while (i < 50) : (i += 1) { + const path = try std.fmt.allocPrint(a, "f{d}.zig", .{i}); + const content = try std.fmt.allocPrint(a, "fn fooBar{d}() void {{}}\n", .{i}); + try wi.indexFile(path, content); + } + + const cap: usize = 5; + const hits = try wi.searchPrefix("foobar", a, cap); + try testing.expect(hits.len <= cap); + try testing.expect(hits.len > 0); +} + + +test "integration: Tier 0.5 prefix expansion finds partial identifier" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("util.zig", "pub fn validateRequest(r: Request) bool { return true; }"); + + // "validateR" is a prefix of "validaterequest" in the word index + const results = try explorer.searchContent("validateR", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + try testing.expect(results.len >= 1); +} + + +test "issue-389: FilteredWalker yields symlinked source files" { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + try tmp_dir.dir.createDirPath(io, "src"); + try tmp_dir.dir.writeFile(io, .{ .sub_path = "src/target.zig", .data = "pub fn linked() void {}\n// MARKER_LINE\n" }); + + // Create an in-workspace symlink: src/alias.zig -> target.zig (relative). + var src_dir = try tmp_dir.dir.openDir(io, "src", .{ .iterate = true }); + defer src_dir.close(io); + src_dir.symLink(io, "target.zig", "alias.zig", .{}) catch |err| switch (err) { + // If the OS denies symlinks (e.g. CI without privilege on Windows), + // skip the test rather than report a false negative. + error.AccessDenied => return error.SkipZigTest, + else => return err, + }; + + var root_buf: [std.fs.max_path_bytes]u8 = undefined; + const root_len = try tmp_dir.dir.realPathFile(io, ".", &root_buf); + const root = root_buf[0..root_len]; + + var store = Store.init(testing.allocator); + defer store.deinit(); + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + explorer.setRoot(io, root); + try watcher.initialScanWithWorkerCount(io, &store, &explorer, root, testing.allocator, false, 1); + + // Both the real file and the symlinked alias must be indexed. The bug at + // src/watcher.zig:319 drops every entry whose kind != .file, silently + // skipping symlinks even when they point at in-workspace source files. + try testing.expect(explorer.contents.contains("src/target.zig")); + try testing.expect(explorer.contents.contains("src/alias.zig")); +} + + +test "issue-405: FilteredWalker walks directory symlinks safely (cycle + escape)" { + // Follow-up to #389. The current FilteredWalker.next() (src/watcher.zig:319-323) + // treats sym_link entries as files when statFile reports .file, but silently + // drops sym_link entries whose target is a directory. Real repos rely on + // directory symlinks (monorepo package links, vendored deps, dotfile configs), + // so the indexer must walk them — but only safely. This test pins three things: + // 1. A file inside a symlinked subdirectory is indexed. + // 2. A symlink that introduces a cycle does not hang or duplicate entries. + // 3. (Implicit) The walker terminates in bounded time on the fixture. + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + // Real directory `pkg/` with one source file. + try tmp_dir.dir.createDirPath(io, "pkg"); + try tmp_dir.dir.writeFile(io, .{ .sub_path = "pkg/inside.zig", .data = "pub fn inside() void {}\n" }); + + // A real directory `app/` that holds a directory-symlink `linked_pkg -> ../pkg`. + // We expect the walker to descend into `linked_pkg` and yield `app/linked_pkg/inside.zig`. + try tmp_dir.dir.createDirPath(io, "app"); + var app_dir = try tmp_dir.dir.openDir(io, "app", .{ .iterate = true }); + defer app_dir.close(io); + app_dir.symLink(io, "../pkg", "linked_pkg", .{}) catch |err| switch (err) { + // Skip on platforms / CI configurations that deny symlink creation. + error.AccessDenied => return error.SkipZigTest, + else => return err, + }; + + // Cycle: `app/loop -> ..` points back at the workspace root. Without cycle + // detection a naive walker recurses forever via app/loop/app/loop/app/... + app_dir.symLink(io, "..", "loop", .{}) catch |err| switch (err) { + error.AccessDenied => return error.SkipZigTest, + else => return err, + }; + + var root_buf: [std.fs.max_path_bytes]u8 = undefined; + const root_len = try tmp_dir.dir.realPathFile(io, ".", &root_buf); + const root = root_buf[0..root_len]; + + var store = Store.init(testing.allocator); + defer store.deinit(); + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + explorer.setRoot(io, root); + try watcher.initialScanWithWorkerCount(io, &store, &explorer, root, testing.allocator, false, 1); + + // 1. The in-target file must appear under the symlinked path. This is the + // behaviour gap left by #389 — directory symlinks are currently ignored, + // so this assertion fails on main. + try testing.expect(explorer.contents.contains("app/linked_pkg/inside.zig")); + + // 2. The real path must also be indexed exactly once. + try testing.expect(explorer.contents.contains("pkg/inside.zig")); + + // 3. The cycle must not have produced a deeply-nested duplicate entry. + // If cycle detection is missing, paths like + // `app/loop/app/loop/app/linked_pkg/inside.zig` would appear (or the + // scan would never terminate). Assert no path contains "loop/app/loop". + var it = explorer.contents.iterator(); + while (it.next()) |kv| { + const p = kv.key_ptr.*; + try testing.expect(std.mem.indexOf(u8, p, "loop/app/loop") == null); + } +} + + +test "issue-405: cleanupStaleTmpFiles deletes in-flight sibling tmp files" { + // BUG: snapshot.zig:cleanupStaleTmpFiles deletes ANY file matching + // `*.tmp` in the snapshot directory with no age guard. + // If a sibling writer (another process / parallel scan) is mid-write + // — i.e. it has just created `..tmp` and is still + // streaming bytes into it before the final rename(tmp, dest) — then a + // concurrent loadSnapshotValidated() will unlink the sibling's + // in-flight tmp file. The sibling's subsequent rename then fails with + // ENOENT and the snapshot write silently aborts. + // + // Reproduces deterministically by simulating the in-flight tmp file + // and observing that loadSnapshotValidated removes it. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const aa = arena.allocator(); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + // Step 1: write a real, valid snapshot at /snap.codedb so + // loadSnapshotValidated has something legitimate to read. + var exp = Explorer.init(aa, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp.indexFile("a.zig", "pub fn alpha() void {}\n"); + const snap_path = try std.fs.path.join(aa, &.{ dir_path, "snap.codedb" }); + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, aa); + + // Step 2: simulate a SIBLING writer that has just created its tmp file + // but has NOT yet renamed. This file matches the cleanup pattern + // (starts with basename, ends with ".tmp"). + const sibling_tmp = try std.fs.path.join(aa, &.{ dir_path, "snap.codedb.deadbeef.tmp" }); + { + var f = try std.Io.Dir.cwd().createFile(io, sibling_tmp, .{}); + defer f.close(io); + try f.writeStreamingAll(io, "in-flight write"); + } + + // Sanity: the sibling tmp exists. + std.Io.Dir.cwd().access(io, sibling_tmp, .{}) catch return error.TestUnexpectedResult; + + // Step 3: run loadSnapshotValidated. cleanupStaleTmpFiles is the + // first thing it does. After this, the sibling's in-flight tmp + // file MUST still exist — otherwise the sibling's rename will fail. + var exp2 = Explorer.init(aa, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store = Store.init(testing.allocator); + defer store.deinit(); + _ = snapshot_mod.loadSnapshotValidated(io, snap_path, null, &exp2, &store, aa); + + // Expected: the in-flight sibling tmp is preserved. + // Current (bug): cleanupStaleTmpFiles unconditionally deletes it. + std.Io.Dir.cwd().access(io, sibling_tmp, .{}) catch { + return error.TestExpectedSiblingTmpPreserved; + }; +} + + +test "issue-409: snapshot .env prefix filter wrongly excludes .envoy/.environment files" { + // BUG: snapshot.zig:isSensitivePath uses + // if (basename.len >= 4 and std.mem.eql(u8, basename[0..4], ".env")) return true; + // to catch .env, .env.local, .env.production, etc. The check is a raw + // 4-byte prefix match — so any basename whose first 4 bytes are ".env" + // is rejected, including legitimate, non-secret files such as: + // + // .envoy.json — Envoy proxy config + // .environment — generic config name + // .envconfig.yaml — anything starting with ".env" + // + // These files end up silently dropped from the snapshot's CONTENT, + // TREE, and OUTLINE_STATE sections, so a save/load round-trip loses + // them entirely. The watcher.zig copy of isSensitivePath has the same + // bug, so they are also excluded from live indexing. + // + // Reproducer: index a non-secret .envoy.json alongside a normal file, + // snapshot, load, and observe that .envoy.json is missing. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const aa = arena.allocator(); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + var exp = Explorer.init(aa, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp.indexFile("a.zig", "pub fn alpha() void {}\n"); + // .envoy.json is the canonical Envoy proxy config name — not a secret. + try exp.indexFile(".envoy.json", "{\"listeners\":[]}\n"); + try testing.expectEqual(@as(usize, 2), exp.outlines.count()); + + const snap_path = try std.fs.path.join(aa, &.{ dir_path, "snap.codedb" }); + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, aa); + + var exp2 = Explorer.init(aa, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store = Store.init(testing.allocator); + defer store.deinit(); + try testing.expect(snapshot_mod.loadSnapshot(io, snap_path, &exp2, &store, aa)); + + // Expected: both files round-trip through the snapshot. + // Current (bug): only "a.zig" survives — ".envoy.json" was excluded by + // the .env prefix check at write time. + try testing.expect(exp2.outlines.contains("a.zig")); + try testing.expect(exp2.outlines.contains(".envoy.json")); +} + + +test "issue-208: content cache evicts cold entries under pressure" { + const ContentCache = @import("hot_cache.zig").ContentCache; + const cap = 50; + var cache = try ContentCache.initAlloc(testing.allocator, cap); + defer cache.deinit(); + + var key_buf: [32]u8 = undefined; + var val_buf: [32]u8 = undefined; + + // Insert 100 keys into a cache with capacity 50. + var i: usize = 0; + while (i < 100) : (i += 1) { + const k = std.fmt.bufPrint(&key_buf, "file_{d}.zig", .{i}) catch unreachable; + const v = std.fmt.bufPrint(&val_buf, "content_{d}", .{i}) catch unreachable; + try cache.put(k, v); + } + + // Cache must not exceed capacity. + try testing.expect(cache.len() <= cap); + + // Touch keys 0..10 to mark them hot (set ref bit). + i = 0; + while (i < 10) : (i += 1) { + const k = std.fmt.bufPrint(&key_buf, "file_{d}.zig", .{i}) catch unreachable; + _ = cache.get(k); + } + + // Insert 20 more keys to trigger further eviction. + i = 100; + while (i < 120) : (i += 1) { + const k = std.fmt.bufPrint(&key_buf, "file_{d}.zig", .{i}) catch unreachable; + const v = std.fmt.bufPrint(&val_buf, "content_{d}", .{i}) catch unreachable; + try cache.put(k, v); + } + + // Still bounded by capacity. + try testing.expect(cache.len() <= cap); + + // Evictions must have fired. + const s = cache.stats(); + try testing.expect(s.evictions > 0); +} + diff --git a/src/test_index.zig b/src/test_index.zig new file mode 100644 index 0000000..b8f3dba --- /dev/null +++ b/src/test_index.zig @@ -0,0 +1,2956 @@ +const std = @import("std"); +const cio = @import("cio.zig"); +const testing = std.testing; +const io = std.testing.io; +const Store = @import("store.zig").Store; +const Explorer = @import("explore.zig").Explorer; +const WordIndex = @import("index.zig").WordIndex; +const TrigramIndex = @import("index.zig").TrigramIndex; +const SparseNgramIndex = @import("index.zig").SparseNgramIndex; +const pairWeight = @import("index.zig").pairWeight; +const extractSparseNgrams = @import("index.zig").extractSparseNgrams; +const buildCoveringSet = @import("index.zig").buildCoveringSet; +const setFrequencyTable = @import("index.zig").setFrequencyTable; +const resetFrequencyTable = @import("index.zig").resetFrequencyTable; +const buildFrequencyTable = @import("index.zig").buildFrequencyTable; +const writeFrequencyTable = @import("index.zig").writeFrequencyTable; +const readFrequencyTable = @import("index.zig").readFrequencyTable; +const explore = @import("explore.zig"); +const Language = explore.Language; +const git_mod = @import("git.zig"); +const decomposeRegex = @import("index.zig").decomposeRegex; +const RegexQuery = @import("index.zig").RegexQuery; +const packTrigram = @import("index.zig").packTrigram; +const regexMatch = explore.regexMatch; +const PostingMask = @import("index.zig").PostingMask; +const normalizeChar = @import("index.zig").normalizeChar; +const Trigram = @import("index.zig").Trigram; +const MmapTrigramIndex = @import("index.zig").MmapTrigramIndex; +const AnyTrigramIndex = @import("index.zig").AnyTrigramIndex; +const version = @import("version.zig"); +const watcher = @import("watcher.zig"); +const AgentRegistry = @import("agent.zig").AgentRegistry; +const snapshot_mod = @import("snapshot.zig"); +const snapshot_json = @import("snapshot_json.zig"); +const mcp_mod = @import("mcp.zig"); +const SearchResult = @import("explore.zig").SearchResult; +const SymbolKind = explore.SymbolKind; +const edit_mod = @import("edit.zig"); + + + + + + + + + + + + + + + + + + + + + + +test "trigram index: index and candidate lookup" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("src/store.zig", "pub fn recordSnapshot(self: *Store) void {}"); + try ti.indexFile("src/agent.zig", "pub fn register(self: *Agent) void {}"); + + const cands = ti.candidates("recordSnapshot", testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + try testing.expect(cands.?.len == 1); + try testing.expectEqualStrings("src/store.zig", cands.?[0]); +} + + +test "trigram index: short query returns null" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("f.zig", "hello world"); + const cands = ti.candidates("hi", testing.allocator); + try testing.expect(cands == null); +} + + +test "trigram index: no match returns empty" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("f.zig", "hello world"); + const cands = ti.candidates("zzzzz", testing.allocator); + try testing.expect(cands != null); + try testing.expect(cands.?.len == 0); +} + + +test "trigram index: re-index removes old trigrams" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("f.zig", "uniqueOldContent"); + const c1 = ti.candidates("uniqueOld", testing.allocator); + defer if (c1) |c| testing.allocator.free(c); + try testing.expect(c1 != null and c1.?.len == 1); + + try ti.indexFile("f.zig", "brandNewStuff"); + const c2 = ti.candidates("uniqueOld", testing.allocator); + defer if (c2) |c| testing.allocator.free(c); + try testing.expect(c2 != null and c2.?.len == 0); + + const c3 = ti.candidates("brandNew", testing.allocator); + defer if (c3) |c| testing.allocator.free(c); + try testing.expect(c3 != null and c3.?.len == 1); +} + + +test "pairWeight: deterministic" { + const w1 = pairWeight('a', 'b'); + const w2 = pairWeight('a', 'b'); + try testing.expectEqual(w1, w2); + + const w3 = pairWeight('a', 'c'); + // Different pair must (almost certainly) produce a different weight. + // We only assert they're not trivially equal; hash collisions are acceptable. + _ = w3; // just ensure it compiles and doesn't crash +} + + +test "pairWeight: different pairs produce different values (sanity)" { + // 'ab' and 'ba' should almost never collide for a reasonable hash. + const w_ab = pairWeight('a', 'b'); + const w_ba = pairWeight('b', 'a'); + // Not a strict requirement (collisions are ok), but verify the function runs. + _ = w_ab; + _ = w_ba; +} + + +test "extractSparseNgrams: short content returns empty" { + const ng = try extractSparseNgrams("ab", testing.allocator); + defer testing.allocator.free(ng); + try testing.expectEqual(@as(usize, 0), ng.len); +} + + +test "extractSparseNgrams: minimum length content yields one ngram" { + const ng = try extractSparseNgrams("abc", testing.allocator); + defer testing.allocator.free(ng); + try testing.expect(ng.len >= 1); + try testing.expectEqual(@as(usize, 3), ng[0].len); + try testing.expectEqual(@as(usize, 0), ng[0].pos); +} + + +test "extractSparseNgrams: deterministic across calls" { + const ng1 = try extractSparseNgrams("hello world", testing.allocator); + defer testing.allocator.free(ng1); + const ng2 = try extractSparseNgrams("hello world", testing.allocator); + defer testing.allocator.free(ng2); + + try testing.expectEqual(ng1.len, ng2.len); + for (ng1, ng2) |a, b| { + try testing.expectEqual(a.hash, b.hash); + try testing.expectEqual(a.pos, b.pos); + try testing.expectEqual(a.len, b.len); + } +} + + +test "extractSparseNgrams: case-insensitive hashing" { + const ng_lower = try extractSparseNgrams("hello", testing.allocator); + defer testing.allocator.free(ng_lower); + const ng_upper = try extractSparseNgrams("HELLO", testing.allocator); + defer testing.allocator.free(ng_upper); + + try testing.expectEqual(ng_lower.len, ng_upper.len); + for (ng_lower, ng_upper) |lo, hi| { + try testing.expectEqual(lo.hash, hi.hash); + } +} + + +test "extractSparseNgrams: ngrams cover entire content" { + const content = "the quick brown fox"; + const ng = try extractSparseNgrams(content, testing.allocator); + defer testing.allocator.free(ng); + + // Verify every byte position is covered by at least one n-gram. + var covered = try testing.allocator.alloc(bool, content.len); + defer testing.allocator.free(covered); + @memset(covered, false); + + for (ng) |n| { + for (n.pos..n.pos + n.len) |p| { + covered[p] = true; + } + } + for (covered) |c| { + try testing.expect(c); + } +} + + +test "extractSparseNgrams: coverage with force-split remainder 1 (len=17)" { + // 17 identical chars → no interior local maxima → one span of length 17. + // Force-split: one MAX_NGRAM_LEN=16 chunk, remainder=1 → must still cover byte 16. + const content = "aaaaaaaaaaaaaaaaa"; // 17 'a's + const ng = try extractSparseNgrams(content, testing.allocator); + defer testing.allocator.free(ng); + + var covered = try testing.allocator.alloc(bool, content.len); + defer testing.allocator.free(covered); + @memset(covered, false); + for (ng) |n| { + for (n.pos..n.pos + n.len) |p| covered[p] = true; + } + for (covered) |c| try testing.expect(c); +} + + +test "extractSparseNgrams: coverage with force-split remainder 2 (len=18)" { + // 18 identical chars → remainder=2 → must still cover bytes 16-17. + const content = "aaaaaaaaaaaaaaaaaa"; // 18 'a's + const ng = try extractSparseNgrams(content, testing.allocator); + defer testing.allocator.free(ng); + + var covered = try testing.allocator.alloc(bool, content.len); + defer testing.allocator.free(covered); + @memset(covered, false); + for (ng) |n| { + for (n.pos..n.pos + n.len) |p| covered[p] = true; + } + for (covered) |c| try testing.expect(c); +} + + +test "extractSparseNgrams: ngram length bounds" { + const content = "abcdefghijklmnopqrstuvwxyz0123456789"; + const ng = try extractSparseNgrams(content, testing.allocator); + defer testing.allocator.free(ng); + + for (ng) |n| { + try testing.expect(n.len >= 3); + try testing.expect(n.len <= 16); + } +} + + +test "buildCoveringSet: sliding window covers all query substrings" { + // "foobar" (6 chars); lengths [3,6] yield 4+3+2+1 = 10 substrings. + const ngrams = try buildCoveringSet("foobar", testing.allocator); + defer testing.allocator.free(ngrams); + try testing.expectEqual(@as(usize, 10), ngrams.len); + for (ngrams) |ng| try testing.expect(ng.len >= 3 and ng.len <= 6); +} + + +test "buildCoveringSet: short query returns empty" { + const ngrams = try buildCoveringSet("ab", testing.allocator); + defer testing.allocator.free(ngrams); + try testing.expectEqual(@as(usize, 0), ngrams.len); +} + + +test "sparse ngram index: index and candidate lookup" { + var sni = SparseNgramIndex.init(testing.allocator); + defer sni.deinit(); + + // Index each file with content equal to the query we'll use — this + // guarantees the sparse n-gram boundaries align (same string = same weights). + const foo_query = "recordSnapshot"; + const bar_query = "registerAgent"; + try sni.indexFile("src/foo.zig", foo_query); + try sni.indexFile("src/bar.zig", bar_query); + + const cands = sni.candidates(foo_query, testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + + var found_foo = false; + var found_bar = false; + if (cands) |cs| { + for (cs) |p| { + if (std.mem.eql(u8, p, "src/foo.zig")) found_foo = true; + if (std.mem.eql(u8, p, "src/bar.zig")) found_bar = true; + } + } + try testing.expect(found_foo); + try testing.expect(!found_bar); +} + + +test "sparse ngram index: short query returns null" { + var sni = SparseNgramIndex.init(testing.allocator); + defer sni.deinit(); + + try sni.indexFile("f.zig", "hello world"); + const cands = sni.candidates("hi", testing.allocator); // length 2 < MIN_LEN + try testing.expect(cands == null); +} + + +test "sparse ngram index: re-index removes old ngrams" { + var sni = SparseNgramIndex.init(testing.allocator); + defer sni.deinit(); + + try sni.indexFile("f.zig", "uniqueOldContent"); + const c1 = sni.candidates("uniqueOldContent", testing.allocator); + defer if (c1) |c| testing.allocator.free(c); + try testing.expect(c1 != null and c1.?.len == 1); + + try sni.indexFile("f.zig", "brandNewStuff"); + const c2 = sni.candidates("uniqueOldContent", testing.allocator); + defer if (c2) |c| testing.allocator.free(c); + // After re-index the old content is gone; may return empty or null. + if (c2) |cs| try testing.expectEqual(@as(usize, 0), cs.len); +} + + +test "sparse ngram index: removeFile prunes entries" { + var sni = SparseNgramIndex.init(testing.allocator); + defer sni.deinit(); + + try sni.indexFile("a.zig", "hello world foo bar"); + try testing.expectEqual(@as(u32, 1), sni.fileCount()); + + sni.removeFile("a.zig"); + try testing.expectEqual(@as(u32, 0), sni.fileCount()); +} + + +test "sparse ngram candidates: sliding window finds file with short n-gram" { + var sni = SparseNgramIndex.init(testing.allocator); + defer sni.deinit(); + + // "a.zig" is indexed with content "rec" — produces the 3-char n-gram "rec". + // "b.zig" is indexed with unrelated content. + try sni.indexFile("a.zig", "rec"); + try sni.indexFile("b.zig", "xxxxxxxxxx"); + + // Query "record" (6 chars) contains "rec" as a 3-char sliding-window + // substring. buildCoveringSet generates "rec" → hash matches the indexed + // n-gram of "a.zig". + const cands = sni.candidates("record", testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + + var found_a = false; + if (cands) |cs| { + for (cs) |p| if (std.mem.eql(u8, p, "a.zig")) { + found_a = true; + }; + } + try testing.expect(found_a); +} + + +test "pairWeight: common pairs have lower weight than rare pairs" { + // Common English/code pairs should have lower base weight than rare pairs. + // 'th' and 'er' are in the default_pair_freq table with weight 0x1000. + // 'qx' and 'zj' are not in the table and default to 0xFE00. + // jitter adds 0-255, so common+max_jitter (0x10FF) < rare+min_jitter (0xFE00). + const w_th = pairWeight('t', 'h'); + const w_er = pairWeight('e', 'r'); + const w_qx = pairWeight('q', 'x'); + const w_zj = pairWeight('z', 'j'); + try testing.expect(w_th < w_qx); + try testing.expect(w_er < w_zj); +} + + +test "pairWeight: frequency-weighted produces fewer boundaries for common text" { + // A string composed of very common pairs should produce few local maxima + // (interior weights are low and similar), giving fewer n-grams than a + // string of rare pairs. + const common = "thehereinandonthere"; + const rare = "qxzjvkqxzjvkqxzjvk"; + const ng_common = try extractSparseNgrams(common, testing.allocator); + defer testing.allocator.free(ng_common); + const ng_rare = try extractSparseNgrams(rare, testing.allocator); + defer testing.allocator.free(ng_rare); + // Rare pairs create more local maxima → more (shorter) n-grams. + try testing.expect(ng_rare.len >= ng_common.len); +} + + +test "pairWeight: deterministic with frequency table" { + const w1 = pairWeight('a', 'b'); + const w2 = pairWeight('a', 'b'); + try testing.expectEqual(w1, w2); + // Verify common and rare pairs also remain deterministic. + try testing.expectEqual(pairWeight('t', 'h'), pairWeight('t', 'h')); + try testing.expectEqual(pairWeight('q', 'x'), pairWeight('q', 'x')); +} + + +test "buildFrequencyTable: common pairs get lower weight than absent pairs" { + // Construct content where 'ab' appears many times and 'qx' never appears. + const content = "ababababababababababab"; + const table = buildFrequencyTable(content); + // 'ab' is frequent → low weight; 'qx' absent → default high (0xFE00). + try testing.expect(table['a']['b'] < table['q']['x']); + try testing.expectEqual(@as(u16, 0xFE00), table['q']['x']); +} + + +test "frequency table: disk round-trip" { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + var dir_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp_dir.dir.realPathFile(io, ".", &dir_buf); + const dir_path = dir_buf[0..dir_path_len]; + + // Build a table with distinct values. + const content = "ababcdcdefefghghijij"; + const original = buildFrequencyTable(content); + + try writeFrequencyTable(io, &original, dir_path); + + const loaded_opt = try readFrequencyTable(io, dir_path, testing.allocator); + try testing.expect(loaded_opt != null); + const loaded = loaded_opt.?; + defer testing.allocator.destroy(loaded); + + // Byte-for-byte identical. + try testing.expectEqualSlices( + u16, + @as([*]const u16, @ptrCast(&original))[0 .. 256 * 256], + @as([*]const u16, @ptrCast(loaded))[0 .. 256 * 256], + ); +} + + +test "frequency table: little-endian byte order on disk" { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + var dir_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp_dir.dir.realPathFile(io, ".", &dir_buf); + const dir_path = dir_buf[0..dir_path_len]; + + var table: [256][256]u16 = .{.{0} ** 256} ** 256; + table[0][0] = 0x1234; // little-endian on disk: 0x34, 0x12 + table[0][1] = 0xABCD; // little-endian on disk: 0xCD, 0xAB + try writeFrequencyTable(io, &table, dir_path); + + const file_path = try std.fmt.allocPrint(testing.allocator, "{s}/pair_freq.bin", .{dir_path}); + defer testing.allocator.free(file_path); + const f = try std.Io.Dir.cwd().openFile(io, file_path, .{}); + defer f.close(io); + var raw: [4]u8 = undefined; + try testing.expectEqual(@as(usize, 4), try f.readPositionalAll(io, &raw, 0)); + try testing.expectEqual(@as(u8, 0x34), raw[0]); + try testing.expectEqual(@as(u8, 0x12), raw[1]); + try testing.expectEqual(@as(u8, 0xCD), raw[2]); + try testing.expectEqual(@as(u8, 0xAB), raw[3]); + + const loaded = try readFrequencyTable(io, dir_path, testing.allocator); + try testing.expect(loaded != null); + defer testing.allocator.destroy(loaded.?); + try testing.expectEqual(@as(u16, 0x1234), loaded.?[0][0]); + try testing.expectEqual(@as(u16, 0xABCD), loaded.?[0][1]); +} + + +test "setFrequencyTable / resetFrequencyTable: pairWeight output changes" { + // Build a table where 'th' is rare (high weight) — opposite of default. + var custom: [256][256]u16 = .{.{0x1000} ** 256} ** 256; // all common + custom['q']['x'] = 0xFE00; // make 'qx' rare + + const before_th = pairWeight('t', 'h'); + const before_qx = pairWeight('q', 'x'); + + setFrequencyTable(&custom); + defer resetFrequencyTable(); + + const after_th = pairWeight('t', 'h'); + const after_qx = pairWeight('q', 'x'); + + // After swap: 'th' should be lower (we set it to 0x1000 vs default table's 0x1000 — same). + // What definitely changes: 'qx' base shifts from 0xFE00 to 0xFE00 (custom kept it high). + // More importantly verify that resetting restores original values. + resetFrequencyTable(); + try testing.expectEqual(before_th, pairWeight('t', 'h')); + try testing.expectEqual(before_qx, pairWeight('q', 'x')); + _ = after_th; + _ = after_qx; +} + + +test "file versions: append and latest" { + var fv = version.FileVersions.init(testing.allocator, "test.zig"); + defer fv.deinit(); + + try fv.versions.append(testing.allocator, .{ + .seq = 1, + .agent = 0, + .timestamp = 0, + .op = .snapshot, + .hash = 0x11, + .size = 100, + }); + try fv.versions.append(testing.allocator, .{ + .seq = 2, + .agent = 0, + .timestamp = 0, + .op = .replace, + .hash = 0x22, + .size = 150, + }); + + const latest = fv.latest().?; + try testing.expect(latest.seq == 2); + try testing.expect(latest.size == 150); +} + + +test "file versions: countSince" { + var fv = version.FileVersions.init(testing.allocator, "test.zig"); + defer fv.deinit(); + + try fv.versions.append(testing.allocator, .{ + .seq = 1, + .agent = 0, + .timestamp = 0, + .op = .snapshot, + .hash = 0, + .size = 0, + }); + try fv.versions.append(testing.allocator, .{ + .seq = 5, + .agent = 0, + .timestamp = 0, + .op = .replace, + .hash = 0, + .size = 0, + }); + try fv.versions.append(testing.allocator, .{ + .seq = 10, + .agent = 0, + .timestamp = 0, + .op = .delete, + .hash = 0, + .size = 0, + }); + + try testing.expect(fv.countSince(0) == 3); + try testing.expect(fv.countSince(1) == 2); + try testing.expect(fv.countSince(5) == 1); + try testing.expect(fv.countSince(10) == 0); +} + + +test "watcher: queue overflow is explicit" { + var queue = watcher.EventQueue{}; + + var pushed: usize = 0; + while (true) : (pushed += 1) { + var path_buf: [32]u8 = undefined; + const path = try std.fmt.bufPrint(&path_buf, "tmp/f-{d}.zig", .{pushed}); + if (!queue.push(watcher.FsEvent.init(path, .modified, @intCast(pushed)) orelse unreachable)) break; + } + + var overflow_path_buf: [32]u8 = undefined; + const overflow_path = try std.fmt.bufPrint(&overflow_path_buf, "tmp/overflow.zig", .{}); + try testing.expect(!queue.push(watcher.FsEvent.init(overflow_path, .created, 999) orelse unreachable)); + + var popped: usize = 0; + while (queue.pop() != null) : (popped += 1) {} + try testing.expect(popped == pushed); +} + + +test "watcher: queue event copies path bytes" { + var queue = watcher.EventQueue{}; + const original = try testing.allocator.dupe(u8, "tmp/deleted.zig"); + try testing.expect(queue.push(watcher.FsEvent.init(original, .deleted, 99) orelse unreachable)); + testing.allocator.free(original); + + const event = queue.pop() orelse return error.TestUnexpectedResult; + try testing.expectEqualStrings("tmp/deleted.zig", event.path()); + try testing.expect(event.kind == .deleted); + try testing.expect(event.seq == 99); +} + + +test "watcher: parallel initial scan matches sequential results" { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + try tmp_dir.dir.createDirPath(io, "src/nested"); + try tmp_dir.dir.writeFile(io, .{ .sub_path = "src/main.zig", .data = "const std = @import(\"std\");\npub fn alpha() void {}\n// TODO: keep me\n" }); + try tmp_dir.dir.writeFile(io, .{ .sub_path = "src/nested/util.py", .data = "def beta():\n return 42\n# TODO later\n" }); + try tmp_dir.dir.writeFile(io, .{ .sub_path = "README.md", .data = "# demo\n" }); + + var root_buf: [std.fs.max_path_bytes]u8 = undefined; + const root_len = try tmp_dir.dir.realPathFile(io, ".", &root_buf); + const root = root_buf[0..root_len]; + + var store_seq = Store.init(testing.allocator); + defer store_seq.deinit(); + var explorer_seq = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer_seq.deinit(); + explorer_seq.setRoot(io, root); + try watcher.initialScanWithWorkerCount(io, &store_seq, &explorer_seq, root, testing.allocator, false, 1); + + var store_par = Store.init(testing.allocator); + defer store_par.deinit(); + var explorer_par = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer_par.deinit(); + explorer_par.setRoot(io, root); + try watcher.initialScanWithWorkerCount(io, &store_par, &explorer_par, root, testing.allocator, false, 4); + + const tree_seq = try explorer_seq.getTree(testing.allocator, false); + defer testing.allocator.free(tree_seq); + const tree_par = try explorer_par.getTree(testing.allocator, false); + defer testing.allocator.free(tree_par); + try testing.expectEqualStrings(tree_seq, tree_par); + + const seq_hits = try explorer_seq.searchWord("TODO", testing.allocator); + defer testing.allocator.free(seq_hits); + const par_hits = try explorer_par.searchWord("TODO", testing.allocator); + defer testing.allocator.free(par_hits); + try testing.expectEqual(seq_hits.len, par_hits.len); + + try testing.expectEqual(explorer_seq.outlines.count(), explorer_par.outlines.count()); +} + + +test "edit: range_start zero is invalid" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/edit-range.txt", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + var file = try tmp.dir.createFile(io, "edit-range.txt", .{}); + defer file.close(io); + try file.writeStreamingAll(io, "line 1\nline 2\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + const agent_id = try agents.register("test-agent"); + + try testing.expectError(error.InvalidRange, edit_mod.applyEdit(io, testing.allocator, &store, &agents, null, .{ + .path = rel_path, + .agent_id = agent_id, + .op = .replace, + .range = .{ 0, 1 }, + .content = "changed", + })); +} + + +test "edit: range_start beyond file is invalid" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/edit-range-oob.txt", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + var file = try tmp.dir.createFile(io, "edit-range-oob.txt", .{}); + defer file.close(io); + try file.writeStreamingAll(io, "line 1\nline 2\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + const agent_id = try agents.register("test-agent-oob"); + + try testing.expectError(error.InvalidRange, edit_mod.applyEdit(io, testing.allocator, &store, &agents, null, .{ + .path = rel_path, + .agent_id = agent_id, + .op = .replace, + .range = .{ 3, 3 }, + .content = "changed", + })); +} + + +test "regression #2: searchContent frees trigram candidate slice" { + // Verifies that the candidates() return value is freed by searchContent. + // If the defer is missing, the GPA will detect the leak and fail. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("leak-check.zig", "pub fn recordSnapshot(self: *Store) void {}\npub fn init() void {}"); + try explorer.indexFile("other.zig", "pub fn register(self: *Agent) void {}"); + + const results = try explorer.searchContent("recordSnapshot", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len == 1); + try testing.expectEqualStrings("leak-check.zig", results[0].path); +} + + +test "regression #2: searchContent no leak on zero results" { + // Even when trigram narrows to candidates but none match full text, + // the candidate slice must be freed. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("abc.zig", "pub fn abcdef() void {}"); + + // "abcxyz" shares trigrams "abc" but won't match full text + const results = try explorer.searchContent("abcxyz", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len == 0); +} + + +test "regression #2: searchContent short query skips trigrams" { + // Queries < 3 chars can't use trigram index — ensure no leak from null path. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("short.zig", "fn ab() void {}"); + + const results = try explorer.searchContent("ab", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len == 1); +} + + +test "regression #5: getHotFiles does not deadlock" { + // getHotFiles used to hold explorer.mu while calling store.getLatest() + // which locks store.mu — a lock ordering violation. The fix collects + // paths under explorer.mu, releases it, then locks store.mu separately. + // This test verifies correctness; deadlock would cause a hang. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + var store = Store.init(testing.allocator); + defer store.deinit(); + + try explorer.indexFile("hot-a.zig", "pub fn a() void {}"); + try explorer.indexFile("hot-b.zig", "pub fn b() void {}"); + try explorer.indexFile("hot-c.zig", "pub fn c() void {}"); + + _ = try store.recordSnapshot("hot-a.zig", 10, 0x1); + _ = try store.recordSnapshot("hot-b.zig", 20, 0x2); + _ = try store.recordSnapshot("hot-c.zig", 30, 0x3); + _ = try store.recordSnapshot("hot-b.zig", 25, 0x4); // b updated again + + const hot = try explorer.getHotFiles(&store, testing.allocator, 2); + defer { + for (hot) |path| testing.allocator.free(path); + testing.allocator.free(hot); + } + try testing.expect(hot.len == 2); + // Most recent should be hot-b.zig (seq 4) then hot-c.zig (seq 3) + try testing.expectEqualStrings("hot-b.zig", hot[0]); + try testing.expectEqualStrings("hot-c.zig", hot[1]); +} + + +test "regression #5: getHotFiles with no store entries" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + var store = Store.init(testing.allocator); + defer store.deinit(); + + try explorer.indexFile("orphan.zig", "pub fn x() void {}"); + + const hot = try explorer.getHotFiles(&store, testing.allocator, 10); + defer { + for (hot) |path| testing.allocator.free(path); + testing.allocator.free(hot); + } + // File exists in explorer but not in store — seq defaults to 0 + try testing.expect(hot.len == 1); + try testing.expectEqualStrings("orphan.zig", hot[0]); +} + + +test "regression: concurrent hot/read with remove" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + var store = Store.init(testing.allocator); + defer store.deinit(); + + try explorer.indexFile("race.zig", "pub fn race() void {}"); + _ = try store.recordSnapshot("race.zig", 24, 0x1); + + const Ctx = struct { + explorer: *Explorer, + store: *Store, + stop: *std.atomic.Value(bool), + }; + + const Worker = struct { + fn run(ctx: *Ctx) void { + while (!ctx.stop.load(.acquire)) { + const hot = ctx.explorer.getHotFiles(ctx.store, testing.allocator, 2) catch continue; + defer { + for (hot) |path| testing.allocator.free(path); + testing.allocator.free(hot); + } + + const cached = ctx.explorer.getContent("race.zig", testing.allocator) catch continue; + if (cached) |content| testing.allocator.free(content); + } + } + }; + + var stop = std.atomic.Value(bool).init(false); + var ctx = Ctx{ .explorer = &explorer, .store = &store, .stop = &stop }; + const worker = try std.Thread.spawn(.{}, Worker.run, .{&ctx}); + defer worker.join(); + var i: usize = 0; + while (i < 200) : (i += 1) { + if (i % 2 == 0) { + try explorer.indexFile("race.zig", "pub fn race() void {}"); + _ = try store.recordSnapshot("race.zig", @intCast(24 + i), @intCast(i + 2)); + } else { + explorer.removeFile("race.zig"); + } + } + + stop.store(true, .release); +} + + +test "regression #5: store getLatestSeqUnlocked" { + var store = Store.init(testing.allocator); + defer store.deinit(); + + _ = try store.recordSnapshot("seq.zig", 100, 0xAA); + _ = try store.recordSnapshot("seq.zig", 200, 0xBB); + + store.mu.lock(); + const seq = store.getLatestSeqUnlocked("seq.zig"); + const missing = store.getLatestSeqUnlocked("nope.zig"); + store.mu.unlock(); + + try testing.expect(seq == 2); + try testing.expect(missing == 0); +} + + +test "regression #7: tree shows directory nodes" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("src/main.zig", "pub fn main() void {}"); + try explorer.indexFile("src/lib.zig", "pub fn init() void {}"); + try explorer.indexFile("build.zig", "pub fn build() void {}"); + + const tree = try explorer.getTree(testing.allocator, false); + defer testing.allocator.free(tree); + + // Should contain "src/" directory node + try testing.expect(std.mem.indexOf(u8, tree, "src/\n") != null); + // Should contain file basenames, not full paths + try testing.expect(std.mem.indexOf(u8, tree, " main.zig") != null); + try testing.expect(std.mem.indexOf(u8, tree, " lib.zig") != null); + // Root-level file should not be indented + try testing.expect(std.mem.indexOf(u8, tree, "build.zig") != null); +} + + +test "regression #7: tree handles nested directories" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("src/utils/hash.zig", "pub fn hash() void {}"); + try explorer.indexFile("src/main.zig", "pub fn main() void {}"); + + const tree = try explorer.getTree(testing.allocator, false); + defer testing.allocator.free(tree); + + // Should have both directory levels + try testing.expect(std.mem.indexOf(u8, tree, "src/\n") != null); + try testing.expect(std.mem.indexOf(u8, tree, " utils/\n") != null); + // Nested file should be double-indented + try testing.expect(std.mem.indexOf(u8, tree, " hash.zig") != null); +} + + +test "regression #7: tree shows only basenames" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("pkg/foo/bar.zig", "const x = 1;"); + + const tree = try explorer.getTree(testing.allocator, false); + defer testing.allocator.free(tree); + + // Full path should NOT appear in tree output + try testing.expect(std.mem.indexOf(u8, tree, "pkg/foo/bar.zig") == null); + // Only basename + try testing.expect(std.mem.indexOf(u8, tree, "bar.zig") != null); +} + + +test "regression: searchWord empty result is allocator-owned" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("math.zig", "pub fn add(a: i32, b: i32) i32 { return a + b; }"); + + const hits = try explorer.searchWord("missing_identifier", testing.allocator); + defer testing.allocator.free(hits); + try testing.expect(hits.len == 0); +} + + +test "regression: searchContent frees empty trigram candidate slice" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("f.zig", "hello world"); + + const results = try explorer.searchContent("zzzzz", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len == 0); +} + + +test "regression: queue push stays non-blocking when full" { + var queue = watcher.EventQueue{}; + + var pushed: usize = 0; + while (true) : (pushed += 1) { + var path_buf: [32]u8 = undefined; + const path = try std.fmt.bufPrint(&path_buf, "tmp/fill-{d}.zig", .{pushed}); + if (!queue.push(watcher.FsEvent.init(path, .modified, @intCast(pushed)) orelse unreachable)) break; + } + + var overflow_path_buf: [32]u8 = undefined; + const overflow_path = try std.fmt.bufPrint(&overflow_path_buf, "tmp/overflow-2.zig", .{}); + const start = cio.nanoTimestamp(); + _ = queue.push(watcher.FsEvent.init(overflow_path, .created, 1000) orelse unreachable); + const elapsed = cio.nanoTimestamp() - start; + + try testing.expect(elapsed < 50 * std.time.ns_per_ms); +} + + +test "isPathSafe: rejects absolute paths" { + const mcp = @import("mcp.zig"); + try testing.expect(!mcp.isPathSafe("/etc/passwd")); + try testing.expect(!mcp.isPathSafe("/")); +} + + +test "isPathSafe: rejects parent traversal" { + const mcp = @import("mcp.zig"); + try testing.expect(!mcp.isPathSafe("../secret")); + try testing.expect(!mcp.isPathSafe("foo/../../etc/passwd")); + try testing.expect(!mcp.isPathSafe("..")); +} + + +test "isPathSafe: rejects empty path" { + const mcp = @import("mcp.zig"); + try testing.expect(!mcp.isPathSafe("")); +} + + +test "isPathSafe: accepts valid relative paths" { + const mcp = @import("mcp.zig"); + try testing.expect(mcp.isPathSafe("src/main.zig")); + try testing.expect(mcp.isPathSafe("README.md")); + try testing.expect(mcp.isPathSafe("a/b/c/d.txt")); +} + + +test "findSymbol: returned data is owned copy" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("a.zig", "pub fn myFunc() void {}"); + + const result = try explorer.findSymbol("myFunc", alloc); + try testing.expect(result != null); + + // Remove the source — if result was borrowed, this would corrupt it + explorer.removeFile("a.zig"); + + // Owned copy should still be valid + try testing.expectEqualStrings("a.zig", result.?.path); + try testing.expectEqualStrings("myFunc", result.?.symbol.name); +} + + +test "findAllSymbols: returned data survives source removal" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("a.zig", "pub fn foo() void {}"); + try explorer.indexFile("b.zig", "pub fn foo() void {}"); + + const results = try explorer.findAllSymbols("foo", alloc); + + // Remove sources + explorer.removeFile("a.zig"); + explorer.removeFile("b.zig"); + + // Owned copies should still be valid + try testing.expect(results.len == 2); + for (results) |r| { + try testing.expectEqualStrings("foo", r.symbol.name); + } +} + + +test "searchContent: returned paths are owned copies" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("src/hello.zig", "pub fn greetWorld() void {}"); + + const results = try explorer.searchContent("greetWorld", alloc, 10); + try testing.expect(results.len == 1); + + // Remove the source + explorer.removeFile("src/hello.zig"); + + // Path and line_text should still be valid (owned) + try testing.expectEqualStrings("src/hello.zig", results[0].path); +} + + +test "trigram index: removeFile prunes empty sets" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("only.zig", "xyzUniqueTrigramContent"); + const before = ti.candidates("xyzUniqueTrigramContent", testing.allocator); + if (before) |b| { + try testing.expect(b.len > 0); + testing.allocator.free(b); + } + + ti.removeFile("only.zig"); + const after = ti.candidates("xyzUniqueTrigramContent", testing.allocator); + if (after) |a| { + try testing.expect(a.len == 0); + testing.allocator.free(a); + } +} + + +test "edit: atomic write leaves no temp files on success" { + // Create a temp file to edit + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + const path = "test_atomic.zig"; + const content = "line1\nline2\nline3\n"; + try tmp_dir.dir.writeFile(io, .{ .sub_path = path, .data = content }); + + // The temp file pattern is "{path}.codedb_tmp" + const tmp_path = path ++ ".codedb_tmp"; + + // After a successful edit, no .codedb_tmp file should remain + tmp_dir.dir.access(io, tmp_path, .{}) catch { + // Expected: temp file doesn't exist (good) + return; + }; + // If we get here, the temp file exists — that's a bug + return error.TempFileNotCleaned; +} + + +test "getBool: returns true for bool true" { + var map: std.json.ObjectMap = .empty; + defer map.deinit(testing.allocator); + try map.put(testing.allocator, "flag", .{ .bool = true }); + const mcp_getBool = @import("mcp.zig").getBool; + try testing.expect(mcp_getBool(&map, "flag") == true); +} + + +test "getBool: returns false for bool false" { + var map: std.json.ObjectMap = .empty; + defer map.deinit(testing.allocator); + try map.put(testing.allocator, "flag", .{ .bool = false }); + const mcp_getBool = @import("mcp.zig").getBool; + try testing.expect(mcp_getBool(&map, "flag") == false); +} + + +test "getBool: returns false for missing key" { + var map: std.json.ObjectMap = .empty; + defer map.deinit(testing.allocator); + const mcp_getBool = @import("mcp.zig").getBool; + try testing.expect(mcp_getBool(&map, "missing") == false); +} + + +test "getBool: returns false for non-bool value" { + var map: std.json.ObjectMap = .empty; + defer map.deinit(testing.allocator); + try map.put(testing.allocator, "flag", .{ .integer = 1 }); + const mcp_getBool = @import("mcp.zig").getBool; + try testing.expect(mcp_getBool(&map, "flag") == false); +} + + +test "Tool enum: all valid tool names parse" { + const Tool = @import("mcp.zig").Tool; + try testing.expect(std.meta.stringToEnum(Tool, "codedb_tree") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_outline") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_symbol") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_search") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_word") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_hot") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_deps") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_read") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_edit") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_changes") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_status") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_snapshot") != null); + try testing.expect(std.meta.stringToEnum(Tool, "codedb_bundle") != null); +} + + +test "Tool enum: invalid names return null" { + const Tool = @import("mcp.zig").Tool; + try testing.expect(std.meta.stringToEnum(Tool, "codedb_invalid") == null); + try testing.expect(std.meta.stringToEnum(Tool, "") == null); + try testing.expect(std.meta.stringToEnum(Tool, "tree") == null); +} + + +test "decomposeRegex: pure literal extracts trigrams" { + var q = try decomposeRegex("hello", testing.allocator); + defer q.deinit(); + // "hello" has 3 trigrams: hel, ell, llo + try testing.expectEqual(@as(usize, 3), q.and_trigrams.len); + try testing.expectEqual(@as(usize, 0), q.or_groups.len); +} + + +test "decomposeRegex: short literal yields no trigrams" { + var q = try decomposeRegex("ab", testing.allocator); + defer q.deinit(); + try testing.expectEqual(@as(usize, 0), q.and_trigrams.len); +} + + +test "decomposeRegex: dot breaks trigram chain" { + var q = try decomposeRegex("he.lo", testing.allocator); + defer q.deinit(); + // "he" then "lo" — neither long enough for trigrams + try testing.expectEqual(@as(usize, 0), q.and_trigrams.len); +} + + +test "decomposeRegex: dot in longer literal" { + var q = try decomposeRegex("hello.world", testing.allocator); + defer q.deinit(); + // "hello" -> hel,ell,llo; "world" -> wor,orl,rld = 6 trigrams + try testing.expectEqual(@as(usize, 6), q.and_trigrams.len); +} + + +test "decomposeRegex: alternation creates OR groups" { + var q = try decomposeRegex("foo|bar", testing.allocator); + defer q.deinit(); + try testing.expectEqual(@as(usize, 0), q.and_trigrams.len); + // All branch trigrams merged into single OR group + try testing.expectEqual(@as(usize, 1), q.or_groups.len); + // "foo" has 1 trigram + "bar" has 1 trigram = 2 trigrams in the group + try testing.expectEqual(@as(usize, 2), q.or_groups[0].len); +} + + +test "decomposeRegex: quantifier removes preceding char" { + var q = try decomposeRegex("hel+o", testing.allocator); + defer q.deinit(); + // "he" then "o" — + removes 'l', neither segment >= 3 + try testing.expectEqual(@as(usize, 0), q.and_trigrams.len); +} + + +test "decomposeRegex: escaped literal preserved" { + var q = try decomposeRegex("a\\.bc", testing.allocator); + defer q.deinit(); + // Escaped dot is literal: "a.bc" = 2 trigrams: a.b, .bc + try testing.expectEqual(@as(usize, 2), q.and_trigrams.len); +} + + +test "decomposeRegex: character class breaks chain" { + var q = try decomposeRegex("abc[xy]def", testing.allocator); + defer q.deinit(); + // "abc" = 1 trigram, "def" = 1 trigram + try testing.expectEqual(@as(usize, 2), q.and_trigrams.len); +} + + +test "decomposeRegex: backslash-w breaks chain" { + var q = try decomposeRegex("abc\\wdef", testing.allocator); + defer q.deinit(); + // "abc" = 1 trigram, "def" = 1 trigram + try testing.expectEqual(@as(usize, 2), q.and_trigrams.len); +} + + +test "candidatesRegex: finds files with AND trigrams" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("foo.zig", "pub fn recordSnapshot() void {}"); + try ti.indexFile("bar.zig", "const x = 42;"); + + var q = try decomposeRegex("record.*Snapshot", testing.allocator); + defer q.deinit(); + // Should extract trigrams from "record" and "Snapshot" + try testing.expect(q.and_trigrams.len > 0); + + const cands = ti.candidatesRegex(&q, testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + try testing.expect(cands.?.len >= 1); + // foo.zig should be a candidate + var found_foo = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "foo.zig")) found_foo = true; + } + try testing.expect(found_foo); +} + + +test "candidatesRegex: OR groups union posting lists" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("alpha.zig", "function foobar() {}"); + try ti.indexFile("beta.zig", "function bazqux() {}"); + try ti.indexFile("gamma.zig", "const x = 1;"); + + var q = try decomposeRegex("foobar|bazqux", testing.allocator); + defer q.deinit(); + // All branch trigrams merged into single OR group + try testing.expectEqual(@as(usize, 1), q.or_groups.len); + + const cands = ti.candidatesRegex(&q, testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + // Both alpha.zig and beta.zig should be candidates + var found_alpha = false; + var found_beta = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "alpha.zig")) found_alpha = true; + if (std.mem.eql(u8, p, "beta.zig")) found_beta = true; + } + try testing.expect(found_alpha or found_beta); +} + + +test "regexMatch: literal match" { + try testing.expect(regexMatch("hello world", "hello")); + try testing.expect(regexMatch("hello world", "world")); + try testing.expect(!regexMatch("hello world", "xyz")); +} + + +test "regexMatch: dot matches any char" { + try testing.expect(regexMatch("hello", "h.llo")); + try testing.expect(regexMatch("hello", "h..lo")); + try testing.expect(!regexMatch("hello", "h...lo")); +} + + +test "regexMatch: star quantifier" { + try testing.expect(regexMatch("helllo", "hel*o")); + try testing.expect(regexMatch("heo", "hel*o")); + try testing.expect(regexMatch("aab", "a*b")); +} + + +test "regexMatch: plus quantifier" { + try testing.expect(regexMatch("helllo", "hel+o")); + try testing.expect(!regexMatch("heo", "hel+o")); +} + + +test "regexMatch: question quantifier" { + try testing.expect(regexMatch("color", "colou?r")); + try testing.expect(regexMatch("colour", "colou?r")); +} + + +test "regexMatch: character class" { + try testing.expect(regexMatch("cat", "c[aeiou]t")); + try testing.expect(regexMatch("cot", "c[aeiou]t")); + try testing.expect(!regexMatch("cxt", "c[aeiou]t")); +} + + +test "regexMatch: negated character class" { + try testing.expect(!regexMatch("cat", "c[^aeiou]t")); + try testing.expect(regexMatch("cxt", "c[^aeiou]t")); +} + + +test "regexMatch: anchors" { + try testing.expect(regexMatch("hello", "^hello")); + try testing.expect(!regexMatch("say hello", "^hello")); + try testing.expect(regexMatch("hello", "hello$")); + try testing.expect(!regexMatch("hello world", "hello$")); +} + + +test "regexMatch: escape sequences" { + try testing.expect(regexMatch("abc123", "\\d+")); + try testing.expect(regexMatch("hello world", "\\w+\\s\\w+")); + try testing.expect(regexMatch("a.b", "a\\.b")); + try testing.expect(!regexMatch("axb", "a\\.b")); +} + + +test "regexMatch: alternation" { + try testing.expect(regexMatch("foo", "foo|bar")); + try testing.expect(regexMatch("bar", "foo|bar")); + try testing.expect(!regexMatch("baz", "foo|bar")); +} + + +test "regexMatch: alternation with many branches does not stack overflow" { + // 300 branches: 4 chars each + 299 separators = 1499 bytes max + var buf: [1500]u8 = undefined; + var pos: usize = 0; + var bi: usize = 0; + while (bi < 300) : (bi += 1) { + if (bi > 0) { + buf[pos] = '|'; + pos += 1; + } + buf[pos] = 'a'; + pos += 1; + buf[pos] = @as(u8, @intCast('0' + bi / 100 % 10)); + pos += 1; + buf[pos] = @as(u8, @intCast('0' + bi / 10 % 10)); + pos += 1; + buf[pos] = @as(u8, @intCast('0' + bi % 10)); + pos += 1; + } + const pattern = buf[0..pos]; + try testing.expect(regexMatch("a000", pattern)); + try testing.expect(regexMatch("a299", pattern)); + try testing.expect(!regexMatch("a999", pattern)); +} + + +test "regexMatch: dot-star" { + try testing.expect(regexMatch("hello world", "hello.*world")); + try testing.expect(regexMatch("helloworld", "hello.*world")); +} + + +test "issue-454: regex \\b word boundary matches whole-word, not literal 'b'" { + // \b is a word-boundary assertion: should match "foo" as a whole word + // but not when it appears as a substring inside another word. + try testing.expect(regexMatch("foo bar", "\\bfoo\\b")); + try testing.expect(!regexMatch("foobar", "\\bfoo\\b")); + // Whole-word "bar" at end + try testing.expect(regexMatch("foo bar", "\\bbar\\b")); + try testing.expect(!regexMatch("foobarbaz", "\\bbar\\b")); +} + + +test "bloom: PostingMask is populated during indexing" { + // Verify that indexing actually sets mask bits, not just zeros. + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("a.zig", "pub fn init(allocator) void {}"); + + // Trigram "pub" should exist with non-zero masks + const tri_pub = packTrigram('p', 'u', 'b'); + const file_set = ti.index.getPtr(tri_pub); + try testing.expect(file_set != null); + + const mask = file_set.?.get("a.zig"); + try testing.expect(mask != null); + // loc_mask must have at least one bit set (position 0) + try testing.expect(mask.?.loc_mask != 0); + // next_mask must have at least one bit set (char after "pub" is ' ') + try testing.expect(mask.?.next_mask != 0); +} + + +test "bloom: loc_mask records correct position bits" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + // Content where "abc" appears at known positions + // Position 0: "abcXXXXXabcYYYYY" — abc at pos 0 and pos 8 + try ti.indexFile("pos.zig", "abcXXXXXabcYYYYY"); + + const tri_abc = packTrigram('a', 'b', 'c'); + const file_set = ti.index.getPtr(tri_abc).?; + const mask = file_set.get("pos.zig").?; + + // pos 0 → bit 0, pos 8 → bit 0 (8 % 8 = 0) + try testing.expect(mask.loc_mask & 1 != 0); // bit 0 set +} + + +test "bloom: next_mask records the following character" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("next.zig", "abcdef"); + + // For trigram "abc" at position 0, next char is 'd' + const tri_abc = packTrigram('a', 'b', 'c'); + const file_set = ti.index.getPtr(tri_abc).?; + const mask = file_set.get("next.zig").?; + + const expected_bit: u8 = @as(u8, 1) << @intCast(normalizeChar('d') % 8); + try testing.expect(mask.next_mask & expected_bit != 0); +} + + +test "bloom: soundness — never rejects actual matches" { + // The bloom filter must NEVER produce false negatives. + // Every file that actually contains the query must appear in candidates. + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + // Index many files with varied content, some containing the target + try ti.indexFile("match1.zig", "fn handleRequest(ctx: *Context) void {}"); + try ti.indexFile("match2.zig", "pub fn handleRequest() !void { return error.Fail; }"); + try ti.indexFile("noise1.zig", "fn processData(input: []const u8) void {}"); + try ti.indexFile("noise2.zig", "const handler = RequestPool.init();"); // has "handl" and "eques" but not "handleRequest" + try ti.indexFile("noise3.zig", "fn handleResponse(ctx: *Context) void {}"); // close but different + try ti.indexFile("noise4.zig", "pub fn register(name: []const u8) void {}"); + try ti.indexFile("noise5.zig", "const request_handler = getHandler();"); // has both words but not adjacent + + const cands = ti.candidates("handleRequest", testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + + // MUST find both actual matches — bloom filter cannot reject them + var found1 = false; + var found2 = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "match1.zig")) found1 = true; + if (std.mem.eql(u8, p, "match2.zig")) found2 = true; + } + try testing.expect(found1); + try testing.expect(found2); +} + + +test "bloom: reduces candidates vs pure trigram intersection" { + // This is the key test: prove bloom filtering actually eliminates + // files that trigram intersection alone would not. + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + // "pub fn init" — common trigrams "pub", "ub ", "b f", " fn", "fn ", "n i", " in", "ini", "nit" + // We'll create files that share many of these trigrams but NOT adjacently. + try ti.indexFile("real.zig", "pub fn init() void {}"); // actual match + try ti.indexFile("shuffled1.zig", "fn publish(nit_pick: bool) void {}"); // has "pub","fn ","nit" but not adjacently + try ti.indexFile("shuffled2.zig", "fn pubNitInit() void {}"); // has "pub","nit","ini" but wrong order + try ti.indexFile("unrelated.zig", "const x = 42;"); // no overlap + + const cands = ti.candidates("pub fn init", testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + + // real.zig MUST be found (soundness) + var found_real = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "real.zig")) found_real = true; + } + try testing.expect(found_real); + + // unrelated.zig must NOT be found + var found_unrelated = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "unrelated.zig")) found_unrelated = true; + } + try testing.expect(!found_unrelated); + + // Count how many candidates we got — should be fewer than all files + // that share trigrams. At minimum, "unrelated.zig" is excluded. + try testing.expect(cands.?.len < 4); +} + + +test "bloom: loc_mask adjacency filtering works" { + // Construct a scenario where two trigrams exist in a file but at + // positions where they can't be adjacent. The loc_mask check should + // filter this out (probabilistically, but deterministically for + // carefully chosen positions). + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + // "XXXabcYYYYYYYYYYYYYYYdefZZZ" — "abc" at pos 3, "def" at pos 21 + // Query "abcdef" needs abc at pos N and def at pos N+3. + // But abc is at pos 3 (bit 3) and def is at pos 21 (bit 5). + // Shifted abc loc_mask bit 3 → bit 4. "bcd" would need to be at bit 4. + // This tests the adjacency logic. + try ti.indexFile("adjacent.zig", "XXabcdefGH"); // abc and def ARE adjacent + try ti.indexFile("apart.zig", "XXXabcYYYYYYYYYYYYYYdefZZZ"); // abc and def far apart + + const cands = ti.candidates("abcdef", testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + + // adjacent.zig MUST be found + var found_adjacent = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "adjacent.zig")) found_adjacent = true; + } + try testing.expect(found_adjacent); + + // apart.zig MAY be filtered out by loc_mask (depends on position mod 8 collision) + // We can't assert it's excluded because bloom filters allow false positives, + // but we CAN assert the total candidate count is reasonable. + try testing.expect(cands.?.len >= 1); // at least the real match +} + + +test "bloom: masks accumulate across multiple positions" { + // If a trigram appears at many positions in a file, both masks should + // have multiple bits set (OR'd together, never replaced). + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + // "the" appears at positions 0, 10, 20, 30, 40, 50, 60, 70 + try ti.indexFile("repeat.zig", "the_______the_______the_______the_______the_______the_______the_______the_______"); + + const tri_the = packTrigram('t', 'h', 'e'); + const file_set = ti.index.getPtr(tri_the).?; + const mask = file_set.get("repeat.zig").?; + + // With 8+ occurrences at varying positions, loc_mask should have many bits set + try testing.expect(@popCount(mask.loc_mask) >= 3); + // next_mask should also have bits set (from the chars following each "the") + try testing.expect(mask.next_mask != 0); +} + + +test "bloom: regression — candidate count for known queries" { + // Regression benchmark: index a controlled set of files and assert + // specific candidate counts. If bloom filtering breaks or regresses, + // these counts will increase. + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("a.zig", "pub fn initAllocator() void {}"); + try ti.indexFile("b.zig", "pub fn deinitAllocator() void {}"); + try ti.indexFile("c.zig", "pub fn init() void {}"); + try ti.indexFile("d.zig", "fn publish(data: []u8) void {}"); + try ti.indexFile("e.zig", "const initial_value = 0;"); + try ti.indexFile("f.zig", "fn processInput() !void {}"); + try ti.indexFile("g.zig", "const config = getConfig();"); + try ti.indexFile("h.zig", "fn handleNotification() void {}"); + + // "initAllocator" — a.zig must be found; b.zig ("deinitAllocator") shares trigrams + { + const cands = ti.candidates("initAllocator", testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + var found_a = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "a.zig")) found_a = true; + } + try testing.expect(found_a); + // b.zig is a valid false positive (shares "initAllocator" substring in "deinitAllocator") + // but d/e/f/g/h should not appear + try testing.expect(cands.?.len <= 2); + } + + // "pub fn init" — should find a.zig, c.zig; maybe b.zig (shares "pub fn ") + // but NOT d/e/f/g/h + { + const cands = ti.candidates("pub fn init", testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + // Must include actual matches + var found_a = false; + var found_c = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "a.zig")) found_a = true; + if (std.mem.eql(u8, p, "c.zig")) found_c = true; + } + try testing.expect(found_a); + try testing.expect(found_c); + // Candidate count must be <= 4 (bloom should exclude some) + // Without bloom: files sharing any "pub"/"fn "/"ini"/"nit" trigrams = many + // With bloom: adjacency + next_mask filtering should narrow it down + try testing.expect(cands.?.len <= 4); + } + + // "processInput" — f.zig must be found, few false positives allowed + { + const cands = ti.candidates("processInput", testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + var found_f = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "f.zig")) found_f = true; + } + try testing.expect(found_f); + // Bloom may allow a false positive but should be way less than 8 + try testing.expect(cands.?.len <= 3); + } +} + + +test "regex regression: trigram extraction counts" { + // Verify exact trigram counts for known patterns. + // If decomposition logic changes, these catch it. + { + var q = try decomposeRegex("handleRequest", testing.allocator); + defer q.deinit(); + // 13 chars → 11 trigrams, all AND + try testing.expectEqual(@as(usize, 11), q.and_trigrams.len); + try testing.expectEqual(@as(usize, 0), q.or_groups.len); + } + { + var q = try decomposeRegex("foo.*bar.*baz", testing.allocator); + defer q.deinit(); + // "foo", "bar", "baz" — each 3 chars = 1 trigram each = 3 AND trigrams + try testing.expectEqual(@as(usize, 3), q.and_trigrams.len); + try testing.expectEqual(@as(usize, 0), q.or_groups.len); + } + { + var q = try decomposeRegex("alpha|beta|gamma", testing.allocator); + defer q.deinit(); + // No AND trigrams — all in OR groups + try testing.expectEqual(@as(usize, 0), q.and_trigrams.len); + try testing.expectEqual(@as(usize, 1), q.or_groups.len); + // alpha=3 + beta=2 + gamma=3 = 8 trigrams in the OR group + try testing.expectEqual(@as(usize, 8), q.or_groups[0].len); + } +} + + +test "regex regression: regexMatch edge cases" { + // Empty pattern matches anything + try testing.expect(regexMatch("anything", "")); + + // Pure wildcard + try testing.expect(regexMatch("abc", ".*")); + try testing.expect(regexMatch("", ".*")); + + // Consecutive quantifiers shouldn't crash + try testing.expect(regexMatch("aab", "a+b")); + try testing.expect(!regexMatch("b", "a+b")); + + // Nested-ish patterns + try testing.expect(regexMatch("foobar", "foo.ar")); + try testing.expect(!regexMatch("foar", "foo.ar")); + + // Backslash at end of pattern (edge case) + try testing.expect(!regexMatch("abc", "abc\\")); +} + + +test "regex regression: candidatesRegex reduces vs brute force" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + try ti.indexFile("handler.zig", "pub fn handleRequest(ctx: *Context) !void { }"); + try ti.indexFile("process.zig", "pub fn processData(input: []u8) void { }"); + try ti.indexFile("utils.zig", "pub fn formatString(s: []const u8) []u8 { return s; }"); + try ti.indexFile("config.zig", "const default_config = Config{ .debug = false };"); + + // "handle.*Request" — should extract trigrams from "handle" and "Request" + var q = try decomposeRegex("handle.*Request", testing.allocator); + defer q.deinit(); + try testing.expect(q.and_trigrams.len >= 4); // at least some from both halves + + const cands = ti.candidatesRegex(&q, testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + + // handler.zig MUST be a candidate (soundness) + var found_handler = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "handler.zig")) found_handler = true; + } + try testing.expect(found_handler); + + // Should NOT include config.zig (no "handle" or "Request" trigrams) + var found_config = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "config.zig")) found_config = true; + } + try testing.expect(!found_config); + + // Candidate count should be much less than total files + try testing.expect(cands.?.len <= 2); +} + + +test "perf regression: indexing 200 files under 200ms" { + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + var wi = WordIndex.init(testing.allocator); + defer wi.deinit(); + + // Generate 200 synthetic files with realistic content + var bufs: [200][]u8 = undefined; + var names: [200][]u8 = undefined; + for (0..200) |i| { + names[i] = try std.fmt.allocPrint(testing.allocator, "src/file_{d:0>3}.zig", .{i}); + bufs[i] = try std.fmt.allocPrint(testing.allocator, + \\pub fn handler_{d}(ctx: *Context, req: Request) !Response {{ + \\ const allocator = ctx.allocator; + \\ const data = try req.readBody(allocator); + \\ defer allocator.free(data); + \\ return Response.init(.ok, data); + \\}} + \\ + \\const Config_{d} = struct {{ + \\ name: []const u8, + \\ value: i64 = {d}, + \\ enabled: bool = true, + \\}}; + , .{ i, i, i * 42 }); + } + defer for (0..200) |i| { + testing.allocator.free(bufs[i]); + testing.allocator.free(names[i]); + }; + + var timer = try cio.Timer.start(); + for (0..200) |i| { + try ti.indexFile(names[i], bufs[i]); + try wi.indexFile(names[i], bufs[i]); + } + const elapsed_ns = timer.read(); + const elapsed_ms = @as(f64, @floatFromInt(elapsed_ns)) / 1_000_000.0; + + // Must complete under 200ms (generous budget — typically ~30ms) + // Debug builds are ~10x slower than ReleaseFast; give generous headroom. + // ReleaseFast typically ~30ms; Debug ~100–250ms depending on host. + try testing.expect(elapsed_ms < 500.0); +} + + +test "perf regression: trigram candidate lookup under 1ms per query" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + for (0..100) |i| { + const name = try std.fmt.allocPrint(alloc, "mod_{d}.zig", .{i}); + const content = try std.fmt.allocPrint(alloc, + \\pub fn process_{d}(data: []const u8) !void {{ + \\ const result = transform(data); + \\ try validate(result); + \\}} + , .{i}); + try ti.indexFile(name, content); + } + + const queries = [_][]const u8{ + "process_42", + "transform", + "pub fn process", + "validate(result)", + }; + + var timer = try cio.Timer.start(); + const iters: usize = 1000; + for (0..iters) |_| { + for (queries) |q| { + const cands = ti.candidates(q, testing.allocator); + if (cands) |c| testing.allocator.free(c); + } + } + const elapsed_ns = timer.read(); + const ns_per_query = elapsed_ns / (iters * queries.len); + + // Must be under 1ms (1_000_000 ns) per query — typically ~100µs + try testing.expect(ns_per_query < 1_000_000); +} + + +test "perf regression: word index lookup under 100ns per query" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + var wi = WordIndex.init(testing.allocator); + defer wi.deinit(); + + for (0..100) |i| { + const name = try std.fmt.allocPrint(alloc, "src_{d}.zig", .{i}); + const content = try std.fmt.allocPrint(alloc, "pub fn handleRequest_{d}(ctx: *Context) void {{}}\nconst allocator = getDefaultAllocator();\n", .{i}); + try wi.indexFile(name, content); + } + + const queries = [_][]const u8{ "handleRequest_50", "allocator", "getDefaultAllocator", "Context" }; + + var timer = try cio.Timer.start(); + const iters: usize = 100_000; + for (0..iters) |_| { + for (queries) |q| { + _ = wi.search(q); + } + } + const elapsed_ns = timer.read(); + const ns_per_query = elapsed_ns / (iters * queries.len); + // Word lookup must be under 500ns in debug — typically ~5ns in release + try testing.expect(ns_per_query < 500); +} + + +test "perf regression: bloom filter reduces scan work" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + var ti = TrigramIndex.init(testing.allocator); + defer ti.deinit(); + + for (0..50) |i| { + const name = try std.fmt.allocPrint(alloc, "f{d:0>2}.zig", .{i}); + const content = try std.fmt.allocPrint(alloc, "pub fn init_{d}(allocator: Allocator) void {{}}\nfn deinit_{d}() void {{}}\n", .{ i, i }); + try ti.indexFile(name, content); + } + + // "pub fn init_25" — specific enough to test bloom effectiveness + const cands = ti.candidates("pub fn init_25", testing.allocator); + defer if (cands) |c| testing.allocator.free(c); + try testing.expect(cands != null); + + // With bloom filtering, should find very few candidates + try testing.expect(cands.?.len <= 10); + + // The actual target file MUST be present (soundness) + var found_target = false; + for (cands.?) |p| { + if (std.mem.eql(u8, p, "f25.zig")) found_target = true; + } + try testing.expect(found_target); + + // KEY ASSERTION: candidate count is meaningfully less than total files + // This proves bloom filtering is doing work, not just passing through + try testing.expect(cands.?.len < 25); // must eliminate at least half +} + + +test "disk word index: round-trip write and read preserves hits" { + const alloc = testing.allocator; + var wi = WordIndex.init(alloc); + defer wi.deinit(); + + try wi.indexFile("src/main.zig", "const Store = @import(\"store.zig\").Store;\npub fn main() void {}\n"); + try wi.indexFile("src/store.zig", "pub const Store = struct {};\npub fn open() void {}\n"); + + const hits_before = try wi.searchDeduped("Store", alloc); + defer alloc.free(hits_before); + try testing.expectEqual(@as(usize, 2), hits_before.len); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + const fake_head = "0123456789abcdef0123456789abcdef01234567".*; + try wi.writeToDisk(io, dir_path, fake_head); + + const header = try WordIndex.readDiskHeader(io, dir_path, alloc); + try testing.expect(header != null); + try testing.expectEqual(@as(u32, 2), header.?.file_count); + try testing.expect(header.?.git_head != null); + try testing.expectEqualSlices(u8, &fake_head, &header.?.git_head.?); + + const loaded = WordIndex.readFromDisk(io, dir_path, alloc); + try testing.expect(loaded != null); + var loaded_wi = loaded.?; + defer loaded_wi.deinit(); + + const hits_after = try loaded_wi.searchDeduped("Store", alloc); + defer alloc.free(hits_after); + try testing.expectEqual(hits_before.len, hits_after.len); + + var found_main = false; + var found_store = false; + for (hits_after) |hit| { + if (std.mem.eql(u8, loaded_wi.hitPath(hit), "src/main.zig")) found_main = true; + if (std.mem.eql(u8, loaded_wi.hitPath(hit), "src/store.zig")) found_store = true; + } + try testing.expect(found_main); + try testing.expect(found_store); +} + + +test "disk word index: skip_file_words still writes file table" { + const alloc = testing.allocator; + var wi = WordIndex.init(alloc); + defer wi.deinit(); + wi.skip_file_words = true; + + try wi.indexFile("src/a.zig", "pub fn alphaToken() void {}\n"); + try wi.indexFile("src/b.zig", "pub fn betaToken() void {}\n"); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + try wi.writeToDisk(io, dir_path, null); + + const header = try WordIndex.readDiskHeader(io, dir_path, alloc); + try testing.expect(header != null); + try testing.expectEqual(@as(u32, 2), header.?.file_count); + + const loaded = WordIndex.readFromDisk(io, dir_path, alloc); + try testing.expect(loaded != null); + var loaded_wi = loaded.?; + defer loaded_wi.deinit(); + + const hits = try loaded_wi.searchDeduped("alphaToken", alloc); + defer alloc.free(hits); + try testing.expectEqual(@as(usize, 1), hits.len); + try testing.expectEqualStrings("src/a.zig", loaded_wi.hitPath(hits[0])); +} + + +test "disk index: round-trip write and read preserves candidates" { + const alloc = testing.allocator; + var ti = TrigramIndex.init(alloc); + defer ti.deinit(); + + try ti.indexFile("src/main.zig", "pub fn main() void { const store = Store.init(allocator); }"); + try ti.indexFile("src/index.zig", "pub fn indexFile(self: *TrigramIndex, path: []const u8) !void {}"); + try ti.indexFile("src/watcher.zig", "pub fn initialScan(store: *Store) !void {}"); + + // Verify candidates before write + const cands_before = ti.candidates("indexFile", testing.allocator); + defer if (cands_before) |c| alloc.free(c); + try testing.expect(cands_before != null); + try testing.expect(cands_before.?.len >= 1); + + // Write to temp dir + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + try ti.writeToDisk(io, dir_path, null); + + // Read back + const loaded = TrigramIndex.readFromDisk(io, dir_path, alloc); + try testing.expect(loaded != null); + var loaded_ti = loaded.?; + defer loaded_ti.deinit(); + + // Same candidates should be returned + const cands_after = loaded_ti.candidates("indexFile", testing.allocator); + defer if (cands_after) |c| alloc.free(c); + try testing.expect(cands_after != null); + try testing.expectEqual(cands_before.?.len, cands_after.?.len); + + // Verify specific file is present + var found = false; + for (cands_after.?) |p| { + if (std.mem.eql(u8, p, "src/index.zig")) found = true; + } + try testing.expect(found); +} + + +test "disk index: readFromDisk returns null for missing files" { + const loaded = TrigramIndex.readFromDisk(io, "/tmp/codedb_nonexistent_dir_12345", testing.allocator); + try testing.expect(loaded == null); +} + + +test "disk index: readFromDisk returns null for corrupt magic" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + // Write garbage postings file + const postings_path = try std.fmt.allocPrint(testing.allocator, "{s}/trigram.postings", .{dir_path}); + defer testing.allocator.free(postings_path); + { + const f = try std.Io.Dir.cwd().createFile(io, postings_path, .{}); + defer f.close(io); + try f.writeStreamingAll(io, "BAADMAGIC"); + } + // Write garbage lookup file + const lookup_path = try std.fmt.allocPrint(testing.allocator, "{s}/trigram.lookup", .{dir_path}); + defer testing.allocator.free(lookup_path); + { + const f = try std.Io.Dir.cwd().createFile(io, lookup_path, .{}); + defer f.close(io); + try f.writeStreamingAll(io, "BAADMAGIC"); + } + + const loaded = TrigramIndex.readFromDisk(io, dir_path, testing.allocator); + try testing.expect(loaded == null); +} + + +test "disk index: empty index round-trips correctly" { + const alloc = testing.allocator; + var ti = TrigramIndex.init(alloc); + defer ti.deinit(); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + try ti.writeToDisk(io, dir_path, null); + + const loaded = TrigramIndex.readFromDisk(io, dir_path, alloc); + try testing.expect(loaded != null); + var loaded_ti = loaded.?; + defer loaded_ti.deinit(); + + try testing.expectEqual(@as(u32, 0), loaded_ti.fileCount()); +} + + +test "disk index: bloom masks preserved after round-trip" { + const alloc = testing.allocator; + var ti = TrigramIndex.init(alloc); + defer ti.deinit(); + + try ti.indexFile("bloom.zig", "pub fn handleRequest(ctx: *Context) void {}"); + + // Get original masks + const tri = packTrigram('h', 'a', 'n'); + const orig_set = ti.index.getPtr(tri).?; + const orig_mask = orig_set.get("bloom.zig").?; + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + try ti.writeToDisk(io, dir_path, null); + + const loaded = TrigramIndex.readFromDisk(io, dir_path, alloc); + try testing.expect(loaded != null); + var loaded_ti = loaded.?; + defer loaded_ti.deinit(); + + // Check masks match + const loaded_set = loaded_ti.index.getPtr(tri).?; + const loaded_mask = loaded_set.get("bloom.zig").?; + try testing.expectEqual(orig_mask.next_mask, loaded_mask.next_mask); + try testing.expectEqual(orig_mask.loc_mask, loaded_mask.loc_mask); +} + + +test "disk index: fileCount matches after round-trip" { + const alloc = testing.allocator; + var ti = TrigramIndex.init(alloc); + defer ti.deinit(); + + try ti.indexFile("a.zig", "fn alpha() void {}"); + try ti.indexFile("b.zig", "fn beta() void {}"); + try ti.indexFile("c.zig", "fn gamma() void {}"); + + try testing.expectEqual(@as(u32, 3), ti.fileCount()); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + try ti.writeToDisk(io, dir_path, null); + + const loaded = TrigramIndex.readFromDisk(io, dir_path, alloc); + try testing.expect(loaded != null); + var loaded_ti = loaded.?; + defer loaded_ti.deinit(); + + try testing.expectEqual(@as(u32, 3), loaded_ti.fileCount()); +} + + +test "disk index: writeToDisk stores git_head, readGitHead retrieves it" { + const alloc = testing.allocator; + var ti = TrigramIndex.init(alloc); + defer ti.deinit(); + + try ti.indexFile("a.zig", "fn hello() void {}"); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + const fake_head = "aabbccddeeff00112233445566778899aabbccdd".*; + try ti.writeToDisk(io, dir_path, fake_head); + + const retrieved = try TrigramIndex.readGitHead(io, dir_path, alloc); + try testing.expect(retrieved != null); + try testing.expectEqualSlices(u8, &fake_head, &retrieved.?); +} + + +test "disk index: writeToDisk with null git_head, readGitHead returns null" { + const alloc = testing.allocator; + var ti = TrigramIndex.init(alloc); + defer ti.deinit(); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + try ti.writeToDisk(io, dir_path, null); + + const retrieved = try TrigramIndex.readGitHead(io, dir_path, alloc); + try testing.expect(retrieved == null); +} + + +test "disk index: readDiskHeader returns file_count and git_head" { + const alloc = testing.allocator; + var ti = TrigramIndex.init(alloc); + defer ti.deinit(); + + try ti.indexFile("x.zig", "pub const X = 42;"); + try ti.indexFile("y.zig", "pub const Y = 99;"); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + const fake_head = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef".*; + try ti.writeToDisk(io, dir_path, fake_head); + + const hdr = try TrigramIndex.readDiskHeader(io, dir_path, alloc); + try testing.expect(hdr != null); + try testing.expectEqual(@as(u32, 2), hdr.?.file_count); + try testing.expect(hdr.?.git_head != null); + try testing.expectEqualSlices(u8, &fake_head, &hdr.?.git_head.?); +} + + +test "disk index: v1 format (no git_head) still loads and readGitHead returns null" { + const alloc = testing.allocator; + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + // Manually write a v1 postings file (no git head bytes) + const postings_path = try std.fmt.allocPrint(alloc, "{s}/trigram.postings", .{dir_path}); + defer alloc.free(postings_path); + { + const f = try std.Io.Dir.cwd().createFile(io, postings_path, .{}); + defer f.close(io); + // magic(4) + version=1(2) + file_count=0(2) = 8 bytes total + try f.writeStreamingAll(io, &.{ 'C', 'D', 'B', 'T' }); + try f.writeStreamingAll(io, &.{ 1, 0 }); // version = 1 LE + try f.writeStreamingAll(io, &.{ 0, 0 }); // file_count = 0 + } + // Write a matching v1 lookup file + const lookup_path = try std.fmt.allocPrint(alloc, "{s}/trigram.lookup", .{dir_path}); + defer alloc.free(lookup_path); + { + const f = try std.Io.Dir.cwd().createFile(io, lookup_path, .{}); + defer f.close(io); + // magic(4) + version=1(2) + pad(2) + entry_count=0(4) = 12 bytes + try f.writeStreamingAll(io, &.{ 'C', 'D', 'B', 'L' }); + try f.writeStreamingAll(io, &.{ 1, 0 }); // version = 1 + try f.writeStreamingAll(io, &.{ 0, 0 }); // pad + try f.writeStreamingAll(io, &.{ 0, 0, 0, 0 }); // entry_count = 0 + } + + // readGitHead on a v1 file must return null (no git head stored) + const git_head = try TrigramIndex.readGitHead(io, dir_path, alloc); + try testing.expect(git_head == null); + + // readFromDisk on a v1 file must still succeed (backward compat) + const loaded = TrigramIndex.readFromDisk(io, dir_path, alloc); + try testing.expect(loaded != null); + var loaded_ti = loaded.?; + defer loaded_ti.deinit(); + try testing.expectEqual(@as(u32, 0), loaded_ti.fileCount()); +} + + +test "issue-105: large files skip trigram indexing to prevent OOM" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // Create content just over 64KB — should be indexed for outline/word but NOT trigram + const large_content = try testing.allocator.alloc(u8, 65 * 1024); + defer testing.allocator.free(large_content); + @memset(large_content, 'a'); + // Make it valid Zig so outline parsing works + @memcpy(large_content[0..21], "pub fn bigFunc() void"); + + // indexFileSkipTrigram should succeed without building trigrams + try explorer.indexFileSkipTrigram("large.zig", large_content); + + // The file should be in outlines and contents but NOT in the trigram index + try testing.expect(explorer.outlines.count() == 1); + try testing.expect(explorer.contents.count() == 1); + try testing.expect(explorer.trigram_index.fileCount() == 0); + + // A small file should still get trigram-indexed + try explorer.indexFile("small.zig", "pub fn tiny() void {}"); + try testing.expect(explorer.trigram_index.fileCount() == 1); +} + + +test "issue-107: codedb_deps returns results for Python files" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("mypackage/utils/helpers.py", "def helper_func():\n pass\n"); + try explorer.indexFile("consumer.py", "from mypackage.utils.helpers import helper_func\n"); + + const deps = try explorer.getImportedBy("mypackage/utils/helpers.py", testing.allocator); + defer { + for (deps) |d| testing.allocator.free(d); + testing.allocator.free(deps); + } + + try testing.expect(deps.len == 1); + try testing.expectEqualStrings("consumer.py", deps[0]); +} + + +test "regression-142: trigram index finds all matching files" { + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + try exp.indexFile("src/main.zig", "pub fn handleRequest(ctx: *Context) !void {}"); + try exp.indexFile("src/server.zig", "fn handleRequest(req: Request) void {}"); + try exp.indexFile("src/util.zig", "pub fn formatDate() []u8 {}"); + + const results = try exp.searchContent("handleRequest", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + // Must find both files containing "handleRequest" + try testing.expect(results.len == 2); +} + + +test "regression-142: trigram index returns no false positives" { + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + try exp.indexFile("a.zig", "pub fn alpha() void {}"); + try exp.indexFile("b.zig", "pub fn beta() void {}"); + + const results = try exp.searchContent("gamma", testing.allocator, 50); + defer testing.allocator.free(results); + // Must return zero results for non-existent content + try testing.expect(results.len == 0); +} + + +test "regression-142: trigram intersection narrows correctly" { + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + try exp.indexFile("match.zig", "const unique_identifier_xyz = 42;"); + try exp.indexFile("partial.zig", "const unique_other = 99;"); + try exp.indexFile("none.zig", "pub fn foo() void {}"); + + const results = try exp.searchContent("unique_identifier_xyz", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + // Only the exact match file, not the partial + try testing.expect(results.len == 1); + try testing.expectEqualStrings("match.zig", results[0].path); +} + + +test "regression-142: trigram handles file removal" { + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + try exp.indexFile("temp.zig", "pub fn removable() void {}"); + try exp.indexFile("keep.zig", "pub fn permanent() void {}"); + + // Remove a file + exp.removeFile("temp.zig"); + + const results = try exp.searchContent("removable", testing.allocator, 50); + defer testing.allocator.free(results); + try testing.expect(results.len == 0); + + const results2 = try exp.searchContent("permanent", testing.allocator, 50); + defer { + for (results2) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results2); + } + try testing.expect(results2.len == 1); +} + + +test "regression-142: trigram handles re-indexing same file" { + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + try exp.indexFile("mutable.zig", "pub fn oldContent() void {}"); + try exp.indexFile("mutable.zig", "pub fn newContent() void {}"); + + const old = try exp.searchContent("oldContent", testing.allocator, 50); + defer testing.allocator.free(old); + try testing.expect(old.len == 0); + + const new = try exp.searchContent("newContent", testing.allocator, 50); + defer { + for (new) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(new); + } + try testing.expect(new.len == 1); +} + + +test "regression-142: trigram disk roundtrip preserves results" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + // Build index + var idx1 = TrigramIndex.init(testing.allocator); + try idx1.indexFile("a.zig", "pub fn searchable() void {}"); + try idx1.indexFile("b.zig", "const value = 42;"); + + // Write to disk + try idx1.writeToDisk(io, dir_path, null); + idx1.deinit(); + + // Read back + var idx2 = TrigramIndex.readFromDisk(io, dir_path, testing.allocator) orelse return error.TestUnexpectedResult; + defer idx2.deinit(); + + // Must find same results + const cands = idx2.candidates("searchable", testing.allocator) orelse return error.TestUnexpectedResult; + defer testing.allocator.free(cands); + try testing.expect(cands.len == 1); +} + + +test "regression-142: many files don't corrupt index" { + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + // Index 500 files + var i: usize = 0; + while (i < 500) : (i += 1) { + var name_buf: [32]u8 = undefined; + const name = try std.fmt.bufPrint(&name_buf, "file_{d}.zig", .{i}); + var content_buf: [64]u8 = undefined; + const content = try std.fmt.bufPrint(&content_buf, "pub fn func_{d}() void {{}}", .{i}); + try exp.indexFile(name, content); + } + + // Search for a specific one + const results = try exp.searchContent("func_250", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len == 1); + try testing.expectEqualStrings("file_250.zig", results[0].path); +} + + +test "regression-142: short queries fall back gracefully" { + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + try exp.indexFile("a.zig", "pub fn ab() void {}"); + + // 2-char query: too short for trigrams, should still work via fallback + const results = try exp.searchContent("ab", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len == 1); +} + + +test "regression-142: word index still works alongside trigram" { + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + try exp.indexFile("words.zig", "pub fn mySpecialFunction() void {}"); + + const hits = try exp.searchWord("mySpecialFunction", testing.allocator); + defer testing.allocator.free(hits); + try testing.expect(hits.len == 1); +} + + +test "issue-164: mmap trigram index returns same candidates as heap index" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const allocator = arena.allocator(); + + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth.zig", "pub fn handleAuth(req: *Request) !void { validate(req); }"); + try explorer.indexFile("src/gate.zig", "pub fn checkGate(ctx: *Context) !bool { return ctx.authenticated; }"); + try explorer.indexFile("src/util.zig", "pub fn formatStr(buf: []u8, args: anytype) !void {}"); + + const heap_results = explorer.trigram_index.candidates("handleAuth", allocator) orelse + return error.NoCandidates; + + try testing.expect(heap_results.len >= 1); + + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const tmp_path_len = try tmp_dir.dir.realPathFile(io, ".", &path_buf); + const tmp_path = path_buf[0..tmp_path_len]; + + try explorer.trigram_index.writeToDisk(io, tmp_path, null); + + var mmap_idx = MmapTrigramIndex.initFromDisk(io, tmp_path, testing.allocator) orelse + return error.MmapInitFailed; + defer mmap_idx.deinit(); + + const mmap_results = mmap_idx.candidates("handleAuth", allocator) orelse + return error.NoCandidates; + + try testing.expect(mmap_results.len >= 1); + try testing.expectEqual(heap_results.len, mmap_results.len); + try testing.expectEqual(explorer.trigram_index.fileCount(), mmap_idx.fileCount()); + try testing.expect(mmap_idx.containsFile("src/auth.zig")); + try testing.expect(mmap_idx.containsFile("src/gate.zig")); + try testing.expect(!mmap_idx.containsFile("nonexistent.zig")); +} + + +test "issue-164: mmap binary search on sorted lookup table" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const allocator = arena.allocator(); + + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("a.zig", "const alpha = 42;"); + try explorer.indexFile("b.zig", "const beta = 43;"); + try explorer.indexFile("c.zig", "const gamma = 44;"); + try explorer.indexFile("d.zig", "const delta = 45;"); + try explorer.indexFile("e.zig", "const alpha_beta = 99;"); + + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const tmp_path_len = try tmp_dir.dir.realPathFile(io, ".", &path_buf); + const tmp_path = path_buf[0..tmp_path_len]; + + try explorer.trigram_index.writeToDisk(io, tmp_path, null); + + var mmap_idx = MmapTrigramIndex.initFromDisk(io, tmp_path, testing.allocator) orelse + return error.MmapInitFailed; + defer mmap_idx.deinit(); + + const results = mmap_idx.candidates("alpha", allocator) orelse + return error.NoCandidates; + try testing.expect(results.len >= 2); + + const no_results = mmap_idx.candidates("zzzzz", allocator); + if (no_results) |nr| { + try testing.expectEqual(@as(usize, 0), nr.len); + } +} + + +test "issue-164: mmap handles missing files gracefully" { + const result = MmapTrigramIndex.initFromDisk(io, "/tmp/nonexistent-codedb-test-dir-164", testing.allocator); + try testing.expect(result == null); +} + + +test "issue-164: AnyTrigramIndex dispatches to mmap variant" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const allocator = arena.allocator(); + + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("foo.zig", "pub fn fooBar(x: i32) i32 { return x + 1; }"); + + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const tmp_path_len = try tmp_dir.dir.realPathFile(io, ".", &path_buf); + const tmp_path = path_buf[0..tmp_path_len]; + + try explorer.trigram_index.writeToDisk(io, tmp_path, null); + + const mmap_loaded = MmapTrigramIndex.initFromDisk(io, tmp_path, testing.allocator) orelse + return error.MmapInitFailed; + + explorer.trigram_index.deinit(); + explorer.trigram_index = .{ .mmap = mmap_loaded }; + + const results = try explorer.searchContent("fooBar", allocator, 10); + try testing.expect(results.len >= 1); + + try testing.expect(explorer.trigram_index.containsFile("foo.zig")); + try testing.expect(!explorer.trigram_index.containsFile("bar.zig")); +} + + +test "issue-246: TrigramIndex.removeFile cleans stale path_to_id left by failed indexFile" { + // Reproduces the corrupted state an OOM mid-way through indexFile leaves: + // removeFile cleared file_trigrams, getOrCreateDocId wrote to path_to_id, + // then an allocation failure meant file_trigrams.put never completed. + // Fix: removeFile must purge path_to_id even when file_trigrams has no entry. + var idx = TrigramIndex.init(testing.allocator); + defer idx.deinit(); + + // Plant the invariant-violating state OOM would leave behind. + try idx.path_to_id.put("ghost.zig", 0); + try idx.id_to_path.append(testing.allocator, "ghost.zig"); + // file_trigrams intentionally has NO entry for "ghost.zig". + + idx.removeFile("ghost.zig"); + + // Currently FAILS: removeFile returns early at the second file_trigrams.getPtr + // check, leaving path_to_id permanently dirty. + try testing.expectEqual(@as(usize, 0), idx.path_to_id.count()); +} + + +test "issue-247: TrigramIndex.id_to_path does not grow on re-index of same file" { + // removeFile removes path_to_id[path] but leaves the id_to_path slot intact. + // getOrCreateDocId then appends a new slot since path_to_id misses. + // After N re-indexes id_to_path.items.len must equal the number of *unique* files. + var idx = TrigramIndex.init(testing.allocator); + defer idx.deinit(); + + const src = "fn alpha() void {} fn beta() void {} const X = 1;"; + var i: usize = 0; + while (i < 5) : (i += 1) { + try idx.indexFile("f.zig", src); + } + + // Currently FAILS: id_to_path.items.len == 5 (grows by 1 per re-index). + try testing.expectEqual(@as(usize, 1), idx.id_to_path.items.len); +} + + +test "issue-227: TrigramIndex.id_to_path stays bounded across many files re-indexed" { + // Broader regression: ensure re-indexing multiple distinct files also doesn't + // accumulate dead id_to_path slots. + var idx = TrigramIndex.init(testing.allocator); + defer idx.deinit(); + + const files = [_][]const u8{ "a.zig", "b.zig", "c.zig" }; + var round: usize = 0; + while (round < 4) : (round += 1) { + for (files) |f| try idx.indexFile(f, "fn foo() void {}"); + } + + // 3 unique files × 4 rounds = 12 slots currently; fix should keep it at 3. + try testing.expectEqual(@as(usize, files.len), idx.id_to_path.items.len); +} + + +test "issue-248: PostingList.removeDocId removes target and preserves sorted order" { + // Documents the correctness contract for the O(log n) binary-search replacement. + // Currently correct but O(n); fix replaces linear scan with bsearch + single remove. + const PostingList = @import("index.zig").PostingList; + var list = PostingList{}; + defer list.items.deinit(testing.allocator); + + var id: u32 = 0; + while (id < 100) : (id += 1) { + const p = try list.getOrAddPosting(testing.allocator, id * 2); // even doc_ids 0..198 + p.loc_mask = 0xFF; + } + + list.removeDocId(50); + try testing.expectEqual(@as(usize, 99), list.items.items.len); + try testing.expect(list.getByDocId(48) != null); + try testing.expect(list.getByDocId(50) == null); + try testing.expect(list.getByDocId(52) != null); + + // Sorted invariant must hold after removal. + for (1..list.items.items.len) |k| { + try testing.expect(list.items.items[k].doc_id > list.items.items[k - 1].doc_id); + } +} + + +test "issue-250: searchContent finds content in files skipped by trigram index" { + // Files indexed with skip_trigram=true (e.g. past the 15k cap) must still be + // reachable via the fallback full-scan path in searchContent. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFileSkipTrigram("large.zig", "fn unique_zzz_sentinel() void {}"); + + const results = try explorer.searchContent("unique_zzz_sentinel", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expectEqual(@as(usize, 1), results.len); +} + + +test "issue-262: sparse+trigram intersection drops files only in trigram index" { + // When both sparse and trigram indices return candidates, searchContent + // intersects them. A file present in trigram candidates but absent from + // sparse candidates is silently dropped — a recall loss. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // Index two files — both contain the query. + try explorer.indexFile("a.zig", "fn recall_target_alpha() void {}"); + try explorer.indexFile("b.zig", "fn recall_target_alpha() void {} // more text here for variety"); + + // Simulate sparse index missing file "b.zig" (e.g. boundary misalignment). + // File b.zig remains in the trigram index but not in sparse. + explorer.sparse_ngram_index.removeFile("b.zig"); + + const results = try explorer.searchContent("recall_target_alpha", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + // Both files contain the query — both must appear. + try testing.expectEqual(@as(usize, 2), results.len); +} + + +test "issue-263: skip_trigram_files searched before max_results exhausted" { + // Files indexed with skip_trigram=true are only searched after all + // trigram/sparse/word paths are exhausted. When a single normal file + // has enough matches to fill max_results, the skip_trigram file is + // never checked — even though it contains relevant content. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // Normal file with 6 matches (one per line). + try explorer.indexFile("noisy.zig", + \\fn my_unique_func() void {} + \\fn my_unique_func_v2() void {} + \\const my_unique_func_ptr = undefined; + \\var my_unique_func_state = 0; + \\test "my_unique_func works" {} + \\// calls my_unique_func internally + ); + + // skip-trigram file with 1 match. + try explorer.indexFileSkipTrigram("large.zig", "fn my_unique_func() void {}"); + + // max_results=5: the normal file fills the quota, skip_trigram never searched. + const results = try explorer.searchContent("my_unique_func", testing.allocator, 5); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + // The skip_trigram file must be represented in results. + var found_large = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "large.zig")) found_large = true; + } + try testing.expect(found_large); +} + + +test "search: BM25 ranks higher-frequency line first" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // Line with two occurrences of "token" should outrank line with one + const content = "// single token mention\nconst token = token_cache.get();\n"; + try explorer.indexFile("auth.zig", content); + + const results = try explorer.searchContent("token", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + try testing.expect(results.len >= 2); + // Line 2 has "token" twice; line 1 has it once — line 2 should come first + try testing.expect(results[0].score >= results[1].score); + try testing.expectEqual(@as(u32, 2), results[0].line_num); +} + + +test "issue-388: TrigramIndex.removeFile frees owned path on tombstone" { + // owns_paths=true means getOrCreateDocId duped the path so callers can + // free their copy. removeFile must release that dup before tombstoning + // the slot — otherwise every snapshot-loaded session leaks one path + // allocation per file removed/re-indexed. + var idx = TrigramIndex.init(testing.allocator); + defer idx.deinit(); + idx.owns_paths = true; + + const path = "src/leaky.zig"; + try idx.indexFile(path, "pub fn leaky() void {}\n"); + idx.removeFile(path); + + // testing.allocator reports any unfreed bytes when this scope exits via + // deinit. The bug leaks the dup on the tombstoned id_to_path slot + // (cleared to ""), so deinit's `if (p.len > 0) free(p)` misses it. +} + + +test "bm25-persistence: writeToDisk/readFromDisk preserves total_tokens and doc_lengths" { + const alloc = testing.allocator; + var wi = WordIndex.init(alloc); + defer wi.deinit(); + + try wi.indexFile("low.txt", "needle filler filler filler filler filler filler filler filler filler"); + try wi.indexFile("high.txt", "needle needle needle filler"); + try wi.indexFile("none.txt", "filler filler filler filler"); + + const pre_total = wi.total_tokens; + const pre_low_len = wi.docLength(wi.path_to_id.get("low.txt") orelse 0); + const pre_high_len = wi.docLength(wi.path_to_id.get("high.txt") orelse 0); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + try wi.writeToDisk(io, dir_path, null); + + const maybe_loaded = WordIndex.readFromDisk(io, dir_path, alloc); + try testing.expect(maybe_loaded != null); + var loaded = maybe_loaded.?; + defer loaded.deinit(); + + try testing.expectEqual(pre_total, loaded.total_tokens); + + const post_low_id = loaded.path_to_id.get("low.txt") orelse { + try testing.expect(false); + return; + }; + const post_high_id = loaded.path_to_id.get("high.txt") orelse { + try testing.expect(false); + return; + }; + try testing.expectEqual(pre_low_len, loaded.docLength(post_low_id)); + try testing.expectEqual(pre_high_len, loaded.docLength(post_high_id)); + + const hits = try loaded.searchDeduped("needle", alloc); + defer alloc.free(hits); + try testing.expect(hits.len >= 2); + + var saw_high = false; + var saw_low = false; + for (hits) |h| { + const p = loaded.hitPath(h); + if (std.mem.eql(u8, p, "high.txt")) saw_high = true; + if (std.mem.eql(u8, p, "low.txt")) saw_low = true; + } + try testing.expect(saw_high); + try testing.expect(saw_low); + + // Post-roundtrip ranked search must still work and return hits for "needle". + var wi2 = WordIndex.init(alloc); + defer wi2.deinit(); + try wi2.indexFile("low.txt", "needle filler filler filler filler filler filler filler filler filler"); + try wi2.indexFile("high.txt", "needle needle needle filler"); + try wi2.indexFile("none.txt", "filler filler filler filler"); + + const low_id_orig = wi2.path_to_id.get("low.txt") orelse 0; + const high_id_orig = wi2.path_to_id.get("high.txt") orelse 0; + try testing.expectEqual(pre_low_len, wi2.docLength(low_id_orig)); + try testing.expectEqual(pre_high_len, wi2.docLength(high_id_orig)); + try testing.expectEqual(pre_total, wi2.total_tokens); +} + + +test "issue-451: scope search surfaces skip-trigram canonical file" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + var i: usize = 0; + while (i < 12) : (i += 1) { + var path_buf: [32]u8 = undefined; + const path = try std.fmt.bufPrint(&path_buf, "small_{d}.zig", .{i}); + try explorer.indexFile(path, "fn s() void { _ = widgetX; }\n"); + } + + const canonical_content = + "fn canonical() void {\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + "}\n"; + try explorer.indexFileSkipTrigram("canonical.zig", canonical_content); + + const results = try explorer.searchContentWithScope("widgetX", testing.allocator, 5); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + if (r.scope_name) |n| testing.allocator.free(n); + } + testing.allocator.free(results); + } + + var found_canonical = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "canonical.zig")) found_canonical = true; + } + try testing.expect(found_canonical); +} + + +test "issue-447: searchContent surfaces large (>64KB) skip-trigram files for common identifiers" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + var i: usize = 0; + while (i < 12) : (i += 1) { + var path_buf: [32]u8 = undefined; + const path = try std.fmt.bufPrint(&path_buf, "small_{d}.zig", .{i}); + try explorer.indexFile(path, "fn s() void { _ = widgetX; }\n"); + } + + const canonical_content = + "fn canonical() void {\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + "}\n"; + try explorer.indexFileSkipTrigram("canonical.zig", canonical_content); + + const results = try explorer.searchContent("widgetX", testing.allocator, 5); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + var found_canonical = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "canonical.zig")) found_canonical = true; + } + try testing.expect(found_canonical); +} + diff --git a/src/test_mcp.zig b/src/test_mcp.zig new file mode 100644 index 0000000..66540e7 --- /dev/null +++ b/src/test_mcp.zig @@ -0,0 +1,1568 @@ +const std = @import("std"); +const cio = @import("cio.zig"); +const testing = std.testing; +const io = std.testing.io; +const Store = @import("store.zig").Store; +const Explorer = @import("explore.zig").Explorer; +const explore = @import("explore.zig"); +const Language = explore.Language; +const AgentRegistry = @import("agent.zig").AgentRegistry; +const mcp_mod = @import("mcp.zig"); +const main_mod = @import("main.zig"); +const nuke_mod = @import("nuke.zig"); +const update_mod = @import("update.zig"); +const Config = @import("config.zig").Config; +const telemetry_mod = @import("telemetry.zig"); +const release_info = @import("release_info.zig"); +const root_policy = @import("root_policy.zig"); +const edit_mod = @import("edit.zig"); +const snapshot_mod = @import("snapshot.zig"); +const watcher = @import("watcher.zig"); +const WordIndex = @import("index.zig").WordIndex; +const TrigramIndex = @import("index.zig").TrigramIndex; +const SparseNgramIndex = @import("index.zig").SparseNgramIndex; +comptime { + _ = @import("config.zig"); +} + + +fn buildCliForHelpTests() !void { + const build = try cio.runCapture(.{ + .allocator = testing.allocator, + .argv = &.{ "zig", "build" }, + .max_output_bytes = 8192, + }); + defer testing.allocator.free(build.stdout); + defer testing.allocator.free(build.stderr); + + try testing.expect(build.term == .Exited); + try testing.expect(build.term.Exited == 0); +} + + +test "issue-59: telemetry writes session, tool, and codebase stats ndjson" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + var telem = telemetry_mod.Telemetry.init(io, dir_path, testing.allocator, false); + defer telem.deinit(); + + telem.recordSessionStart(); + telem.recordToolCall("codedb_status", 1234, false, 56); + + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + try explorer.indexFile("src/lib.py", "def run():\n return 1\n"); + + telem.recordCodebaseStats(&explorer, 42); + telem.flush(); + + const ndjson_path = try std.fmt.allocPrint(testing.allocator, "{s}/telemetry.ndjson", .{dir_path}); + defer testing.allocator.free(ndjson_path); + + const contents = try std.Io.Dir.cwd().readFileAlloc(io, ndjson_path, testing.allocator, .limited(64 * 1024)); + defer testing.allocator.free(contents); + + try testing.expect(std.mem.indexOf(u8, contents, "\"event_type\":\"session_start\"") != null); + const version_needle = try std.fmt.allocPrint(testing.allocator, "\"version\":\"{s}\"", .{release_info.semver}); + defer testing.allocator.free(version_needle); + try testing.expect(std.mem.indexOf(u8, contents, version_needle) != null); + try testing.expect(std.mem.indexOf(u8, contents, "\"event_type\":\"tool_call\"") != null); + try testing.expect(std.mem.indexOf(u8, contents, "\"tool\":\"codedb_status\"") != null); + try testing.expect(std.mem.indexOf(u8, contents, "\"event_type\":\"codebase_stats\"") != null); + try testing.expect(std.mem.indexOf(u8, contents, "\"startup_time_ms\":42") != null); + try testing.expect(std.mem.indexOf(u8, contents, "\"languages\":[\"zig\",\"python\"]") != null); +} + + +test "issue-60: telemetry disabled path is a no-op" { + var telem = telemetry_mod.Telemetry.init(io, "/tmp", testing.allocator, true); + defer telem.deinit(); + + telem.recordSessionStart(); + telem.recordToolCall("codedb_search", 99, true, 10); + try testing.expect(!telem.enabled); + try testing.expect(telem.file == null); + try testing.expect(telem.head.load(.monotonic) == 0); +} + + +test "issue-77: mcp index accepts temporary-directory roots that cause pathological cache growth" { + var tmp_name_buf: [128]u8 = undefined; + const tmp_name = try std.fmt.bufPrint(&tmp_name_buf, "codedb-issue-77-{d}", .{@as(i64, @intCast(@divTrunc(cio.nanoTimestamp(), 1000)))}); + const tmp_root = try std.fs.path.join(testing.allocator, &.{ "/private/tmp", tmp_name }); + defer testing.allocator.free(tmp_root); + + std.Io.Dir.cwd().createDirPath(io, tmp_root) catch |err| switch (err) { + error.PathAlreadyExists => {}, + else => return err, + }; + defer std.Io.Dir.cwd().deleteTree(io, tmp_root) catch {}; + + const source_path = try std.fs.path.join(testing.allocator, &.{ tmp_root, "sample.zig" }); + defer testing.allocator.free(source_path); + { + const file = try std.Io.Dir.cwd().createFile(io, source_path, .{}); + defer file.close(io); + try file.writeStreamingAll(io, "pub fn sample() void {}\n"); + } + + const result = try cio.runCapture(.{ + .allocator = testing.allocator, + .argv = &.{ "zig", "build", "run", "--", tmp_root, "snapshot" }, + .max_output_bytes = 256 * 1024, + }); + defer testing.allocator.free(result.stdout); + defer testing.allocator.free(result.stderr); + + try testing.expect(result.term.Exited != 0); +} + + +test "issue-93: isSensitivePath blocks .env and credentials" { + try testing.expect(watcher.isSensitivePath(".env")); + try testing.expect(watcher.isSensitivePath(".env.local")); + try testing.expect(watcher.isSensitivePath(".env.production")); + try testing.expect(watcher.isSensitivePath("credentials.json")); + try testing.expect(watcher.isSensitivePath("service-account.json")); + try testing.expect(watcher.isSensitivePath("id_rsa")); + try testing.expect(watcher.isSensitivePath("secrets.yaml")); + try testing.expect(watcher.isSensitivePath("config/secrets.yml")); + try testing.expect(watcher.isSensitivePath("server.key")); + try testing.expect(watcher.isSensitivePath("cert.pem")); + try testing.expect(watcher.isSensitivePath("keystore.jks")); + try testing.expect(watcher.isSensitivePath("identity.pfx")); + try testing.expect(watcher.isSensitivePath(".ssh/known_hosts")); + // Normal files should NOT be blocked + try testing.expect(!watcher.isSensitivePath("main.zig")); + try testing.expect(!watcher.isSensitivePath("src/server.zig")); + try testing.expect(!watcher.isSensitivePath("README.md")); + try testing.expect(!watcher.isSensitivePath("package.json")); +} + + +test "issue-93: isPathSafe blocks traversal" { + const MCP = @import("mcp.zig"); + try testing.expect(!MCP.isPathSafe("../../../etc/passwd")); + try testing.expect(!MCP.isPathSafe("/etc/passwd")); + try testing.expect(!MCP.isPathSafe("")); + try testing.expect(MCP.isPathSafe("src/main.zig")); + try testing.expect(MCP.isPathSafe("README.md")); +} + + +test "auto-update: shouldRunAutoUpdate gates correctly" { + const day_ms: i64 = 24 * 60 * 60 * 1000; + + // Disabled by env: never runs + try testing.expect(!update_mod.shouldRunAutoUpdate(0, null, true)); + try testing.expect(!update_mod.shouldRunAutoUpdate(day_ms * 100, null, true)); + try testing.expect(!update_mod.shouldRunAutoUpdate(day_ms * 100, 0, true)); + + // First run (no stamp): always runs when not disabled + try testing.expect(update_mod.shouldRunAutoUpdate(0, null, false)); + + // Throttled: <24h since last check → skip + try testing.expect(!update_mod.shouldRunAutoUpdate(day_ms - 1, 0, false)); + + // Exactly 24h since last check → run + try testing.expect(update_mod.shouldRunAutoUpdate(day_ms, 0, false)); + + // Long after last check → run + try testing.expect(update_mod.shouldRunAutoUpdate(day_ms * 7, 0, false)); +} + + +test "issue-394: shouldRunAutoUpdate permanently blocked by future-timestamp stamp file" { + // Reproduces the case where the stamp file contains a timestamp in the + // future relative to the wall clock — for example, after an NTP clock + // correction that rolls the clock back, or after a stamp written by a + // host with a fast clock. The current implementation computes + // (now - last) and only fires when that delta >= 24h, so a future + // `last` produces a negative delta and the check is silently skipped + // for as long as the stamp stays in the future — potentially many days. + // + // Expected: a wildly future stamp should NOT prevent the next check + // from firing. The simplest correct behavior is: if last > now, treat + // the stamp as invalid and allow the update check to run. + + const day_ms: i64 = 24 * 60 * 60 * 1000; + const now_ms: i64 = 1_700_000_000_000; + const future_last_ms: i64 = now_ms + day_ms * 30; // 30 days in the future + + try testing.expect(update_mod.shouldRunAutoUpdate(now_ms, future_last_ms, false)); +} + + +test "issue-395: shouldRunAutoUpdate panics on i64 underflow when stamp is corrupt" { + // Reproduces a panic when ~/.codedb/last_auto_update_check is corrupt + // and decodes to a very negative i64. readAutoUpdateStamp does no + // sanity check — it reads 8 bytes, calls std.mem.readInt(i64, ...), + // and feeds that straight into shouldRunAutoUpdate, which evaluates + // `now_ms - last` with checked subtraction. For last = minInt(i64) + // and any positive now_ms, the subtraction overflows and triggers an + // integer-overflow panic in Debug / ReleaseSafe builds (which is what + // `zig build test` and the shipped MCP binary use). + // + // Result: every `codedb mcp` startup crashes during the auto-update + // gate for any user whose stamp file got corrupted to a value with + // the high bit set (e.g. truncated write, partial flush, or any byte + // sequence starting with 0x80..0xFF in the stamp). + // + // Expected fix: clamp the delta with a saturating/wrapping subtraction + // or treat any last_ms <= 0 (or in the distant past) as invalid and + // run the update. + + const now_ms: i64 = 1_700_000_000_000; + const last_ms: i64 = std.math.minInt(i64); + + try testing.expect(update_mod.shouldRunAutoUpdate(now_ms, last_ms, false)); +} + + +test "issue-150: --help prints usage" { + try buildCliForHelpTests(); + + const result = try cio.runCapture(.{ + .allocator = testing.allocator, + .argv = &.{ "./zig-out/bin/codedb", "--help" }, + .max_output_bytes = 8192, + }); + defer testing.allocator.free(result.stdout); + defer testing.allocator.free(result.stderr); + + try testing.expect(result.term == .Exited); + try testing.expect(result.term.Exited == 0); + try testing.expect(std.mem.indexOf(u8, result.stdout, "usage:") != null or + std.mem.indexOf(u8, result.stderr, "usage:") != null); + try testing.expect(std.mem.indexOf(u8, result.stdout, "update") != null or + std.mem.indexOf(u8, result.stderr, "update") != null); + try testing.expect(std.mem.indexOf(u8, result.stdout, "nuke") != null or + std.mem.indexOf(u8, result.stderr, "nuke") != null); +} + + +test "issue-150: -h prints usage" { + try buildCliForHelpTests(); + + const result = try cio.runCapture(.{ + .allocator = testing.allocator, + .argv = &.{ "./zig-out/bin/codedb", "-h" }, + .max_output_bytes = 8192, + }); + defer testing.allocator.free(result.stdout); + defer testing.allocator.free(result.stderr); + + try testing.expect(result.term == .Exited); + try testing.expect(result.term.Exited == 0); + try testing.expect(std.mem.indexOf(u8, result.stdout, "usage:") != null or + std.mem.indexOf(u8, result.stderr, "usage:") != null); +} + + +test "update: compareVersions orders semantic versions" { + try testing.expect(try update_mod.compareVersions("0.2.55", "0.2.56") == .lt); + try testing.expect(try update_mod.compareVersions("0.2.56", "0.2.56") == .eq); + try testing.expect(try update_mod.compareVersions("v0.2.57", "0.2.56") == .gt); + try testing.expect(try update_mod.compareVersions("0.2.56", "0.2.56.0") == .eq); +} + + +test "update: checksumForBinary parses release manifest" { + const manifest = + \\7be38140d090b2e23723c8cde02be150171c818daa16b18c520b44cc1e078add codedb-darwin-arm64 + \\76bc7b81bc9fd211aa2c1ac59d1d26e8c80bc211ab560de2dc998ea9e04ec471 codedb-darwin-x86_64 + \\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *codedb-linux-arm64 + ; + + try testing.expectEqualStrings( + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + update_mod.checksumForBinary(manifest, "codedb-linux-arm64") orelse return error.TestUnexpectedResult, + ); + try testing.expect(update_mod.checksumForBinary(manifest, "codedb-linux-x86_64") == null); +} + + +test "update: asset names match published release naming" { + try testing.expectEqualStrings("codedb-darwin-arm64", update_mod.assetNameForTarget(.macos, .aarch64).?); + try testing.expectEqualStrings("codedb-darwin-x86_64", update_mod.assetNameForTarget(.macos, .x86_64).?); + try testing.expectEqualStrings("codedb-linux-arm64", update_mod.assetNameForTarget(.linux, .aarch64).?); + try testing.expectEqualStrings("codedb-linux-x86_64", update_mod.assetNameForTarget(.linux, .x86_64).?); + try testing.expect(update_mod.assetNameForTarget(.windows, .x86_64) == null); +} + + +test "nuke: commandTargetsBinary only matches the current install path" { + try testing.expect(nuke_mod.commandTargetsBinary( + "/tmp/codedb-test/bin/codedb serve", + "/tmp/codedb-test/bin/codedb", + )); + try testing.expect(nuke_mod.commandTargetsBinary( + "/var/folders/example/codedb serve", + "/private/var/folders/example/codedb", + )); + try testing.expect(!nuke_mod.commandTargetsBinary( + "/Users/rachpradhan/bin/codedb --mcp", + "/tmp/codedb-test/bin/codedb", + )); +} + + +test "nuke: removeJsonMcpServerEntry drops only codedb integration" { + const input = + \\{ + \\ "mcpServers": { + \\ "codedb": { "command": "/Users/me/bin/codedb", "args": ["mcp"] }, + \\ "other": { "command": "other", "args": [] } + \\ }, + \\ "theme": "dark" + \\} + ; + + const output = (try nuke_mod.removeJsonMcpServerEntry(testing.allocator, input, "codedb")) orelse + return error.TestUnexpectedResult; + defer testing.allocator.free(output); + + try testing.expect(std.mem.indexOf(u8, output, "\"codedb\"") == null); + try testing.expect(std.mem.indexOf(u8, output, "\"other\"") != null); + try testing.expect(std.mem.indexOf(u8, output, "\"theme\"") != null); +} + + +test "nuke: removeJsonMcpServerEntry removes empty mcpServers object" { + const input = + \\{ + \\ "mcpServers": { + \\ "codedb": { "command": "/Users/me/bin/codedb", "args": ["mcp"] } + \\ }, + \\ "theme": "dark" + \\} + ; + + const output = (try nuke_mod.removeJsonMcpServerEntry(testing.allocator, input, "codedb")) orelse + return error.TestUnexpectedResult; + defer testing.allocator.free(output); + + try testing.expect(std.mem.indexOf(u8, output, "\"codedb\"") == null); + try testing.expect(std.mem.indexOf(u8, output, "\"mcpServers\"") == null); + try testing.expect(std.mem.indexOf(u8, output, "\"theme\"") != null); +} + + +test "nuke: removeCodexMcpServerBlock removes codedb block only" { + const input = + \\[mcp_servers.codedb] + \\command = "/Users/me/bin/codedb" + \\args = ["mcp"] + \\startup_timeout_sec = 30 + \\ + \\[mcp_servers.other] + \\command = "other" + \\args = [] + ; + + const output = (try nuke_mod.removeCodexMcpServerBlock(testing.allocator, input, "codedb")) orelse + return error.TestUnexpectedResult; + defer testing.allocator.free(output); + + try testing.expect(std.mem.indexOf(u8, output, "[mcp_servers.codedb]") == null); + try testing.expect(std.mem.indexOf(u8, output, "[mcp_servers.other]") != null); + try testing.expect(std.mem.indexOf(u8, output, "command = \"other\"") != null); +} + + +test "nuke: removeCodexMcpServerBlock matches indented header with inline comment" { + const input = + \\ [mcp_servers.codedb] # local override + \\command = "/Users/me/bin/codedb" + \\args = ["mcp"] + \\ + \\[mcp_servers.other] + \\command = "other" + \\args = [] + ; + + const output = (try nuke_mod.removeCodexMcpServerBlock(testing.allocator, input, "codedb")) orelse + return error.TestUnexpectedResult; + defer testing.allocator.free(output); + + try testing.expect(std.mem.indexOf(u8, output, "codedb") == null); + try testing.expect(std.mem.indexOf(u8, output, "[mcp_servers.other]") != null); +} + + +test "nuke: deregisterJsonIntegrationFile handles configs larger than 64 KiB" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/large-claude.json", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + var content: std.ArrayList(u8) = .empty; + defer content.deinit(testing.allocator); + try content.appendSlice(testing.allocator, + \\{ + \\ "mcpServers": { + \\ "codedb": { "command": "/Users/me/bin/codedb", "args": ["mcp"] }, + \\ "other": { "command": "other", "args": [] } + \\ }, + \\ "padding": " + ); + try content.appendNTimes(testing.allocator, 'x', 70 * 1024); + try content.appendSlice(testing.allocator, "\"\n}\n"); + + var file = try tmp.dir.createFile(io, "large-claude.json", .{}); + defer file.close(io); + try file.writeStreamingAll(io, content.items); + + try testing.expect(try nuke_mod.deregisterJsonIntegrationFile(io, testing.allocator, rel_path)); + + const rewritten = try std.Io.Dir.cwd().readFileAlloc(io, rel_path, testing.allocator, .limited(std.math.maxInt(usize))); + defer testing.allocator.free(rewritten); + + try testing.expect(std.mem.indexOf(u8, rewritten, "\"codedb\"") == null); + try testing.expect(std.mem.indexOf(u8, rewritten, "\"other\"") != null); + try testing.expect(std.mem.indexOf(u8, rewritten, "\"padding\"") != null); +} + + +test "issue-148: dead MCP clients are polled every second" { + const mcp = @import("mcp.zig"); + try testing.expectEqual(@as(u64, 1000), mcp.dead_client_poll_ms); +} + + +test "issue-148: POLLHUP detects closed pipe" { + // Verify the polling infrastructure works for pipe-based transports + const pipe = try cio.makePipe(); + defer _ = std.c.close(pipe[0]); + + // Close write end — simulates client disconnect + _ = std.c.close(pipe[1]); + + // Poll should detect POLLHUP on the read end + var fds = [_]std.posix.pollfd{.{ + .fd = pipe[0], + .events = std.posix.POLL.IN, + .revents = 0, + }}; + + const n = try std.posix.poll(&fds, 100); // 100ms timeout + try testing.expect(n > 0); + try testing.expect((fds[0].revents & std.posix.POLL.HUP) != 0); +} + + +test "issue-148: idle watchdog exits on shutdown signal" { + // The watchdog should check shutdown every ~1s (not 30s) + // and return quickly when signalled + var shutdown = std.atomic.Value(bool).init(false); + + const t0 = cio.milliTimestamp(); + // Signal shutdown after a small delay + const signal_thread = try std.Thread.spawn(.{}, struct { + fn run(s: *std.atomic.Value(bool)) void { + cio.sleepMs(500); + s.store(true, .release); + } + }.run, .{&shutdown}); + + // Run a simplified watchdog loop (matches the real one's 1s granularity) + while (!shutdown.load(.acquire)) { + for (0..30) |_| { + if (shutdown.load(.acquire)) break; + cio.sleepMs(100); // faster for test + } + break; // one iteration is enough to test + } + signal_thread.join(); + + const elapsed = cio.milliTimestamp() - t0; + // With 1s granularity, should respond well under 5s (not 30s) + // Using 100ms intervals in test, so should be ~500ms + if (elapsed > 0) { + // Just verify it didn't hang for 30 seconds + try testing.expect(elapsed < 5_000); + } +} + + +test "issue-278: MCP tracks activity without using it as a transport timeout" { + const mcp = @import("mcp.zig"); + + // Save and restore + const saved = mcp.last_activity.load(.acquire); + defer mcp.last_activity.store(saved, .release); + + // Set activity to "just now" + mcp.last_activity.store(cio.milliTimestamp(), .release); + + const last = mcp.last_activity.load(.acquire); + const now = cio.milliTimestamp(); + try testing.expect(now - last < 1_000); +} + + +test "issue-278: MCP session may remain idle longer than old timeout" { + const mcp = @import("mcp.zig"); + // Stale activity is now only an accounting signal. The stdio transport is + // kept alive until the client actually disconnects. + const old_idle_timeout_ms = 60 * 60 * 1000; + const older_than_old_timeout = cio.milliTimestamp() - old_idle_timeout_ms - 1_000; + + // Save and restore + const saved = mcp.last_activity.load(.acquire); + defer mcp.last_activity.store(saved, .release); + + mcp.last_activity.store(older_than_old_timeout, .release); + const last = mcp.last_activity.load(.acquire); + const now = cio.milliTimestamp(); + + try testing.expect(now - last > old_idle_timeout_ms); +} + + +test "issue-148: open pipe does not trigger HUP" { + const pipe = try cio.makePipe(); + defer _ = std.c.close(pipe[0]); + defer _ = std.c.close(pipe[1]); + + var poll_fds = [_]std.posix.pollfd{.{ + .fd = pipe[0], + .events = std.posix.POLL.IN | std.posix.POLL.HUP, + .revents = 0, + }}; + + const result = try std.posix.poll(&poll_fds, 0); + try testing.expectEqual(@as(usize, 0), result); +} + + +test "issue-148: codedb mcp exits when stdin is closed" { + // Integration test: spawn codedb mcp, close stdin, verify it exits + var child = std.process.spawn(io, .{ + .argv = &.{ "zig", "build", "run", "--", "--mcp" }, + .stdin = .pipe, + .stdout = .pipe, + .stderr = .ignore, + }) catch { + // If spawn fails (e.g., zig not on PATH), skip the test + return; + }; + + // Send initialize then close stdin (simulate client crash) + const init_msg = "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"initialize\",\"params\":{\"protocolVersion\":\"2024-11-05\",\"capabilities\":{},\"clientInfo\":{\"name\":\"test\",\"version\":\"1\"}}}"; + const header = std.fmt.comptimePrint("Content-Length: {d}\r\n\r\n", .{init_msg.len}); + + if (child.stdin) |stdin| { + stdin.writeStreamingAll(io, header) catch {}; + stdin.writeStreamingAll(io, init_msg) catch {}; + // Close stdin — simulates client disconnecting + stdin.close(io); + child.stdin = null; + } + + // Wait for the process to exit. The main read loop exits on stdin EOF; + // the watchdog also polls dead clients every second as a backup. + const start = cio.milliTimestamp(); + const term = child.wait(io) catch { + // If wait fails, the process is stuck — test fails + try testing.expect(false); + return; + }; + + const elapsed = cio.milliTimestamp() - start; + + // Should have exited (not been killed by us) + switch (term) { + .exited => |code| _ = code, + else => {}, + } + + // Should exit promptly after stdin closes. + try testing.expect(elapsed < 5_000); +} + + +test "issue-249: nuke.removeJsonMcpServerEntry returns null when key absent" { + // Verifies removeJsonMcpServerEntry does not signal a write when key is absent, + // which ensures the non-atomic rewriteConfigFile path is never triggered unnecessarily. + const result = try nuke_mod.removeJsonMcpServerEntry(testing.allocator, "{\"other\":1}", "codedb"); + try testing.expect(result == null); +} + + +test "issue-207: ScanState round-trips through atomic" { + const initial = mcp_mod.getScanState(); + defer mcp_mod.setScanState(initial); + + mcp_mod.setScanState(.loading_snapshot); + try testing.expectEqual(mcp_mod.ScanState.loading_snapshot, mcp_mod.getScanState()); + + mcp_mod.setScanState(.walking); + try testing.expectEqual(mcp_mod.ScanState.walking, mcp_mod.getScanState()); + + mcp_mod.setScanState(.indexing); + try testing.expectEqual(mcp_mod.ScanState.indexing, mcp_mod.getScanState()); + + mcp_mod.setScanState(.ready); + try testing.expectEqual(mcp_mod.ScanState.ready, mcp_mod.getScanState()); +} + + +test "issue-207: ScanState.name covers all states" { + try testing.expectEqualStrings("loading_snapshot", mcp_mod.ScanState.loading_snapshot.name()); + try testing.expectEqualStrings("walking", mcp_mod.ScanState.walking.name()); + try testing.expectEqualStrings("indexing", mcp_mod.ScanState.indexing.name()); + try testing.expectEqualStrings("ready", mcp_mod.ScanState.ready.name()); +} + + +test "issue-346: root_policy rejects dangerous ambient cwd roots" { + try testing.expect(!root_policy.isIndexableRoot("/")); + try testing.expect(!root_policy.isIndexableRoot("/Applications")); + try testing.expect(!root_policy.isIndexableRoot("/usr")); + try testing.expect(!root_policy.isIndexableRoot("/usr/local")); + try testing.expect(!root_policy.isIndexableRoot("/usr/local/bin")); + try testing.expect(!root_policy.isIndexableRoot("/opt")); + try testing.expect(!root_policy.isIndexableRoot("/opt/homebrew")); +} + + +test "issue-357: bundle preserves nested 'arguments' for codedb_outline" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + try explorer.indexFile("src/lib.zig", "pub fn helper() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const bundle_json = + \\{"ops":[ + \\ {"tool":"codedb_outline","arguments":{"path":"src/main.zig"}}, + \\ {"tool":"codedb_outline","arguments":{"path":"src/lib.zig"}} + \\]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + // Nested-args bundle path must preserve 'path' for every op — no missing-arg errors. + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'path' argument") == null); + try testing.expect(std.mem.indexOf(u8, out.items, "src/main.zig") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "src/lib.zig") != null); +} + + +test "issue-357: bundle surfaces received keys when an op is missing required path" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + // Bundle with a wrong key name ('file_path' instead of 'path'). The op must + // fail (path is missing), but the bundle wrapper must surface the keys it + // received so the caller can tell whether codedb dropped the arg or the + // client sent it under the wrong name. + const bundle_json = + \\{"ops":[{"tool":"codedb_outline","arguments":{"file_path":"src/main.zig"}}]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + // The error itself must still appear (legitimate — path is missing). + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'path' argument") != null); + // And the bundle must surface what the op actually contained, naming the + // bad key so the caller can self-diagnose. + try testing.expect(std.mem.indexOf(u8, out.items, "received keys") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "file_path") != null); +} + + +test "issue-423: bundle emits 'received keys' exactly once per failing op" { + // Regression: handler (handleSearch etc) appends the diagnostic, AND the + // bundle dispatch loop also appends it — caller saw the line twice in a + // row. Must appear exactly once per failing op. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const bundle_json = + \\{"ops":[{"tool":"codedb_search","arguments":{}}]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + var count: usize = 0; + var idx: usize = 0; + while (std.mem.indexOfPos(u8, out.items, idx, "received keys:")) |pos| { + count += 1; + idx = pos + 1; + } + try testing.expectEqual(@as(usize, 1), count); +} + + +test "issue-367: openDataLog truncates orphan bytes from prior session" { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + var dir_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp_dir.dir.realPathFile(io, ".", &dir_buf); + const dir_path = dir_buf[0..dir_path_len]; + + const log_path = try std.fmt.allocPrint(testing.allocator, "{s}/data.log", .{dir_path}); + defer testing.allocator.free(log_path); + + const orphan = "ORPHAN_SECRET_TOKEN_FROM_PRIOR_SESSION"; + { + const f = try std.Io.Dir.cwd().createFile(io, log_path, .{ .truncate = true }); + defer f.close(io); + try f.writePositionalAll(io, orphan, 0); + } + + var store = Store.init(testing.allocator); + defer store.deinit(); + try store.openDataLog(io, log_path); + + const f = try std.Io.Dir.cwd().openFile(io, log_path, .{}); + defer f.close(io); + const len = try f.length(io); + try testing.expectEqual(@as(u64, 0), len); + try testing.expectEqual(@as(u64, 0), store.data_log_pos); + + const diff = "fresh diff"; + _ = try store.recordEdit("foo.zig", 1, .replace, 0xABCD, diff.len, diff); + + var buf: [128]u8 = undefined; + const f2 = try std.Io.Dir.cwd().openFile(io, log_path, .{}); + defer f2.close(io); + const new_len = try f2.length(io); + try testing.expectEqual(@as(u64, diff.len), new_len); + const read_len = try f2.readPositionalAll(io, buf[0..diff.len], 0); + try testing.expectEqual(diff.len, read_len); + try testing.expectEqualStrings(diff, buf[0..diff.len]); +} + + +test "issue-367-dx: tty summary surfaces received keys on missing-arg error" { + const args_json = + \\{"file_path":"src/main.zig","weird_key":"x"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + const raw_output = "error: missing 'path' argument\nreceived keys: [file_path, weird_key]"; + + var summary: std.ArrayList(u8) = .empty; + defer summary.deinit(testing.allocator); + + mcp_mod.mcpGenerateSummary( + testing.allocator, + "codedb_outline", + &parsed.value.object, + raw_output, + true, + &summary, + ); + + try testing.expect(std.mem.indexOf(u8, summary.items, "received") != null); + try testing.expect(std.mem.indexOf(u8, summary.items, "file_path") != null); +} + + +test "issue-bug2: tool calls during scan-in-progress hint at scan state" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const prev_state = mcp_mod.getScanState(); + defer mcp_mod.setScanState(prev_state); + mcp_mod.setScanState(.walking); + + const args_json = + \\{"query":"some_unknown_symbol_that_will_not_match"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_search, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "0 results") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "scan still in progress") != null); +} + + +test "issue-378: search waits briefly for scan to reach ready instead of returning empty" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const prev_state = mcp_mod.getScanState(); + defer mcp_mod.setScanState(prev_state); + mcp_mod.setScanState(.walking); + + const Flipper = struct { + fn run(exp: *Explorer) void { + cio.sleepMs(100); + exp.indexFile("src/late.zig", "fn waitsForScanMarker() void {}\n") catch return; + mcp_mod.setScanState(.ready); + } + }; + const t = try std.Thread.spawn(.{}, Flipper.run, .{&explorer}); + defer t.join(); + + const args_json = + \\{"query":"waitsForScanMarker"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_search, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "src/late.zig") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "scan still in progress") == null); +} + + +test "issue-bug5: codedb_read returns binary stub instead of dumping bytes" { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + var dir_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp_dir.dir.realPathFile(io, ".", &dir_buf); + const dir_path = dir_buf[0..dir_path_len]; + + const bin_rel = "blob.bin"; + const bin_full = try std.fmt.allocPrint(testing.allocator, "{s}/{s}", .{ dir_path, bin_rel }); + defer testing.allocator.free(bin_full); + { + const f = try std.Io.Dir.cwd().createFile(io, bin_full, .{ .truncate = true }); + defer f.close(io); + const payload = [_]u8{ 'a', 'b', 0, 'c', 'd', 0, 'e' }; + try f.writePositionalAll(io, &payload, 0); + } + + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + explorer.setRoot(io, dir_path); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, dir_path, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = try std.fmt.allocPrint(testing.allocator, + "{{\"path\":\"{s}\"}}", .{bin_rel}); + defer testing.allocator.free(args_json); + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_read, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "binary file") != null); + try testing.expect(std.mem.indexOf(u8, out.items, &[_]u8{0}) == null); +} + + +test "issue-bug6: codedb_read errors when line_start > line_end" { + var tmp_dir = testing.tmpDir(.{}); + defer tmp_dir.cleanup(); + + var dir_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp_dir.dir.realPathFile(io, ".", &dir_buf); + const dir_path = dir_buf[0..dir_path_len]; + + const rel = "small.txt"; + const full = try std.fmt.allocPrint(testing.allocator, "{s}/{s}", .{ dir_path, rel }); + defer testing.allocator.free(full); + { + const f = try std.Io.Dir.cwd().createFile(io, full, .{ .truncate = true }); + defer f.close(io); + try f.writePositionalAll(io, "alpha\nbeta\ngamma\n", 0); + } + + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + explorer.setRoot(io, dir_path); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, dir_path, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = try std.fmt.allocPrint(testing.allocator, + "{{\"path\":\"{s}\",\"line_start\":100,\"line_end\":10}}", .{rel}); + defer testing.allocator.free(args_json); + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_read, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.startsWith(u8, out.items, "error:")); + try testing.expect(std.mem.indexOf(u8, out.items, "line_start") != null); +} + + +test "issue-bug7: codedb_search rejects empty query" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"query":""} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_search, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.startsWith(u8, out.items, "error:")); + try testing.expect(std.mem.indexOf(u8, out.items, "empty") != null); +} + + +test "issue-bug7: codedb_search rejects negative max_results" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"query":"foo","max_results":-3} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_search, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.startsWith(u8, out.items, "error:")); + try testing.expect(std.mem.indexOf(u8, out.items, "max_results") != null); +} + + +test "issue-bug11: codedb_bundle marks isError when all ops fail" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"ops":[{"tool":"codedb_outline"}]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.startsWith(u8, out.items, "error:")); +} + + +test "issue-386: telemetry recordToolCall preserves UTF-8 codepoint boundaries" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + var telem = telemetry_mod.Telemetry.init(io, dir_path, testing.allocator, false); + defer telem.deinit(); + + // 30 ASCII bytes + a 3-byte UTF-8 codepoint (✓ = 0xE2 0x9C 0x93) lands the + // codepoint boundary at byte 33. The 32-byte cap currently truncates inside + // the codepoint, leaving 0xE2 0x9C as the trailing bytes — invalid UTF-8. + const tool_name = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\xe2\x9c\x93_tail"; + telem.recordToolCall(tool_name, 1234, false, 56); + telem.flush(); + + const ndjson_path = try std.fmt.allocPrint(testing.allocator, "{s}/telemetry.ndjson", .{dir_path}); + defer testing.allocator.free(ndjson_path); + + const contents = try std.Io.Dir.cwd().readFileAlloc(io, ndjson_path, testing.allocator, .limited(64 * 1024)); + defer testing.allocator.free(contents); + + const tool_field = "\"tool\":\""; + const idx = std.mem.indexOf(u8, contents, tool_field) orelse return error.ToolFieldMissing; + const after = contents[idx + tool_field.len ..]; + const end = std.mem.indexOfScalar(u8, after, '"') orelse return error.ToolFieldUnterminated; + const recorded = after[0..end]; + + // The recorded tool slice must be valid UTF-8. A mid-codepoint truncation + // produces invalid bytes — std.unicode.utf8ValidateSlice rejects them. + try testing.expect(std.unicode.utf8ValidateSlice(recorded)); +} + + +test "issue-387: appendId preserves JSON-RPC numeric and number_string ids" { + // JSON-RPC ids are typed as String|Number|Null. The MCP server must echo + // the id verbatim so the client can correlate the reply with its request. + // appendId currently only handles .integer and .string — .float and + // .number_string fall through to "null", breaking correlation for any + // client that uses a fractional id (some test runners) or that the JSON + // parser materializes as number_string. + + // Float id round-trips: parsing "3.5" yields .float, which must serialize + // back to "3.5" (or any representation a JSON parser accepts as the same + // number) — NOT "null". + { + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, "3.5", .{}); + defer parsed.deinit(); + var buf: std.ArrayList(u8) = .empty; + defer buf.deinit(testing.allocator); + mcp_mod.appendId(testing.allocator, &buf, parsed.value); + try testing.expect(!std.mem.eql(u8, buf.items, "null")); + } + + // number_string round-trips: a request with `"id": 12345678901234567890` + // (>i64) is parsed as .number_string. The reply must echo the digits, not + // the literal "null". + { + const v = std.json.Value{ .number_string = "12345678901234567890" }; + var buf: std.ArrayList(u8) = .empty; + defer buf.deinit(testing.allocator); + mcp_mod.appendId(testing.allocator, &buf, v); + try testing.expectEqualStrings("12345678901234567890", buf.items); + } +} + + +test "issue-406: root_policy blocks /private/etc (macOS realpath of /etc)" { + // /etc is in the system_prefixes deny list, but on macOS /etc is a symlink + // to /private/etc. Callers feed isIndexableRoot a path resolved by + // realPathFile (see handleIndex in src/mcp.zig), which turns "/etc" into + // "/private/etc" — and then this textual prefix check accepts it. The + // canonical form must be blocked too, otherwise the deny list is bypassed + // by the very normalization step the callers depend on. + try testing.expect(!root_policy.isIndexableRoot("/private/etc")); + try testing.expect(!root_policy.isIndexableRoot("/private/etc/ssh")); +} + + +test "issue-407: root_policy blocks /var and its non-folders subtree" { + // The system_prefixes list explicitly blocks /var/folders and /var/tmp, + // but not /var itself or /var/log, /var/lib, /var/db, /var/spool, etc. + // On Linux those hold logs, mail, and package state; on macOS realPathFile + // turns /var into /private/var (also unblocked). Accidentally pointing + // the indexer at /var/log on a server pulls in GBs of secrets and is + // never a valid "project root". + try testing.expect(!root_policy.isIndexableRoot("/var")); + try testing.expect(!root_policy.isIndexableRoot("/var/log")); + try testing.expect(!root_policy.isIndexableRoot("/var/lib")); + try testing.expect(!root_policy.isIndexableRoot("/private/var")); + try testing.expect(!root_policy.isIndexableRoot("/private/var/log")); +} + + +test "issue-412: bundle reports 'missing tool' for tool field of wrong type" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const bundle_json = + \\{"ops":[{"tool":123,"arguments":{"path":"x.zig"}}]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'tool' field") == null); +} + + +test "issue-413: bundle truncation drops subsequent ops without telling the caller" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + // Index a single large file (~120KB) so two reads exceed the 200KB + // bundle cap. Bundle truncates and breaks out of the loop after op[1], + // emitting a TRUNCATED note — but op[2] is silently dropped. + var big: std.ArrayList(u8) = .empty; + defer big.deinit(testing.allocator); + while (big.items.len < 120 * 1024) { + try big.appendSlice(testing.allocator, "pub fn placeholder() void { _ = 0; }\n"); + } + try explorer.indexFile("big.zig", big.items); + try explorer.indexFile("small.zig", "pub fn small() void {}\n"); + + // Three reads: first two exceed 200KB → truncate. op[2] is small.zig + // and should still surface — at minimum, the bundle output must + // mention it (e.g. as another truncated entry) so the caller knows + // their request had three ops, not one. + const bundle_json = + \\{"ops":[ + \\ {"tool":"codedb_read","arguments":{"path":"big.zig"}}, + \\ {"tool":"codedb_read","arguments":{"path":"big.zig"}}, + \\ {"tool":"codedb_outline","arguments":{"path":"small.zig"}} + \\]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + // op[2] (index 2) was sent — caller deserves to see something for it. + // Either its result, or an explicit "[2]" entry noting it was dropped. + try testing.expect(std.mem.indexOf(u8, out.items, "[2]") != null); +} + + +test "issue-424-B: bundle falls through to inline args when arguments is empty object" { + // Forge-style buggy clients sometimes send `arguments: {}` AND put the + // real args inline at the op level. The dispatcher currently sees the + // empty `arguments` and stops looking — resulting in a misleading + // "missing 'path'" with `received keys: []` even though `path` is + // sitting right there in the op. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const bundle_json = + \\{"ops":[{"tool":"codedb_outline","arguments":{},"path":"src/main.zig"}]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + // Should succeed: path was discoverable inline even though `arguments` was empty. + try testing.expect(std.mem.indexOf(u8, out.items, "src/main.zig") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'path'") == null); + try testing.expect(std.mem.indexOf(u8, out.items, "received keys: []") == null); +} + + +test "issue-424-D: received-keys diagnostic hints at inline-args workaround when empty" { + // When a sub-op fails with truly-empty args, the diagnostic should + // point users at the inline-args fallback so a broken client wrapper + // can be routed around without a server change. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const bundle_json = + \\{"ops":[{"tool":"codedb_outline","arguments":{}}]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + // Original error stays. + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'path'") != null); + // The diagnostic should fire (received-keys line present) and surface + // the inline-shape hint, since no real sub-op args were observed. + try testing.expect(std.mem.indexOf(u8, out.items, "received keys:") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "inline shape") != null); +} + + +test "issue-424-A: bundle envelope errors carry the 'error:' prefix consistently" { + // Pre-fix the bundle dispatcher emits 'op must be an object' and + // 'missing 'tool' field' WITHOUT the 'error:' prefix that per-tool + // handlers and TTY-summary parsing both expect. Normalize. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + // Op is a string, not an object. + const bad_shape = + \\{"ops":["not-an-object"]} + ; + const parsed1 = try std.json.parseFromSlice(std.json.Value, testing.allocator, bad_shape, .{}); + defer parsed1.deinit(); + var out1: std.ArrayList(u8) = .empty; + defer out1.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed1.value.object, &out1, &store, &explorer, &agents); + try testing.expect(std.mem.indexOf(u8, out1.items, "error: op must be an object") != null); + + // Op missing 'tool' field. + const no_tool = + \\{"ops":[{"arguments":{}}]} + ; + const parsed2 = try std.json.parseFromSlice(std.json.Value, testing.allocator, no_tool, .{}); + defer parsed2.deinit(); + var out2: std.ArrayList(u8) = .empty; + defer out2.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed2.value.object, &out2, &store, &explorer, &agents); + try testing.expect(std.mem.indexOf(u8, out2.items, "error: missing 'tool'") != null); +} + + +test "issue-441: bundle rejects codedb_projects sub-op" { + // codedb_projects lists every indexed project on the machine, which is a + // global directory enumeration unrelated to whatever repo the agent is + // working on. When a planner sees a previous bundle that called + // codedb_projects, it tends to replay the same shape — re-emitting 5x + // codedb_projects ops as if that were the canonical "what do I do here" + // call. Block it at the dispatcher, mirroring the existing rejections of + // codedb_bundle (recursive) and codedb_edit (write op). + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const bundle_json = + \\{"ops":[{"tool":"codedb_projects","arguments":{}}]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + // The op must be rejected with an explicit error, not silently dispatched. + try testing.expect(std.mem.indexOf(u8, out.items, "error: codedb_projects not allowed in bundle") != null); +} + + +test "issue-441: codedb_projects branch is excluded from augmented oneOf" { + // Mirror of the dispatcher rejection at the schema level — when the + // discriminated oneOf is opted into via CODEDB_DISCRIMINATED_SCHEMA=1, + // there must not be a oneOf branch advertising codedb_projects as a + // valid sub-tool, since the bundle dispatcher rejects it at runtime. + const augmented = try mcp_mod.buildAugmentedToolsList(testing.allocator); + defer testing.allocator.free(augmented); + + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, augmented, .{}); + defer parsed.deinit(); + + const tools = parsed.value.object.get("tools").?.array; + var bundle_items: ?std.json.Value = null; + for (tools.items) |t| { + if (std.mem.eql(u8, t.object.get("name").?.string, "codedb_bundle")) { + bundle_items = t.object.get("inputSchema").?.object.get("properties").?.object.get("ops").?.object.get("items").?; + break; + } + } + const one_of = bundle_items.?.object.get("oneOf").?.array; + + for (one_of.items) |branch| { + const props = branch.object.get("properties").?.object; + const tool_v = props.get("tool").?; + const tool_const = tool_v.object.get("const") orelse continue; + try testing.expect(!std.mem.eql(u8, tool_const.string, "codedb_projects")); + } +} + + +test "issue-443: codedb_bundle is omitted from default tools/list response" { + // The codedb_bundle tool has been a footgun across multiple stages: + // #434 — schema permitted empty arguments (Stage 1 fix: required arguments) + // #437 — Stage 2 oneOf augmentation broke OpenAI strict-mode (#440 hotfix) + // #441 — codedb_projects sub-op replay loop in planners + // Even with all of the above, OpenAI clients still emit + // {"tool":"codedb_*","arguments":{}} because the default schema's + // arguments field is a bare {type:"object"} with no inner shape, and + // the discriminated oneOf is opt-in only. + // + // Disable codedb_bundle entirely until the schema can be reworked to + // bind sub-tool arguments inline (no `arguments` wrapper), removing + // the empty-args footgun structurally. The dispatcher-side handler + // stays so clients with cached schemas don't crash, but the runtime + // tools/list response no longer advertises it. CODEDB_BUNDLE_ENABLED=1 + // re-enables advertisement for callers that want to re-engage it. + const response = try mcp_mod.buildToolsListResponse(testing.allocator, .{ + .bundle_enabled = false, + .discriminated_opt_in = false, + }); + defer testing.allocator.free(response); + + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, response, .{}); + defer parsed.deinit(); + + const tools = parsed.value.object.get("tools").?.array; + for (tools.items) |t| { + const name = t.object.get("name").?.string; + try testing.expect(!std.mem.eql(u8, name, "codedb_bundle")); + } + + // Sanity: legitimate tools still advertised. + var saw_search = false; + var saw_outline = false; + for (tools.items) |t| { + const name = t.object.get("name").?.string; + if (std.mem.eql(u8, name, "codedb_search")) saw_search = true; + if (std.mem.eql(u8, name, "codedb_outline")) saw_outline = true; + } + try testing.expect(saw_search); + try testing.expect(saw_outline); +} + + +test "issue-443: codedb_bundle is advertised when CODEDB_BUNDLE_ENABLED=1" { + // Re-enable path. When bundle_enabled is true the runtime response + // includes codedb_bundle, exactly as it did before this gate. + const response = try mcp_mod.buildToolsListResponse(testing.allocator, .{ + .bundle_enabled = true, + .discriminated_opt_in = false, + }); + defer testing.allocator.free(response); + + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, response, .{}); + defer parsed.deinit(); + + const tools = parsed.value.object.get("tools").?.array; + var saw_bundle = false; + for (tools.items) |t| { + if (std.mem.eql(u8, t.object.get("name").?.string, "codedb_bundle")) saw_bundle = true; + } + try testing.expect(saw_bundle); +} + + +test "issue-434: codedb_bundle ops items schema requires arguments field" { + // The codedb_bundle inputSchema in tools_list advertises ops items as + // {required: ["tool"]} with arguments as a bare {type: "object"} that + // permits {}. Function-calling LLMs read the schema as authoritative and + // emit the minimum-valid payload — {tool: "...", arguments: {}} — which + // misroutes through the inline-args fallback and surfaces as + // "received keys: [tool, arguments]" from each sub-tool. Stage 1 fix: + // add "arguments" to the items.required array so models are forced to + // populate it. (Stage 2 — discriminated oneOf over tool — is a follow-up.) + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, mcp_mod.tools_list, .{}); + defer parsed.deinit(); + + const tools = parsed.value.object.get("tools").?.array; + var bundle_schema: ?std.json.Value = null; + for (tools.items) |t| { + const name = t.object.get("name").?.string; + if (std.mem.eql(u8, name, "codedb_bundle")) { + bundle_schema = t.object.get("inputSchema").?; + break; + } + } + try testing.expect(bundle_schema != null); + + const ops = bundle_schema.?.object.get("properties").?.object.get("ops").?; + const items = ops.object.get("items").?; + const required = items.object.get("required").?.array; + + var has_tool = false; + var has_arguments = false; + for (required.items) |r| { + if (std.mem.eql(u8, r.string, "tool")) has_tool = true; + if (std.mem.eql(u8, r.string, "arguments")) has_arguments = true; + } + try testing.expect(has_tool); + try testing.expect(has_arguments); +} + + +test "issue-437: codedb_bundle ops items schema has discriminated oneOf per sub-tool" { + // Stage 2 of the bundle-schema fix. Stage 1 (#434) made `arguments` + // required but left it as a bare {type: "object"} — so a schema-greedy + // model can still emit `arguments: {}` to satisfy the required check + // without populating real keys. Stage 2 binds the *contents* of + // arguments to each sub-tool's actual inputSchema via a discriminated + // oneOf on `tool` (const) → `arguments` (sub-tool inputSchema). + // + // The augmented schema is built at runtime from the per-sub-tool + // schemas already advertised in tools_list, so there is no + // hand-maintained duplication. + const augmented = try mcp_mod.buildAugmentedToolsList(testing.allocator); + defer testing.allocator.free(augmented); + + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, augmented, .{}); + defer parsed.deinit(); + + const tools = parsed.value.object.get("tools").?.array; + var bundle_items: ?std.json.Value = null; + for (tools.items) |t| { + const name = t.object.get("name").?.string; + if (std.mem.eql(u8, name, "codedb_bundle")) { + bundle_items = t.object.get("inputSchema").?.object.get("properties").?.object.get("ops").?.object.get("items").?; + break; + } + } + try testing.expect(bundle_items != null); + + // `oneOf` array must exist on items. + const one_of_val = bundle_items.?.object.get("oneOf"); + try testing.expect(one_of_val != null); + const one_of = one_of_val.?.array; + + // Must have at least one branch per dispatchable codedb_* sub-tool. + // codedb_bundle (recursive) and codedb_edit (write op) are explicitly + // rejected by handleBundle, so they are excluded. + try testing.expect(one_of.items.len >= 10); + + // Find the codedb_outline branch and verify it pins tool to a const + // and binds arguments to a populated schema (with `path` property). + var found_outline = false; + for (one_of.items) |branch| { + const props = branch.object.get("properties").?.object; + const tool_v = props.get("tool").?; + const tool_const = tool_v.object.get("const"); + if (tool_const == null) continue; + if (!std.mem.eql(u8, tool_const.?.string, "codedb_outline")) continue; + found_outline = true; + + const args_schema = props.get("arguments").?; + const args_props = args_schema.object.get("properties").?.object; + try testing.expect(args_props.get("path") != null); + // codedb_outline requires `path` — preserved by the augmentation. + const args_required = args_schema.object.get("required").?.array; + var path_required = false; + for (args_required.items) |r| { + if (std.mem.eql(u8, r.string, "path")) path_required = true; + } + try testing.expect(path_required); + break; + } + try testing.expect(found_outline); + + // No branch should be for the recursive codedb_bundle or the write-op codedb_edit. + for (one_of.items) |branch| { + const props = branch.object.get("properties").?.object; + const tool_v = props.get("tool").?; + const tool_const = tool_v.object.get("const") orelse continue; + try testing.expect(!std.mem.eql(u8, tool_const.string, "codedb_bundle")); + try testing.expect(!std.mem.eql(u8, tool_const.string, "codedb_edit")); + } +} + diff --git a/src/test_parser.zig b/src/test_parser.zig new file mode 100644 index 0000000..4a0ffde --- /dev/null +++ b/src/test_parser.zig @@ -0,0 +1,1654 @@ +const std = @import("std"); +const cio = @import("cio.zig"); +const testing = std.testing; +const io = std.testing.io; +const explore = @import("explore.zig"); +const Explorer = explore.Explorer; +const Language = explore.Language; +const SymbolKind = explore.SymbolKind; +const DependencyGraph = explore.DependencyGraph; +const Store = @import("store.zig").Store; + + +fn expectOutlineSymbol(outline: *const explore.FileOutline, name: []const u8, kind: SymbolKind) !void { + for (outline.symbols.items) |sym| { + if (std.mem.eql(u8, sym.name, name) and sym.kind == kind) return; + } + return error.TestUnexpectedResult; +} + + +fn expectOutlineImport(outline: *const explore.FileOutline, import_path: []const u8) !void { + for (outline.imports.items) |imp| { + if (std.mem.eql(u8, imp, import_path)) return; + } + return error.TestUnexpectedResult; +} + + +test "issue-301: Dart / Flutter parser" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("lib/home_screen.dart", + \\import 'package:flutter/material.dart'; + \\export 'src/helpers.dart'; + \\part 'home_screen.g.dart'; + \\ + \\typedef ItemBuilder = Widget Function(BuildContext context); + \\ + \\abstract class HomeScreen extends StatelessWidget { + \\ @override + \\ Widget build(BuildContext context) { + \\ return const Placeholder(); + \\ } + \\} + \\ + \\mixin Loader on State { + \\ Future loadData() async {} + \\} + \\ + \\extension ContextX on BuildContext { + \\ ThemeData get theme => Theme.of(this); + \\} + \\ + \\enum LoadState { idle, loading } + \\ + \\const String appTitle = 'codedb'; + ); + + var outline = (try explorer.getOutline("lib/home_screen.dart", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + + try testing.expectEqual(Language.dart, outline.language); + try testing.expectEqual(@as(usize, 3), outline.imports.items.len); + + var found_typedef = false; + var found_class = false; + var found_mixin = false; + var found_extension = false; + var found_enum = false; + var found_build = false; + var found_load = false; + var found_const = false; + for (outline.symbols.items) |sym| { + if (sym.kind == .type_alias and std.mem.eql(u8, sym.name, "ItemBuilder")) found_typedef = true; + if (sym.kind == .class_def and std.mem.eql(u8, sym.name, "HomeScreen")) found_class = true; + if (sym.kind == .trait_def and std.mem.eql(u8, sym.name, "Loader")) found_mixin = true; + if (sym.kind == .impl_block and std.mem.eql(u8, sym.name, "ContextX")) found_extension = true; + if (sym.kind == .enum_def and std.mem.eql(u8, sym.name, "LoadState")) found_enum = true; + if (sym.kind == .function and std.mem.eql(u8, sym.name, "build")) found_build = true; + if (sym.kind == .function and std.mem.eql(u8, sym.name, "loadData")) found_load = true; + if (sym.kind == .constant and std.mem.eql(u8, sym.name, "appTitle")) found_const = true; + } + try testing.expect(found_typedef); + try testing.expect(found_class); + try testing.expect(found_mixin); + try testing.expect(found_extension); + try testing.expect(found_enum); + try testing.expect(found_build); + try testing.expect(found_load); + try testing.expect(found_const); + + const tree = try explorer.getTree(testing.allocator, false); + defer testing.allocator.free(tree); + try testing.expect(std.mem.indexOf(u8, tree, "home_screen.dart dart") != null); +} + + +test "issue-php-1: PHP class definition herkend" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("app/Models/Candidate.php", + \\ 0 + \\} + ); + + var outline = (try explorer.getOutline("main.go", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + var func_count: usize = 0; + var struct_count: usize = 0; + for (outline.symbols.items) |sym| { + if (sym.kind == .function) func_count += 1; + if (sym.kind == .struct_def) struct_count += 1; + } + try testing.expect(func_count == 2); // main + Validate + try testing.expect(struct_count == 2); // Config + Handler + try testing.expect(outline.imports.items.len == 1); // "fmt" +} + + +test "issue-151: Ruby class, module, and def" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("app.rb", + \\require "json" + \\require_relative "./helpers" + \\ + \\module Authentication + \\ class User + \\ def initialize(name) + \\ @name = name + \\ end + \\ + \\ def greet + \\ puts "hello" + \\ end + \\ end + \\end + ); + + var outline = (try explorer.getOutline("app.rb", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + var func_count: usize = 0; + var struct_count: usize = 0; + for (outline.symbols.items) |sym| { + if (sym.kind == .function) func_count += 1; + if (sym.kind == .struct_def) struct_count += 1; + } + try testing.expect(func_count == 2); // initialize + greet + try testing.expect(struct_count == 2); // Authentication + User + try testing.expect(outline.imports.items.len == 2); // json + ./helpers +} + + +test "issue-151: Ruby =begin/=end comments skipped" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("commented.rb", + \\def real_method + \\ true + \\end + \\=begin + \\def fake_method + \\ false + \\end + \\=end + ); + + var outline = (try explorer.getOutline("commented.rb", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + var func_count: usize = 0; + for (outline.symbols.items) |sym| { + if (sym.kind == .function) func_count += 1; + } + try testing.expect(func_count == 1); // only real_method +} + + +test "issue-151: Go block comments skipped" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("commented.go", + \\package main + \\ + \\func realFunc() {} + \\/* + \\func fakeFunc() {} + \\*/ + ); + + var outline = (try explorer.getOutline("commented.go", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + var func_count: usize = 0; + for (outline.symbols.items) |sym| { + if (sym.kind == .function) func_count += 1; + } + try testing.expect(func_count == 1); // only realFunc +} + + +test "issue-301: Dart block comments skipped" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("commented.dart", + \\class RealWidget {} + \\/* + \\class FakeWidget {} + \\void fakeHelper() {} + \\*/ + ); + + var outline = (try explorer.getOutline("commented.dart", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + + var class_count: usize = 0; + var func_count: usize = 0; + for (outline.symbols.items) |sym| { + if (sym.kind == .class_def) class_count += 1; + if (sym.kind == .function) func_count += 1; + } + try testing.expectEqual(@as(usize, 1), class_count); + try testing.expectEqual(@as(usize, 0), func_count); +} + + +test "issue-179: block comment does not produce phantom symbols" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("test.zig", "/* commented out\npub fn fake_func() void {}\n*/\npub fn real_func() void {}\n"); + + const outline = (try explorer.getOutline("test.zig", testing.allocator)).?; + defer { + var o = outline; + o.deinit(); + } + var found_real = false; + var found_fake = false; + for (outline.symbols.items) |sym| { + if (std.mem.indexOf(u8, sym.name, "real_func") != null) found_real = true; + if (std.mem.indexOf(u8, sym.name, "fake_func") != null) found_fake = true; + } + try testing.expect(found_real); + try testing.expect(!found_fake); +} + + +test "issue-179: code after single-line /* */ comment is parsed" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("test.zig", "/* skip this */ pub fn visible() void {}\n"); + + const outline = (try explorer.getOutline("test.zig", testing.allocator)).?; + defer { + var o = outline; + o.deinit(); + } + var found = false; + for (outline.symbols.items) |sym| { + if (std.mem.indexOf(u8, sym.name, "visible") != null) found = true; + } + try testing.expect(found); +} + + +test "issue-179: Python docstring with text does not leak symbols" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("test.py", "def real():\n \"\"\"This is a docstring.\n def fake():\n pass\n \"\"\"\n pass\n"); + + const outline = (try explorer.getOutline("test.py", testing.allocator)).?; + defer { + var o = outline; + o.deinit(); + } + var found_real = false; + var found_fake = false; + for (outline.symbols.items) |sym| { + if (std.mem.indexOf(u8, sym.name, "real") != null) found_real = true; + if (std.mem.indexOf(u8, sym.name, "fake") != null) found_fake = true; + } + try testing.expect(found_real); + try testing.expect(!found_fake); +} + + +test "issue-108: HCL resource block parsed" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("main.tf", + \\resource "aws_instance" "web" { + \\ ami = "abc-123" + \\} + ); + const results = try explorer.findAllSymbols("web", alloc); + defer alloc.free(results); + try testing.expect(results.len == 1); + try testing.expectEqual(SymbolKind.struct_def, results[0].symbol.kind); +} + + +test "issue-108: HCL variable and output parsed" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("vars.tf", + \\variable "region" { + \\ default = "us-east-1" + \\} + \\output "ip" { + \\ value = aws_instance.web.public_ip + \\} + ); + const vars = try explorer.findAllSymbols("region", alloc); + defer alloc.free(vars); + try testing.expect(vars.len == 1); + try testing.expectEqual(SymbolKind.variable, vars[0].symbol.kind); + const outs = try explorer.findAllSymbols("ip", alloc); + defer alloc.free(outs); + try testing.expect(outs.len == 1); + try testing.expectEqual(SymbolKind.constant, outs[0].symbol.kind); +} + + +test "issue-108: HCL module and provider parsed" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("main.tf", + \\provider "aws" { + \\ region = "us-east-1" + \\} + \\module "vpc" { + \\ source = "./modules/vpc" + \\} + ); + const providers = try explorer.findAllSymbols("aws", alloc); + defer alloc.free(providers); + try testing.expect(providers.len == 1); + const mods = try explorer.findAllSymbols("vpc", alloc); + defer alloc.free(mods); + try testing.expect(mods.len == 1); +} + + +test "issue-108: HCL comment lines skipped" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("main.tf", + \\# This is a comment + \\// Another comment + \\variable "name" {} + ); + const results = try explorer.findAllSymbols("name", alloc); + defer alloc.free(results); + try testing.expect(results.len == 1); +} + + +test "issue-215: R function assignment parsed" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("analysis.R", + \\greet <- function(name) { + \\ paste("Hello", name) + \\} + ); + const results = try explorer.findAllSymbols("greet", alloc); + defer alloc.free(results); + try testing.expect(results.len == 1); + try testing.expectEqual(SymbolKind.function, results[0].symbol.kind); +} + + +test "issue-215: R library import parsed" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("script.r", + \\library(dplyr) + \\require(ggplot2) + ); + const outline = try explorer.getOutline("script.r", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(@as(usize, 2), outline.imports.items.len); +} + + +test "issue-215: R setClass parsed" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("classes.R", + \\setClass("Person") + \\setRefClass("Animal") + ); + const p = try explorer.findAllSymbols("Person", alloc); + defer alloc.free(p); + try testing.expect(p.len == 1); + try testing.expectEqual(SymbolKind.class_def, p[0].symbol.kind); + const a2 = try explorer.findAllSymbols("Animal", alloc); + defer alloc.free(a2); + try testing.expect(a2.len == 1); +} + + +test "issue-319: C parser extracts includes macros types and functions" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("src/core.c", + \\#include + \\#include "local.h" + \\#define MAX_SIZE 64 + \\#define SQUARE(x) ((x) * (x)) + \\struct Worker { + \\ int id; + \\}; + \\enum Mode { + \\ MODE_A, + \\}; + \\union Value { + \\ int i; + \\}; + \\typedef unsigned long size_alias_t; + \\static inline const char *worker_name(const struct Worker *worker) { + \\ return "worker"; + \\} + \\void *alloc_item(size_t size) + \\{ + \\ return malloc(size); + \\} + ); + + const outline = try explorer.getOutline("src/core.c", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.c, outline.language); + try testing.expectEqual(@as(usize, 2), outline.imports.items.len); + try testing.expectEqualStrings("stdio.h", outline.imports.items[0]); + try testing.expectEqualStrings("local.h", outline.imports.items[1]); + + const max_size = try explorer.findAllSymbols("MAX_SIZE", alloc); + defer alloc.free(max_size); + try testing.expectEqual(@as(usize, 1), max_size.len); + try testing.expectEqual(SymbolKind.macro_def, max_size[0].symbol.kind); + + const square = try explorer.findAllSymbols("SQUARE", alloc); + defer alloc.free(square); + try testing.expectEqual(@as(usize, 1), square.len); + try testing.expectEqual(SymbolKind.macro_def, square[0].symbol.kind); + + const worker = try explorer.findAllSymbols("Worker", alloc); + defer alloc.free(worker); + try testing.expectEqual(@as(usize, 1), worker.len); + try testing.expectEqual(SymbolKind.struct_def, worker[0].symbol.kind); + + const mode = try explorer.findAllSymbols("Mode", alloc); + defer alloc.free(mode); + try testing.expectEqual(@as(usize, 1), mode.len); + try testing.expectEqual(SymbolKind.enum_def, mode[0].symbol.kind); + + const value = try explorer.findAllSymbols("Value", alloc); + defer alloc.free(value); + try testing.expectEqual(@as(usize, 1), value.len); + try testing.expectEqual(SymbolKind.union_def, value[0].symbol.kind); + + const alias = try explorer.findAllSymbols("size_alias_t", alloc); + defer alloc.free(alias); + try testing.expectEqual(@as(usize, 1), alias.len); + try testing.expectEqual(SymbolKind.type_alias, alias[0].symbol.kind); + + const worker_name = try explorer.findAllSymbols("worker_name", alloc); + defer alloc.free(worker_name); + try testing.expectEqual(@as(usize, 1), worker_name.len); + try testing.expectEqual(SymbolKind.function, worker_name[0].symbol.kind); + + const alloc_item = try explorer.findAllSymbols("alloc_item", alloc); + defer alloc.free(alloc_item); + try testing.expectEqual(@as(usize, 1), alloc_item.len); + try testing.expectEqual(SymbolKind.function, alloc_item[0].symbol.kind); +} + + +test "issue-319: C parser avoids comments strings prototypes and macro calls" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("src/noise.c", + \\// int fake_comment(void) { + \\/* int fake_block(void) { */ + \\const char *s = "int fake_string(void) {"; + \\typedef int (*handler_fn)(int); + \\int prototype_only(void); + \\EXPORT_SYMBOL(real_function); + \\if (real_function()) { + \\} + \\int real_function(void) { + \\ return 1; + \\} + ); + + const real = try explorer.findAllSymbols("real_function", alloc); + defer alloc.free(real); + try testing.expectEqual(@as(usize, 1), real.len); + try testing.expectEqual(SymbolKind.function, real[0].symbol.kind); + + const fake_comment = try explorer.findAllSymbols("fake_comment", alloc); + defer alloc.free(fake_comment); + try testing.expectEqual(@as(usize, 0), fake_comment.len); + + const fake_block = try explorer.findAllSymbols("fake_block", alloc); + defer alloc.free(fake_block); + try testing.expectEqual(@as(usize, 0), fake_block.len); + + const fake_string = try explorer.findAllSymbols("fake_string", alloc); + defer alloc.free(fake_string); + try testing.expectEqual(@as(usize, 0), fake_string.len); + + const prototype = try explorer.findAllSymbols("prototype_only", alloc); + defer alloc.free(prototype); + try testing.expectEqual(@as(usize, 0), prototype.len); + + const handler = try explorer.findAllSymbols("handler_fn", alloc); + defer alloc.free(handler); + try testing.expectEqual(@as(usize, 0), handler.len); +} + + +test "issue-321: common detected extensions produce outlines" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("src/math.cc", + \\#include + \\class Calculator { + \\public: + \\ int add(int a, int b) { + \\ return a + b; + \\ } + \\}; + \\int free_add(int a, int b) { + \\ return a + b; + \\} + ); + try explorer.indexFile("src/Bridge.mm", + \\#import "Bridge.h" + \\@interface BrowserController + \\- (void)loadPage:(NSString *)url; + \\@end + \\@implementation BrowserController + \\- (void)loadPage:(NSString *)url { } + \\@end + \\class BrowserBridge { + \\}; + \\int bridge_main(void) { + \\ return 0; + \\} + ); + try explorer.indexFile("src/App.java", + \\package demo; + \\import java.util.List; + \\public class Worker { + \\ public void run() {} + \\} + \\interface RunnableThing {} + \\enum Mode { A } + \\record Pair(int left, int right) {} + ); + try explorer.indexFile("src/App.kt", + \\package demo + \\import kotlinx.coroutines.runBlocking + \\data class User(val name: String) + \\interface Repo + \\enum class KotlinMode { A } + \\fun loadUser(): User = User("a") + \\val answer = 42 + ); + try explorer.indexFile("src/Widget.svelte", + \\ + \\.card { color: red; } + ); + try explorer.indexFile("src/View.vue", + \\ + ); + try explorer.indexFile("src/Page.astro", + \\--- + \\import Layout from '../layouts/Layout.astro'; + \\const title = 'Home'; + \\--- + ); + try explorer.indexFile("scripts/build.sh", + \\source ./env.sh + \\function build_app() { + \\} + \\deploy_app() { + \\} + \\BUILD_MODE=release + ); + try explorer.indexFile("styles/app.css", + \\:root { + \\ --brand: red; + \\} + \\.button { + \\ color: var(--brand); + \\} + \\@keyframes fade {} + ); + try explorer.indexFile("styles/app.scss", + \\$gap: 8px; + \\@mixin center {} + \\.panel {} + ); + try explorer.indexFile("db/schema.sql", + \\CREATE TABLE users (id integer); + \\CREATE OR REPLACE FUNCTION do_thing() RETURNS void AS $$ SELECT 1; $$ LANGUAGE sql; + \\CREATE INDEX idx_users_id ON users(id); + ); + try explorer.indexFile("api/service.proto", + \\syntax = "proto3"; + \\import "google/protobuf/timestamp.proto"; + \\message User {} + \\enum Status { STATUS_OK = 0; } + \\service UserService { + \\ rpc GetUser (User) returns (User); + \\} + ); + try explorer.indexFile("math/solver.f90", + \\module solver + \\use mathlib + \\type :: Particle + \\end type + \\subroutine step() + \\end subroutine + \\function energy() + \\end function + ); + try explorer.indexFile("ir/module.ll", + \\%Pair = type { i32, i32 } + \\@global_value = global i32 0 + \\define i32 @main() { + \\ ret i32 0 + \\} + ); + try explorer.indexFile("ir/dialect.mlir", + \\module @kernel_mod { + \\ func.func @kernel() { + \\ return + \\ } + \\} + ); + try explorer.indexFile("llvm/records.td", + \\include "Base.td" + \\class Register; + \\multiclass Pat; + \\def R0 : Register<"r0">; + \\defm ADD : Pat<"add">; + \\let Namespace = "Toy"; + ); + + const cc_outline = try explorer.getOutline("src/math.cc", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.cpp, cc_outline.language); + try expectOutlineImport(&cc_outline, "vector"); + try expectOutlineSymbol(&cc_outline, "Calculator", .class_def); + try expectOutlineSymbol(&cc_outline, "add", .function); + try expectOutlineSymbol(&cc_outline, "free_add", .function); + + const mm_outline = try explorer.getOutline("src/Bridge.mm", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.cpp, mm_outline.language); + try expectOutlineImport(&mm_outline, "Bridge.h"); + try expectOutlineSymbol(&mm_outline, "BrowserController", .class_def); + try expectOutlineSymbol(&mm_outline, "loadPage", .method); + try expectOutlineSymbol(&mm_outline, "BrowserBridge", .class_def); + try expectOutlineSymbol(&mm_outline, "bridge_main", .function); + + const java_outline = try explorer.getOutline("src/App.java", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.java, java_outline.language); + try expectOutlineImport(&java_outline, "java.util.List"); + try expectOutlineSymbol(&java_outline, "Worker", .class_def); + try expectOutlineSymbol(&java_outline, "run", .method); + try expectOutlineSymbol(&java_outline, "RunnableThing", .interface_def); + try expectOutlineSymbol(&java_outline, "Mode", .enum_def); + try expectOutlineSymbol(&java_outline, "Pair", .class_def); + + const kt_outline = try explorer.getOutline("src/App.kt", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.kotlin, kt_outline.language); + try expectOutlineImport(&kt_outline, "kotlinx.coroutines.runBlocking"); + try expectOutlineSymbol(&kt_outline, "User", .class_def); + try expectOutlineSymbol(&kt_outline, "Repo", .interface_def); + try expectOutlineSymbol(&kt_outline, "KotlinMode", .enum_def); + try expectOutlineSymbol(&kt_outline, "loadUser", .function); + try expectOutlineSymbol(&kt_outline, "answer", .constant); + + const svelte_outline = try explorer.getOutline("src/Widget.svelte", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.svelte, svelte_outline.language); + try expectOutlineImport(&svelte_outline, "./Thing.svelte"); + try expectOutlineSymbol(&svelte_outline, "title", .constant); + try expectOutlineSymbol(&svelte_outline, "renderTitle", .function); + try expectOutlineSymbol(&svelte_outline, ".card", .class_def); + + const vue_outline = try explorer.getOutline("src/View.vue", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.vue, vue_outline.language); + try expectOutlineImport(&vue_outline, "./Child.vue"); + try expectOutlineSymbol(&vue_outline, "count", .constant); + try expectOutlineSymbol(&vue_outline, "inc", .function); + + const astro_outline = try explorer.getOutline("src/Page.astro", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.astro, astro_outline.language); + try expectOutlineImport(&astro_outline, "../layouts/Layout.astro"); + try expectOutlineSymbol(&astro_outline, "title", .constant); + + const shell_outline = try explorer.getOutline("scripts/build.sh", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.shell, shell_outline.language); + try expectOutlineImport(&shell_outline, "./env.sh"); + try expectOutlineSymbol(&shell_outline, "build_app", .function); + try expectOutlineSymbol(&shell_outline, "deploy_app", .function); + try expectOutlineSymbol(&shell_outline, "BUILD_MODE", .variable); + + const css_outline = try explorer.getOutline("styles/app.css", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.css, css_outline.language); + try expectOutlineSymbol(&css_outline, "--brand", .constant); + try expectOutlineSymbol(&css_outline, ".button", .class_def); + try expectOutlineSymbol(&css_outline, "fade", .function); + + const scss_outline = try explorer.getOutline("styles/app.scss", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.scss, scss_outline.language); + try expectOutlineSymbol(&scss_outline, "$gap", .constant); + try expectOutlineSymbol(&scss_outline, "center", .function); + try expectOutlineSymbol(&scss_outline, ".panel", .class_def); + + const sql_outline = try explorer.getOutline("db/schema.sql", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.sql, sql_outline.language); + try expectOutlineSymbol(&sql_outline, "users", .struct_def); + try expectOutlineSymbol(&sql_outline, "do_thing", .function); + try expectOutlineSymbol(&sql_outline, "idx_users_id", .constant); + + const proto_outline = try explorer.getOutline("api/service.proto", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.protobuf, proto_outline.language); + try expectOutlineImport(&proto_outline, "google/protobuf/timestamp.proto"); + try expectOutlineSymbol(&proto_outline, "User", .struct_def); + try expectOutlineSymbol(&proto_outline, "Status", .enum_def); + try expectOutlineSymbol(&proto_outline, "UserService", .interface_def); + try expectOutlineSymbol(&proto_outline, "GetUser", .method); + + const fortran_outline = try explorer.getOutline("math/solver.f90", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.fortran, fortran_outline.language); + try expectOutlineImport(&fortran_outline, "mathlib"); + try expectOutlineSymbol(&fortran_outline, "solver", .class_def); + try expectOutlineSymbol(&fortran_outline, "Particle", .struct_def); + try expectOutlineSymbol(&fortran_outline, "step", .function); + try expectOutlineSymbol(&fortran_outline, "energy", .function); + + const llvm_outline = try explorer.getOutline("ir/module.ll", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.llvm_ir, llvm_outline.language); + try expectOutlineSymbol(&llvm_outline, "Pair", .type_alias); + try expectOutlineSymbol(&llvm_outline, "global_value", .variable); + try expectOutlineSymbol(&llvm_outline, "main", .function); + + const mlir_outline = try explorer.getOutline("ir/dialect.mlir", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.mlir, mlir_outline.language); + try expectOutlineSymbol(&mlir_outline, "kernel_mod", .class_def); + try expectOutlineSymbol(&mlir_outline, "kernel", .function); + + const td_outline = try explorer.getOutline("llvm/records.td", alloc) orelse return error.TestUnexpectedResult; + try testing.expectEqual(Language.tablegen, td_outline.language); + try expectOutlineImport(&td_outline, "Base.td"); + try expectOutlineSymbol(&td_outline, "Register", .class_def); + try expectOutlineSymbol(&td_outline, "Pat", .class_def); + try expectOutlineSymbol(&td_outline, "R0", .constant); + try expectOutlineSymbol(&td_outline, "ADD", .constant); + try expectOutlineSymbol(&td_outline, "Namespace", .variable); + + const worker = try explorer.findAllSymbols("Worker", alloc); + defer alloc.free(worker); + try testing.expectEqual(@as(usize, 1), worker.len); + try testing.expectEqual(SymbolKind.class_def, worker[0].symbol.kind); + + const run = try explorer.findAllSymbols("run", alloc); + defer alloc.free(run); + try testing.expectEqual(@as(usize, 1), run.len); + try testing.expectEqual(SymbolKind.method, run[0].symbol.kind); + + const user = try explorer.findAllSymbols("User", alloc); + defer alloc.free(user); + try testing.expect(user.len >= 2); + + const load_user = try explorer.findAllSymbols("loadUser", alloc); + defer alloc.free(load_user); + try testing.expectEqual(@as(usize, 1), load_user.len); + try testing.expectEqual(SymbolKind.function, load_user[0].symbol.kind); + + const title = try explorer.findAllSymbols("title", alloc); + defer alloc.free(title); + try testing.expect(title.len >= 2); + + const build_app = try explorer.findAllSymbols("build_app", alloc); + defer alloc.free(build_app); + try testing.expectEqual(@as(usize, 1), build_app.len); + try testing.expectEqual(SymbolKind.function, build_app[0].symbol.kind); + + const button = try explorer.findAllSymbols(".button", alloc); + defer alloc.free(button); + try testing.expectEqual(@as(usize, 1), button.len); + + const users = try explorer.findAllSymbols("users", alloc); + defer alloc.free(users); + try testing.expectEqual(@as(usize, 1), users.len); + try testing.expectEqual(SymbolKind.struct_def, users[0].symbol.kind); + + const user_service = try explorer.findAllSymbols("UserService", alloc); + defer alloc.free(user_service); + try testing.expectEqual(@as(usize, 1), user_service.len); + try testing.expectEqual(SymbolKind.interface_def, user_service[0].symbol.kind); + + const particle = try explorer.findAllSymbols("Particle", alloc); + defer alloc.free(particle); + try testing.expectEqual(@as(usize, 1), particle.len); + try testing.expectEqual(SymbolKind.struct_def, particle[0].symbol.kind); + + const main_sym = try explorer.findAllSymbols("main", alloc); + defer alloc.free(main_sym); + try testing.expectEqual(@as(usize, 1), main_sym.len); + try testing.expectEqual(SymbolKind.function, main_sym[0].symbol.kind); + + const kernel = try explorer.findAllSymbols("kernel", alloc); + defer alloc.free(kernel); + try testing.expectEqual(@as(usize, 1), kernel.len); + try testing.expectEqual(SymbolKind.function, kernel[0].symbol.kind); + + const r0 = try explorer.findAllSymbols("R0", alloc); + defer alloc.free(r0); + try testing.expectEqual(@as(usize, 1), r0.len); +} + + +test "issue-179: Python inline docstring does not leak symbols" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("mod.py", + \\def real_func(): + \\ """This docstring contains def fake(): pass""" + \\ return 1 + ); + + const real = try explorer.findAllSymbols("real_func", alloc); + defer alloc.free(real); + try testing.expect(real.len == 1); + + const fake = try explorer.findAllSymbols("fake", alloc); + defer alloc.free(fake); + try testing.expectEqual(@as(usize, 0), fake.len); +} + + +test "issue-179: Python multi-line docstring with def inside" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("doc.py", + \\def outer(): + \\ """ + \\ Example: + \\ def inner_example(): + \\ pass + \\ """ + \\ return True + ); + + const outer = try explorer.findAllSymbols("outer", alloc); + defer alloc.free(outer); + try testing.expect(outer.len == 1); + + const inner = try explorer.findAllSymbols("inner_example", alloc); + defer alloc.free(inner); + try testing.expectEqual(@as(usize, 0), inner.len); +} + + +test "issue-331: C parser does not index indented call sites as functions" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const a = arena.allocator(); + var explorer = Explorer.init(a, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("test.c", + \\void real_func(int x) { + \\ fprintf(stderr, "curl_easy_perform() failed: %s\n", + \\ curl_easy_strerror(res)); + \\ curl_easy_perform(curl); + \\ if (SSL_get_options(ctx)) + \\ return; + \\} + ); + + const syms = explorer.outlines.get("test.c").?.symbols.items; + var found_false = false; + for (syms) |sym| { + if (sym.kind == .function) { + if (std.mem.eql(u8, sym.name, "fprintf") or + std.mem.eql(u8, sym.name, "curl_easy_perform") or + std.mem.eql(u8, sym.name, "curl_easy_strerror") or + std.mem.eql(u8, sym.name, "SSL_get_options")) + { + found_false = true; + } + } + } + try testing.expect(!found_false); + var found_real = false; + for (syms) |sym| { + if (sym.kind == .function and std.mem.eql(u8, sym.name, "real_func")) + found_real = true; + } + try testing.expect(found_real); +} + + +test "issue-331: C parser finds nginx-style split-line definitions" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const a = arena.allocator(); + var explorer = Explorer.init(a, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("ngx_http_request.c", + \\ngx_int_t + \\ngx_http_init_connection(ngx_connection_t *c) + \\{ + \\ ngx_http_connection_t *hc; + \\} + \\ + \\static ngx_int_t + \\ngx_http_create_request(ngx_http_request_t *r) + \\{ + \\ return NGX_OK; + \\} + ); + + const syms = explorer.outlines.get("ngx_http_request.c").?.symbols.items; + var found_init = false; + var found_create = false; + for (syms) |sym| { + if (sym.kind == .function) { + if (std.mem.eql(u8, sym.name, "ngx_http_init_connection")) found_init = true; + if (std.mem.eql(u8, sym.name, "ngx_http_create_request")) found_create = true; + } + } + try testing.expect(found_init); + try testing.expect(found_create); +} + + +test "issue-392: Swift parser" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("Sources/App/Greeter.swift", + \\import Foundation + \\import UIKit + \\ + \\public struct Greeter { + \\ let name: String + \\ + \\ public func greet() -> String { + \\ return "Hello, \(name)" + \\ } + \\} + \\ + \\public class HomeViewController: UIViewController { + \\ public override func viewDidLoad() { + \\ super.viewDidLoad() + \\ } + \\} + \\ + \\public protocol Reloadable { + \\ func reload() + \\} + \\ + \\public enum LoadState { + \\ case idle + \\ case loading + \\} + \\ + \\public func topLevel() -> Int { return 42 } + ); + + var outline = (try explorer.getOutline("Sources/App/Greeter.swift", testing.allocator)) orelse return error.TestUnexpectedResult; + defer outline.deinit(); + + // Detected language must surface as "swift" — main has no Language.swift, + // so the file falls into .unknown and no parser runs. + try testing.expectEqualStrings("swift", @tagName(outline.language)); + + var found_struct = false; + var found_class = false; + var found_protocol = false; + var found_enum = false; + var found_top_fn = false; + var found_method = false; + for (outline.symbols.items) |sym| { + if (std.mem.eql(u8, sym.name, "Greeter")) found_struct = true; + if (std.mem.eql(u8, sym.name, "HomeViewController")) found_class = true; + if (std.mem.eql(u8, sym.name, "Reloadable")) found_protocol = true; + if (std.mem.eql(u8, sym.name, "LoadState")) found_enum = true; + if (std.mem.eql(u8, sym.name, "topLevel")) found_top_fn = true; + if (std.mem.eql(u8, sym.name, "greet")) found_method = true; + } + try testing.expect(found_struct); + try testing.expect(found_class); + try testing.expect(found_protocol); + try testing.expect(found_enum); + try testing.expect(found_top_fn); + try testing.expect(found_method); +} + diff --git a/src/test_query.zig b/src/test_query.zig new file mode 100644 index 0000000..a784c73 --- /dev/null +++ b/src/test_query.zig @@ -0,0 +1,1232 @@ +const std = @import("std"); +const cio = @import("cio.zig"); +const testing = std.testing; +const io = std.testing.io; +const Store = @import("store.zig").Store; +const Explorer = @import("explore.zig").Explorer; +const SearchResult = @import("explore.zig").SearchResult; +const WordIndex = @import("index.zig").WordIndex; +const TrigramIndex = @import("index.zig").TrigramIndex; +const SparseNgramIndex = @import("index.zig").SparseNgramIndex; +const explore = @import("explore.zig"); +const Language = explore.Language; +const SymbolKind = explore.SymbolKind; +const mcp_mod = @import("mcp.zig"); + + +const fuzzyScore = @import("explore.zig").fuzzyScore; +const AgentRegistry = @import("agent.zig").AgentRegistry; +const edit_mod = @import("edit.zig"); + + +test "issue-360: edit rejects mismatched if_hash and leaves file untouched" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/edit-if-hash.txt", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + const original = "line 1\nline 2\nline 3\n"; + var file = try tmp.dir.createFile(io, "edit-if-hash.txt", .{}); + defer file.close(io); + try file.writeStreamingAll(io, original); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + const agent_id = try agents.register("issue-360-agent"); + + // A hash value that cannot match any real file content (caller saw a stale read) + try testing.expectError(error.HashMismatch, edit_mod.applyEdit(io, testing.allocator, &store, &agents, null, .{ + .path = rel_path, + .agent_id = agent_id, + .op = .replace, + .range = .{ 1, 1 }, + .content = "stale-line edit", + .if_hash = "deadbeef", + })); + + // File on disk must be unchanged after the rejected edit + const after_bytes = try std.Io.Dir.cwd().readFileAlloc(io, rel_path, testing.allocator, .limited(10 * 1024)); + defer testing.allocator.free(after_bytes); + try testing.expectEqualStrings(original, after_bytes); +} + + +test "issue-360: edit response reports hex hash matching codedb_read" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/edit-hex.txt", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + const original = "alpha\nbeta\ngamma\n"; + var file = try tmp.dir.createFile(io, "edit-hex.txt", .{}); + defer file.close(io); + try file.writeStreamingAll(io, original); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + const agent_id = try agents.register("issue-360-hex-agent"); + + const result = try edit_mod.applyEdit(io, testing.allocator, &store, &agents, null, .{ + .path = rel_path, + .agent_id = agent_id, + .op = .replace, + .range = .{ 2, 2 }, + .content = "BETA", + }); + + // Hash returned matches Wyhash of the new content, hex-formatted same as codedb_read + const new_bytes = try std.Io.Dir.cwd().readFileAlloc(io, rel_path, testing.allocator, .limited(10 * 1024)); + defer testing.allocator.free(new_bytes); + const expected_hash = std.hash.Wyhash.hash(0, new_bytes); + try testing.expectEqual(expected_hash, result.new_hash); +} + + +test "issue-360: edit dry_run returns diff preview and leaves file untouched" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/edit-dry.txt", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + const original = "alpha\nbeta\ngamma\n"; + var file = try tmp.dir.createFile(io, "edit-dry.txt", .{}); + defer file.close(io); + try file.writeStreamingAll(io, original); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + const agent_id = try agents.register("issue-360-dry-agent"); + + const result = try edit_mod.applyEdit(io, testing.allocator, &store, &agents, null, .{ + .path = rel_path, + .agent_id = agent_id, + .op = .replace, + .range = .{ 2, 2 }, + .content = "BETA", + .dry_run = true, + }); + defer if (result.preview) |p| testing.allocator.free(p); + + // File on disk is untouched. + const after_bytes = try std.Io.Dir.cwd().readFileAlloc(io, rel_path, testing.allocator, .limited(10 * 1024)); + defer testing.allocator.free(after_bytes); + try testing.expectEqualStrings(original, after_bytes); + + // Store unchanged. + try testing.expectEqual(@as(u64, 0), store.currentSeq()); + + // seq=0 indicates not committed; new_hash is the would-be hash. + try testing.expectEqual(@as(u64, 0), result.seq); + + // Preview shows both the removed and the added line. + try testing.expect(result.preview != null); + const preview = result.preview.?; + try testing.expect(std.mem.indexOf(u8, preview, "-beta") != null); + try testing.expect(std.mem.indexOf(u8, preview, "+BETA") != null); +} + + +test "issue-163: fuzzy exact match scores highest" { + const exact = fuzzyScore("main.zig", "src/main.zig"); + const partial = fuzzyScore("main.zig", "src/main_helper.zig"); + try testing.expect(exact != null); + try testing.expect(partial != null); + try testing.expect(exact.? > partial.?); +} + + +test "issue-163: fuzzy subsequence match works" { + const score = fuzzyScore("authmid", "src/auth_middleware.py"); + try testing.expect(score != null); + try testing.expect(score.? > 0); +} + + +test "issue-163: fuzzy typo-tolerant (missing char)" { + // "auth_midlware" missing the 'd' in middleware — should still match via subsequence + const score = fuzzyScore("auth_midlware", "src/auth_middleware.py"); + try testing.expect(score != null); +} + + +test "issue-163: fuzzy word boundary bonus" { + // "auth" at word boundary should score higher than "auth" buried in a word + const boundary = fuzzyScore("auth", "src/auth_handler.py"); + const buried = fuzzyScore("auth", "src/xauthyhandle.py"); + try testing.expect(boundary != null); + try testing.expect(buried != null); + try testing.expect(boundary.? > buried.?); +} + + +test "issue-163: fuzzy filename ranks above directory" { + // "test" in filename portion should score higher than "test" only in directory + const in_name = fuzzyScore("test", "src/test_auth.py"); + const in_dir = fuzzyScore("test", "testdir/deep/nested/xyzfile.py"); + try testing.expect(in_name != null); + try testing.expect(in_dir != null); + try testing.expect(in_name.? > in_dir.?); +} + + +test "issue-163: fuzzy no match returns null" { + const score = fuzzyScore("zzzzxyz", "src/main.zig"); + try testing.expect(score == null); +} + + +test "issue-163: fuzzyFindFiles via Explorer" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth_middleware.py", "def check_auth(): pass"); + try explorer.indexFile("src/middleware/auth.py", "class Auth: pass"); + try explorer.indexFile("tests/test_auth.py", "def test_auth(): pass"); + try explorer.indexFile("src/utils.py", "def format_str(): pass"); + + const results = try explorer.fuzzyFindFiles("authmid", testing.allocator, 10); + defer testing.allocator.free(results); + + try testing.expect(results.len >= 1); + // auth_middleware.py should be top result + try testing.expect(std.mem.indexOf(u8, results[0].path, "auth_middleware") != null); +} + + +test "issue-163: multi-part query matches both parts" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth_middleware.py", "def check(): pass"); + try explorer.indexFile("src/auth_handler.py", "def handle(): pass"); + try explorer.indexFile("src/utils.py", "def util(): pass"); + + // "auth middle" should match auth_middleware but not utils + const results = try explorer.fuzzyFindFiles("auth middle", testing.allocator, 10); + defer testing.allocator.free(results); + + try testing.expect(results.len >= 1); + try testing.expect(std.mem.indexOf(u8, results[0].path, "middleware") != null); +} + + +test "issue-163: extension constraint filters results" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth.py", "def check(): pass"); + try explorer.indexFile("src/auth.ts", "function check() {}"); + try explorer.indexFile("src/auth.zig", "fn check() void {}"); + + // "auth *.py" should only return the .py file + const results = try explorer.fuzzyFindFiles("auth *.py", testing.allocator, 10); + defer testing.allocator.free(results); + + try testing.expect(results.len >= 1); + for (results) |r| { + try testing.expect(std.mem.endsWith(u8, r.path, ".py")); + } +} + + +test "issue-163: special entry point files get bonus" { + const score_main = fuzzyScore("main", "src/main.zig"); + const score_regular = fuzzyScore("main", "src/maintain.zig"); + try testing.expect(score_main != null); + try testing.expect(score_regular != null); + // main.zig is a special entry point — should score higher than maintain.zig + try testing.expect(score_main.? > score_regular.?); +} + + +test "issue-163: transpositions handled by Smith-Waterman" { + // These all failed with the old subsequence matcher + try testing.expect(fuzzyScore("mpc", "src/mcp.zig") != null); + try testing.expect(fuzzyScore("mian", "src/main.zig") != null); + try testing.expect(fuzzyScore("agnet", "src/agent.zig") != null); + try testing.expect(fuzzyScore("indxe", "src/index.zig") != null); +} + + +test "issue-168: query pipeline find → limit produces file set" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth.py", "def check_auth(): pass"); + try explorer.indexFile("src/auth_handler.py", "def handle(): pass"); + try explorer.indexFile("src/utils.py", "def util(): pass"); + try explorer.indexFile("src/config.py", "DEBUG = True"); + + // Pipeline: find "auth" → should return auth files + const results = try explorer.fuzzyFindFiles("auth", testing.allocator, 10); + defer testing.allocator.free(results); + + try testing.expect(results.len >= 2); + // Both auth files should be in results + var found_auth = false; + var found_handler = false; + for (results) |r| { + if (std.mem.indexOf(u8, r.path, "auth.py") != null) found_auth = true; + if (std.mem.indexOf(u8, r.path, "auth_handler") != null) found_handler = true; + } + try testing.expect(found_auth); + try testing.expect(found_handler); +} + + +test "issue-168: query pipeline search returns matching lines" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/main.zig", "pub fn main() void {\n const x = 42;\n}\n"); + try explorer.indexFile("src/lib.zig", "pub fn init() void {}\n"); + + const results = try explorer.searchContent("main", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + try testing.expect(results.len >= 1); + try testing.expect(std.mem.indexOf(u8, results[0].path, "main.zig") != null); +} + + +test "issue-168: query pipeline filter by extension" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth.py", "def check(): pass"); + try explorer.indexFile("src/auth.ts", "function check() {}"); + try explorer.indexFile("src/auth.zig", "fn check() void {}"); + + // fuzzyFindFiles with extension constraint + const results = try explorer.fuzzyFindFiles("auth *.py", testing.allocator, 10); + defer testing.allocator.free(results); + + try testing.expect(results.len >= 1); + for (results) |r| { + try testing.expect(std.mem.endsWith(u8, r.path, ".py")); + } +} + + +test "issue-168: query pipeline outline returns symbols" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/main.zig", "pub fn main() void {}\npub fn helper() void {}\n"); + + var outline = (try explorer.getOutline("src/main.zig", testing.allocator)).?; + defer outline.deinit(); + try testing.expect(outline.symbols.items.len >= 2); +} + + +test "issue-168: query pipeline chained find → filter narrows results" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth.py", "def check(): pass"); + try explorer.indexFile("src/auth.ts", "function check() {}"); + try explorer.indexFile("src/utils.py", "def util(): pass"); + try explorer.indexFile("docs/auth.md", "# Auth docs"); + + // find "auth" returns all auth files, then *.py filter narrows to python + const all = try explorer.fuzzyFindFiles("auth", testing.allocator, 10); + defer testing.allocator.free(all); + try testing.expect(all.len >= 3); // auth.py, auth.ts, auth.md + + const py_only = try explorer.fuzzyFindFiles("auth *.py", testing.allocator, 10); + defer testing.allocator.free(py_only); + try testing.expect(py_only.len >= 1); + try testing.expect(py_only.len < all.len); // filtered set is smaller +} + + +test "issue-168: query pipeline handles empty results gracefully" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/main.zig", "pub fn main() void {}"); + + // Search for something that doesn't exist + const results = try explorer.fuzzyFindFiles("zzzznonexistent", testing.allocator, 10); + defer testing.allocator.free(results); + try testing.expectEqual(@as(usize, 0), results.len); +} + + +test "issue-168: recall — find + filter preserves only matching extension" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth.py", "def check(): pass"); + try explorer.indexFile("src/auth.ts", "function check() {}"); + try explorer.indexFile("src/auth.zig", "fn check() void {}"); + try explorer.indexFile("src/auth.rs", "fn check() {}"); + try explorer.indexFile("src/auth_test.py", "def test_check(): pass"); + + // find "auth" should get all 5, then *.py should narrow to exactly 2 + const all = try explorer.fuzzyFindFiles("auth", testing.allocator, 20); + defer testing.allocator.free(all); + try testing.expect(all.len == 5); + + const py = try explorer.fuzzyFindFiles("auth *.py", testing.allocator, 20); + defer testing.allocator.free(py); + try testing.expect(py.len == 2); + for (py) |r| try testing.expect(std.mem.endsWith(u8, r.path, ".py")); +} + + +test "issue-168: recall — search finds content across multiple files" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/a.zig", "pub fn handleRequest() void {}"); + try explorer.indexFile("src/b.zig", "pub fn handleResponse() void {}"); + try explorer.indexFile("src/c.zig", "pub fn processData() void {}"); + + const results = try explorer.searchContent("handle", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + // Should find "handle" in a.zig and b.zig but not c.zig + try testing.expect(results.len >= 2); + var found_a = false; + var found_b = false; + var found_c = false; + for (results) |r| { + if (std.mem.indexOf(u8, r.path, "a.zig") != null) found_a = true; + if (std.mem.indexOf(u8, r.path, "b.zig") != null) found_b = true; + if (std.mem.indexOf(u8, r.path, "c.zig") != null) found_c = true; + } + try testing.expect(found_a); + try testing.expect(found_b); + try testing.expect(!found_c); +} + + +test "issue-168: recall — fuzzy find ranks exact matches highest" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth.zig", "fn auth() void {}"); + try explorer.indexFile("src/authorization.zig", "fn authorize() void {}"); + try explorer.indexFile("src/authenticate.zig", "fn authenticate() void {}"); + + const results = try explorer.fuzzyFindFiles("auth.zig", testing.allocator, 10); + defer testing.allocator.free(results); + + try testing.expect(results.len >= 1); + // Exact match "auth.zig" should be ranked first + try testing.expect(std.mem.eql(u8, results[0].path, "src/auth.zig")); + // Score should decrease for less exact matches + if (results.len >= 2) { + try testing.expect(results[0].score > results[1].score); + } +} + + +test "issue-168: recall — multi-part query intersection" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth_controller.py", "class AuthController: pass"); + try explorer.indexFile("src/auth_model.py", "class AuthModel: pass"); + try explorer.indexFile("src/user_controller.py", "class UserController: pass"); + try explorer.indexFile("src/user_model.py", "class UserModel: pass"); + + // "auth controller" should match auth_controller but not user_controller or auth_model + const results = try explorer.fuzzyFindFiles("auth controller", testing.allocator, 10); + defer testing.allocator.free(results); + + try testing.expect(results.len >= 1); + try testing.expect(std.mem.indexOf(u8, results[0].path, "auth_controller") != null); +} + + +test "issue-168: recall — transposition tolerance in pipeline" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/middleware.zig", "fn process() void {}"); + try explorer.indexFile("src/controller.zig", "fn handle() void {}"); + try explorer.indexFile("src/service.zig", "fn serve() void {}"); + + // "midleware" (missing 'd') should still find middleware via Smith-Waterman + const results = try explorer.fuzzyFindFiles("midleware", testing.allocator, 5); + defer testing.allocator.free(results); + + try testing.expect(results.len >= 1); + try testing.expect(std.mem.indexOf(u8, results[0].path, "middleware") != null); +} + + +test "auto-retry: delimiter stripping finds results" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/auth_middleware.py", "def check(): pass"); + + // "authmiddleware" without delimiters should still find auth_middleware + const results = try explorer.fuzzyFindFiles("authmiddleware", testing.allocator, 10); + defer testing.allocator.free(results); + try testing.expect(results.len >= 1); + try testing.expect(std.mem.indexOf(u8, results[0].path, "auth_middleware") != null); +} + + +test "per-file truncation: max 5 matches per file in output" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // Create a file with 10 lines all matching "const" + var content: [500]u8 = undefined; + var pos: usize = 0; + for (0..10) |i| { + const line = std.fmt.bufPrint(content[pos..], "const val{d} = {d};\n", .{ i, i }) catch break; + pos += line.len; + } + try explorer.indexFile("src/many_consts.zig", content[0..pos]); + + // Search — explorer returns all 10, but MCP handler would truncate to 5 + const results = try explorer.searchContent("const", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + // At the explorer level all 10 should be found + try testing.expect(results.len >= 10); +} + + +test "issue-359: globPaths matches files by glob pattern" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/mcp.zig", "pub fn a() void {}"); + try explorer.indexFile("src/explore.zig", "pub fn b() void {}"); + try explorer.indexFile("src/sub/inner.zig", "pub fn c() void {}"); + try explorer.indexFile("tests/test_main.py", "def t(): pass"); + try explorer.indexFile("README.md", "# readme"); + + // ** matches across path separators + const zigs = try explorer.globPaths(testing.allocator, "src/**/*.zig", 100); + defer testing.allocator.free(zigs); + try testing.expectEqual(@as(usize, 3), zigs.len); + + // single * does not cross path separators + const top_zigs = try explorer.globPaths(testing.allocator, "src/*.zig", 100); + defer testing.allocator.free(top_zigs); + try testing.expectEqual(@as(usize, 2), top_zigs.len); + + // top-level extension match + const md = try explorer.globPaths(testing.allocator, "*.md", 100); + defer testing.allocator.free(md); + try testing.expectEqual(@as(usize, 1), md.len); + try testing.expectEqualStrings("README.md", md[0]); + + // results are sorted + const all_zigs = try explorer.globPaths(testing.allocator, "**/*.zig", 100); + defer testing.allocator.free(all_zigs); + try testing.expect(all_zigs.len >= 2); + var i: usize = 1; + while (i < all_zigs.len) : (i += 1) { + try testing.expect(std.mem.order(u8, all_zigs[i - 1], all_zigs[i]) == .lt); + } +} + + +test "issue-359: lsDir returns immediate children with file metadata" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("src/mcp.zig", "pub fn a() void {}"); + try explorer.indexFile("src/explore.zig", "pub fn b() void {}"); + try explorer.indexFile("src/sub/inner.zig", "pub fn c() void {}"); + try explorer.indexFile("tests/test_main.py", "def t(): pass"); + try explorer.indexFile("README.md", "# readme"); + + // Top-level: 1 file (README.md) + 2 dirs (src/, tests/) + const top = try explorer.lsDir(testing.allocator, ""); + defer testing.allocator.free(top); + try testing.expectEqual(@as(usize, 3), top.len); + + var saw_readme = false; + var saw_src_dir = false; + var saw_tests_dir = false; + for (top) |e| { + if (std.mem.eql(u8, e.name, "README.md")) { + try testing.expect(!e.is_dir); + saw_readme = true; + } + if (std.mem.eql(u8, e.name, "src")) { + try testing.expect(e.is_dir); + saw_src_dir = true; + } + if (std.mem.eql(u8, e.name, "tests")) { + try testing.expect(e.is_dir); + saw_tests_dir = true; + } + } + try testing.expect(saw_readme and saw_src_dir and saw_tests_dir); + + // Inside src/: 2 files (mcp.zig, explore.zig) + 1 dir (sub/) + const src_children = try explorer.lsDir(testing.allocator, "src"); + defer testing.allocator.free(src_children); + try testing.expectEqual(@as(usize, 3), src_children.len); + + var saw_sub_dir = false; + var file_count: usize = 0; + for (src_children) |e| { + if (e.is_dir) { + if (std.mem.eql(u8, e.name, "sub")) saw_sub_dir = true; + } else { + file_count += 1; + try testing.expect(e.line_count >= 1); + } + } + try testing.expect(saw_sub_dir); + try testing.expectEqual(@as(usize, 2), file_count); +} + + +test "issue-359: mcp.globMatch backtracks across **/* boundary" { + // Pipeline filter (codedb_query) calls mcp.globMatch on each path. The + // iterative version forgot the outer ** position when it entered the + // inner *.zig star, so paths like src/sub/inner.zig were rejected by + // src/**/*.zig even though they should match. + try testing.expect(mcp_mod.globMatch("src/**/*.zig", "src/sub/inner.zig")); + try testing.expect(mcp_mod.globMatch("src/**/*.zig", "src/a/b/c.zig")); + + // Single * still must not cross /. + try testing.expect(!mcp_mod.globMatch("src/*.zig", "src/sub/inner.zig")); + + // Plain prefix matches still work. + try testing.expect(mcp_mod.globMatch("src/*.zig", "src/mcp.zig")); + try testing.expect(!mcp_mod.globMatch("docs/*.md", "src/mcp.zig")); +} + + +test "issue-359: globPaths recall — every matching path survives at every depth" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // Plant files at varying depths under src/, plus a few outside it. + const planted = [_][]const u8{ + "src/a.zig", + "src/b.zig", + "src/sub/c.zig", + "src/sub/d.zig", + "src/sub/deep/e.zig", + "src/sub/deep/f.zig", + "src/sub/deep/deeper/g.zig", + "tests/h.zig", + "src/notes.md", + "src/sub/notes.md", + }; + for (planted) |p| try explorer.indexFile(p, "pub fn x() void {}"); + + // src/**/*.zig must reach every depth — this is the case the old + // iterative matcher silently dropped (single star slot lost the + // outer ** position when the inner *.zig star ran). + const all_src_zigs = try explorer.globPaths(testing.allocator, "src/**/*.zig", 100); + defer testing.allocator.free(all_src_zigs); + try testing.expectEqual(@as(usize, 7), all_src_zigs.len); + + // Single * does not cross /: only the two top-level src zigs. + const top = try explorer.globPaths(testing.allocator, "src/*.zig", 100); + defer testing.allocator.free(top); + try testing.expectEqual(@as(usize, 2), top.len); + + // **/*.md should find both markdown files no matter their depth. + const md = try explorer.globPaths(testing.allocator, "**/*.md", 100); + defer testing.allocator.free(md); + try testing.expectEqual(@as(usize, 2), md.len); + + // Anchored deep match: src/**/g.zig must find the deepest one only. + const g = try explorer.globPaths(testing.allocator, "src/**/g.zig", 100); + defer testing.allocator.free(g); + try testing.expectEqual(@as(usize, 1), g.len); + try testing.expectEqualStrings("src/sub/deep/deeper/g.zig", g[0]); + + // Pipeline filter must agree path-for-path with globPaths, since it + // now routes through the same matcher. Spot-check a few. + try testing.expect(mcp_mod.globMatch("src/**/*.zig", "src/sub/deep/deeper/g.zig")); + try testing.expect(mcp_mod.globMatch("**/*.md", "src/sub/notes.md")); + try testing.expect(!mcp_mod.globMatch("src/**/*.zig", "tests/h.zig")); +} + + +test "issue-359/360: retrieval recall — search/word/symbol/fuzzy/glob/deps all return ground truth" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // Flat paths so dep_graph keys (raw import strings) line up with file paths. + try explorer.indexFile( + "auth.zig", + \\const std = @import("std"); + \\ + \\pub fn authenticate(token: []const u8) bool { + \\ _ = token; + \\ return true; + \\} + \\pub fn validateToken(token: []const u8) bool { + \\ return authenticate(token); + \\} + , + ); + try explorer.indexFile( + "handler.zig", + \\const auth = @import("auth.zig"); + \\ + \\pub fn handleLogin() void { + \\ if (auth.authenticate("x")) return; + \\} + , + ); + try explorer.indexFile( + "auth_test.zig", + \\const auth = @import("auth.zig"); + \\ + \\test "auth round-trip" { + \\ _ = auth.authenticate("x"); + \\} + , + ); + try explorer.indexFile( + "unrelated.zig", + \\pub fn formatNumber(n: i64) []const u8 { + \\ _ = n; + \\ return "0"; + \\} + , + ); + try explorer.indexFile("README.md", "# project\nauthenticate description here"); + + // 1. Full-text search: every file containing `authenticate` must appear. + { + const expected = [_][]const u8{ "auth.zig", "handler.zig", "auth_test.zig", "README.md" }; + const results = try explorer.searchContent("authenticate", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + var seen = std.StringHashMap(void).init(testing.allocator); + defer seen.deinit(); + for (results) |r| try seen.put(r.path, {}); + for (expected) |e| try testing.expect(seen.contains(e)); + try testing.expect(!seen.contains("unrelated.zig")); + } + + // 2. Word index: exact token `authenticate` must reach the same 4 files. + { + const hits = try explorer.searchWord("authenticate", testing.allocator); + defer testing.allocator.free(hits); + var seen = std.StringHashMap(void).init(testing.allocator); + defer seen.deinit(); + explorer.mu.lockShared(); + defer explorer.mu.unlockShared(); + for (hits) |h| try seen.put(explorer.word_index.hitPath(h), {}); + const expected = [_][]const u8{ "auth.zig", "handler.zig", "auth_test.zig", "README.md" }; + for (expected) |e| try testing.expect(seen.contains(e)); + } + + // 3. Symbol index: `authenticate` is defined once, in auth.zig. + { + const results = try explorer.findAllSymbols("authenticate", testing.allocator); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.symbol.name); + if (r.symbol.detail) |d| testing.allocator.free(d); + } + testing.allocator.free(results); + } + try testing.expect(results.len >= 1); + var found_def = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "auth.zig")) found_def = true; + } + try testing.expect(found_def); + } + + // 4. Fuzzy file find: query "auth" must reach both auth.zig and auth_test.zig. + { + const results = try explorer.fuzzyFindFiles("auth", testing.allocator, 50); + defer testing.allocator.free(results); + var seen = std.StringHashMap(void).init(testing.allocator); + defer seen.deinit(); + for (results) |r| try seen.put(r.path, {}); + try testing.expect(seen.contains("auth.zig")); + try testing.expect(seen.contains("auth_test.zig")); + } + + // 5. Glob: `auth*.zig` must include auth.zig and auth_test.zig only. + { + const matches = try explorer.globPaths(testing.allocator, "auth*.zig", 50); + defer testing.allocator.free(matches); + var found_auth = false; + var found_test = false; + for (matches) |m| { + if (std.mem.eql(u8, m, "auth.zig")) found_auth = true; + if (std.mem.eql(u8, m, "auth_test.zig")) found_test = true; + try testing.expect(!std.mem.eql(u8, m, "unrelated.zig")); + try testing.expect(!std.mem.eql(u8, m, "handler.zig")); + } + try testing.expect(found_auth); + try testing.expect(found_test); + } + + // 6. Dependency graph: handler.zig and auth_test.zig both import auth.zig. + { + const importers = try explorer.getImportedBy("auth.zig", testing.allocator); + defer { + for (importers) |p| testing.allocator.free(p); + testing.allocator.free(importers); + } + var saw_handler = false; + var saw_test = false; + for (importers) |p| { + if (std.mem.eql(u8, p, "handler.zig")) saw_handler = true; + if (std.mem.eql(u8, p, "auth_test.zig")) saw_test = true; + } + try testing.expect(saw_handler); + try testing.expect(saw_test); + } +} + + +test "issue-356-1: codedb_query returns partial results when a step fails" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + try explorer.indexFile("src/lib.zig", "pub fn helper() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + // Pipeline: step 0 (find) succeeds, step 1 (search) is missing 'query'. + // Pre-fix: bails on step 1, dropping step 0's output entirely. + // Post-fix: returns step 0's matched files + a "--- partial ---" tail + // naming the failing step. + const pipe_json = + \\{"pipeline":[ + \\ {"op":"find","query":"main"}, + \\ {"op":"search"} + \\]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, pipe_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_query, &parsed.value.object, &out, &store, &explorer, &agents); + + // Step 0's output (file matches) must survive even though step 1 failed. + try testing.expect(std.mem.indexOf(u8, out.items, "src/main.zig") != null); + // The partial-results tail must name the failing step so callers can + // recover instead of guessing what went wrong. + try testing.expect(std.mem.indexOf(u8, out.items, "--- partial ---") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "failed_at: 1") != null); +} + + +test "issue-356-2: codedb_outline suggests fuzzy alternatives for non-indexed paths" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + try explorer.indexFile("src/mcp.zig", "pub fn mcp() void {}\n"); + try explorer.indexFile("src/explore.zig", "pub fn explore() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + // Outline a path that doesn't index — typo on 'main.zig'. + const args_json = + \\{"path":"src/man.zig"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_outline, &parsed.value.object, &out, &store, &explorer, &agents); + + // Pre-fix: bare 'error: file not indexed' with no recovery hint. + // Post-fix: append fuzzy suggestions so the agent can self-correct. + try testing.expect(std.mem.indexOf(u8, out.items, "did you mean") != null); + // src/main.zig is the closest fuzzy match for src/man.zig. + try testing.expect(std.mem.indexOf(u8, out.items, "src/main.zig") != null); +} + + +test "issue-356-3: codedb_query surfaces received keys on missing-arg errors" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + // Single-step pipeline: search step missing 'query' but provided 'q' + // (common typo). The error should name the keys actually received so + // the caller can self-diagnose, mirroring the #357 bundle diagnostic. + const pipe_json = + \\{"pipeline":[{"op":"search","q":"main"}]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, pipe_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_query, &parsed.value.object, &out, &store, &explorer, &agents); + + // The legitimate missing-arg error must still appear. + try testing.expect(std.mem.indexOf(u8, out.items, "search needs 'query'") != null); + // And the diagnostic must surface what the step actually contained. + try testing.expect(std.mem.indexOf(u8, out.items, "received keys") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "q") != null); +} + + +test "issue-356-p2: codedb_outline missing path surfaces received keys" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"file_path":"src/main.zig"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_outline, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'path'") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "received keys") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "file_path") != null); +} + + +test "issue-356-p2: codedb_symbol missing name surfaces received keys" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"symbol":"main"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_symbol, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'name'") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "received keys") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "symbol") != null); +} + + +test "issue-356-p2: codedb_search missing query surfaces received keys" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"q":"main"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_search, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'query'") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "received keys") != null); +} + + +test "issue-356-p2: codedb_word missing word surfaces received keys" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"w":"main"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_word, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'word'") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "received keys") != null); +} + + +test "issue-356-p2: codedb_read missing path surfaces received keys" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"file":"src/main.zig"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_read, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'path'") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "received keys") != null); +} + + +test "issue-356-p2: codedb_deps missing path surfaces received keys" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"target":"src/main.zig"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_deps, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'path'") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "received keys") != null); +} + + +test "issue-356-p3: codedb_query emits per-stage summary tail on success" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + try explorer.indexFile("src/lib.zig", "pub fn helper() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + // Two-step pipeline that succeeds. Phase 3 emits a summary tail so + // callers can see which step did what without re-parsing the + // unstructured per-step output above it. + const pipe_json = + \\{"pipeline":[ + \\ {"op":"find","query":"main"}, + \\ {"op":"sort","by":"path"} + \\]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, pipe_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_query, &parsed.value.object, &out, &store, &explorer, &agents); + + // Stage summary appears at the end of a successful pipeline. + try testing.expect(std.mem.indexOf(u8, out.items, "--- stages ---") != null); + // Lists each step with op and outgoing file count. + try testing.expect(std.mem.indexOf(u8, out.items, "0: find") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "1: sort") != null); +} + + +test "issue-356-p3: codedb_outline includes actionable hint when parser fails" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + // Outline a path that's NOT indexed (no setRoot, so disk read won't + // help either). The "file not indexed" error already gets fuzzy + // suggestions from phase 1. This test pins that the hint format is + // actionable — specifically that a 'try codedb_index' suggestion + // appears so users know how to recover from a stale index. + const args_json = + \\{"path":"src/notindexed.zig"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_outline, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "file not indexed") != null); + // Phase 3 adds a 'codedb_index' hint so callers know how to recover + // from a stale index in addition to the 'did you mean' suggestions. + try testing.expect(std.mem.indexOf(u8, out.items, "codedb_index") != null); +} + + +test "issue-356-p3: codedb_read appends fuzzy suggestions when path is unreadable" { + const tmp_io = testing.io; + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + try tmp.dir.createDirPath(tmp_io, "src"); + try tmp.dir.writeFile(tmp_io, .{ + .sub_path = "src/main.zig", + .data = "pub fn main() void {}\n", + }); + + var project_path_buf: [std.fs.max_path_bytes]u8 = undefined; + const project_path_len = try tmp.dir.realPathFile(tmp_io, ".", &project_path_buf); + const project_path = project_path_buf[0..project_path_len]; + + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + explorer.setRoot(tmp_io, project_path); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + try explorer.indexFile("src/lib.zig", "pub fn helper() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, project_path, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + // Read a non-indexed, non-existent path. Pre-fix: bare 'failed to read file'. + // Post-fix: append fuzzy suggestions like outline already does. + const args_json = + \\{"path":"src/man.zig"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_read, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "failed to read file") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "did you mean") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "src/main.zig") != null); +} + diff --git a/src/test_search.zig b/src/test_search.zig new file mode 100644 index 0000000..afc194e --- /dev/null +++ b/src/test_search.zig @@ -0,0 +1,1598 @@ +const std = @import("std"); +const cio = @import("cio.zig"); +const testing = std.testing; +const io = std.testing.io; +const Store = @import("store.zig").Store; +const Explorer = @import("explore.zig").Explorer; +const SearchResult = @import("explore.zig").SearchResult; +const WordIndex = @import("index.zig").WordIndex; +const TrigramIndex = @import("index.zig").TrigramIndex; +const SparseNgramIndex = @import("index.zig").SparseNgramIndex; +const explore = @import("explore.zig"); +const Language = explore.Language; +const SymbolKind = explore.SymbolKind; +const DependencyGraph = explore.DependencyGraph; +const SymbolLocation = explore.SymbolLocation; +const mcp_mod = @import("mcp.zig"); +const AgentRegistry = @import("agent.zig").AgentRegistry; + + +test "issue-264: early exit at max_results misses valid matches in remaining candidates" { + // searchContent stops as soon as result_list.items.len >= max_results. + // The first-indexed file is iterated first (doc_id order). If it has + // many matches it fills the quota alone, and later files are never checked. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // Index noisy file FIRST — it will be the first trigram candidate. + try explorer.indexFile("noisy.zig", + \\fn target_token() void {} + \\fn target_token_v2() void {} + \\const target_token_ptr = undefined; + \\var target_token_state = 0; + \\test "target_token works" {} + \\// calls target_token internally + ); + + // Index quiet file SECOND — it will be a later candidate. + try explorer.indexFile("quiet.zig", "fn target_token() void {}"); + + // max_results=5: noisy.zig has 6 matches, fills the quota. + const results = try explorer.searchContent("target_token", testing.allocator, 5); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + // quiet.zig must be represented in results even though noisy.zig + // has enough matches to fill max_results by itself. + var found_quiet = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "quiet.zig")) found_quiet = true; + } + try testing.expect(found_quiet); +} + + +test "search: line numbers correct with incremental counting" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // File with target on specific lines + const content = "line1\nline2\ntarget_here\nline4\nline5\ntarget_here\nline7\n"; + try explorer.indexFile("test.zig", content); + + const results = try explorer.searchContent("target_here", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + try testing.expectEqual(@as(usize, 2), results.len); + try testing.expectEqual(@as(u32, 3), results[0].line_num); + try testing.expectEqual(@as(u32, 6), results[1].line_num); +} + + +test "issue-290: searchContent with hyphen query does not crash" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("a.zig", "const x = \"test-case\";\n"); + const results = try explorer.searchContent("test-case", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } +} + + +test "issue-292: searchContent with pipe query does not crash" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("a.zig", "const x = \"timestamp|activity|filter\";\n"); + const results = try explorer.searchContent("timestamp|activity|filter", testing.allocator, 5); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } +} + + +test "issue-292: codedb_search guidance hints regex=true on metachar query" { + const args_json = "{\"query\":\"timestamp|activity|filter\"}"; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var buf: std.ArrayList(u8) = .empty; + defer buf.deinit(testing.allocator); + mcp_mod.mcpGenerateGuidance(testing.allocator, "codedb_search", &parsed.value.object, "", false, &buf); + try testing.expect(std.mem.indexOf(u8, buf.items, "regex=true") != null); +} + + +test "issue-292: codedb_search guidance does not warn when regex=true is set" { + const args_json = "{\"query\":\"timestamp|activity\",\"regex\":true}"; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var buf: std.ArrayList(u8) = .empty; + defer buf.deinit(testing.allocator); + mcp_mod.mcpGenerateGuidance(testing.allocator, "codedb_search", &parsed.value.object, "", false, &buf); + try testing.expect(std.mem.indexOf(u8, buf.items, "regex=true") == null); +} + + +test "issue-290: codedb_search guidance does not warn on plain hyphen" { + const args_json = "{\"query\":\"test-case\"}"; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var buf: std.ArrayList(u8) = .empty; + defer buf.deinit(testing.allocator); + mcp_mod.mcpGenerateGuidance(testing.allocator, "codedb_search", &parsed.value.object, "", false, &buf); + try testing.expect(std.mem.indexOf(u8, buf.items, "regex=true") == null); +} + + +test "issue-363b: fuzzyFindFiles ranks exact basename match above unrelated lib.rs" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // Reproducer from #363: indexing the codegraff workspace, querying 'cli.rs' + // returned four `lib.rs` files before the actual `crates/forge_main/src/cli.rs`. + // Path layout matches the user's report. + try explorer.indexFile("crates/forge_ci/src/lib.rs", "pub fn ci() {}\n"); + try explorer.indexFile("crates/forge_fs/src/lib.rs", "pub fn fs() {}\n"); + try explorer.indexFile("crates/forge_app/src/lib.rs", "pub fn app_lib() {}\n"); + try explorer.indexFile("crates/forge_api/src/lib.rs", "pub fn api() {}\n"); + try explorer.indexFile( + "crates/forge_main/src/cli.rs", + "pub fn parse_args() -> Args {\n Args {}\n}\n", + ); + + const matches = try explorer.fuzzyFindFiles("cli.rs", testing.allocator, 5); + defer testing.allocator.free(matches); + + try testing.expect(matches.len > 0); + // Exact-basename match should be #1, not buried below unrelated lib.rs files. + try testing.expectEqualStrings("crates/forge_main/src/cli.rs", matches[0].path); +} + + +test "issue-363a: searchContent surfaces source-file matches even when doc files dominate the word index" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // To hit Tier 0 of searchContent (explore.zig:1511-1535) the gate + // `word_hits.len <= max_results * 2` must hold. We pick small numbers: + // 4 docs × 4 mentions = 16 hits, then 2 source-file hits = 18 total, with + // max_results=10 → 18 ≤ 20 ✓ → Tier 0 runs. + var path_buf: [64]u8 = undefined; + var content_buf: [1024]u8 = undefined; + var i: usize = 0; + while (i < 4) : (i += 1) { + const path = try std.fmt.bufPrint(&path_buf, "docs/notes_{d}.md", .{i}); + const content = try std.fmt.bufPrint(&content_buf, + "## Notes {d}\n\n" ++ + "The searchContent function is documented here.\n" ++ + "We discuss searchContent at length.\n" ++ + "Note that searchContent is multi-tier.\n" ++ + "Performance: searchContent is fast.\n", + .{i}, + ); + try explorer.indexFile(path, content); + } + + // Index the source file LAST so its word-index hits land at the END of + // the posting list. Pre-fix, Tier 0 fills the result_list with doc hits + // and returns before reaching source-file hits. + try explorer.indexFile( + "src/explore.zig", + "pub fn searchContent(self: *Explorer, query: []const u8) !void {\n" ++ + " // searchContent is the multi-tier text search entrypoint.\n" ++ + " _ = self;\n" ++ + " _ = query;\n" ++ + "}\n", + ); + + const results = try explorer.searchContent("searchContent", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + var found_source = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "src/explore.zig")) { + found_source = true; + break; + } + } + // The source file MUST appear — it's the canonical match for the + // identifier. Pre-fix, doc-file hits saturated the 10-result quota in + // Tier 0 and src/explore.zig was dropped. + try testing.expect(found_source); +} + + +test "issue-recall: codedb_search supports path_glob filter" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "received keys foo\n"); + try explorer.indexFile("CHANGELOG.md", "received keys diagnostic\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"query":"received keys","path_glob":"*.zig"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_search, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "src/main.zig") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "CHANGELOG.md") == null); +} + + +test "issue-422: search header count must reflect post-filter visible results" { + // From the issue: a query whose ONLY match would be displayed instead + // shows `1 results` then `(0 shown, 1 truncated)` — every match hidden + // behind a misleading header. Root cause: the header reports the + // unfiltered `results.len` from the explorer, but path_glob/compact + // filters can drop items before they reach the renderer, so a "result" + // that was filtered is mis-labeled as "truncated". + // + // Repro shape mirrors the reporter's call: scope=true, compact=true, + // path_glob limited to a subtree. The match ITSELF is in-glob and not a + // comment — the bug is purely in the bookkeeping. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + // Two files: one in the path_glob subtree (the real match), one outside + // it (a decoy that the explorer would also return for the substring). + // Without the fix the header counts both, then the renderer drops the + // out-of-glob one and (because of unrelated bookkeeping) reports the + // in-glob one as "truncated" too. + try explorer.indexFile( + "crates/forge_api/src/forge_api.rs", + "// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\n// header\npub struct ForgeAPI {\n", + ); + // Decoy match outside the glob — explorer will return it, the renderer + // must NOT count it toward "truncated". + try explorer.indexFile("docs/forge_api.md", "struct ForgeAPI is documented here\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"query":"struct ForgeAPI","max_results":20,"scope":true,"compact":true,"regex":false,"path_glob":"crates/**/*.rs"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_search, &parsed.value.object, &out, &store, &explorer, &agents); + + // The actionable hit must be visible (path + line number). + try testing.expect(std.mem.indexOf(u8, out.items, "crates/forge_api/src/forge_api.rs") != null); + try testing.expect(std.mem.indexOf(u8, out.items, ":24:") != null); + // Out-of-glob decoy must be excluded from the rendered output. + try testing.expect(std.mem.indexOf(u8, out.items, "docs/forge_api.md") == null); + // The misleading "(N shown, M truncated)" footer must NOT fire when M + // is just the count of glob-filtered or compact-filtered items. Those + // weren't truncated — they were filtered out, and saying "truncated" + // implies the user could recover them by raising max_results. + try testing.expect(std.mem.indexOf(u8, out.items, " truncated)") == null); + // Header count must reflect post-filter visible matches (1), not the + // raw explorer count (2). Otherwise users see a misleading "2 results" + // when only 1 matched their glob. + try testing.expect(std.mem.indexOf(u8, out.items, "1 results for 'struct ForgeAPI'") != null); +} + + +test "issue-390: codedb_search scope=true caps matches per file" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + // Build a "dominant" file with 20 matches plus several files with 1 match + // each. Without a per-file cap on the scope=true path, the dominant file + // alone drowns the response. The plain/regex branches already enforce + // max_per_file=5 (mcp.zig:1141, 1198), but the scope=true branch does not. + var dominant_buf: std.ArrayList(u8) = .empty; + defer dominant_buf.deinit(testing.allocator); + try dominant_buf.appendSlice(testing.allocator, "pub fn dominant() void {\n"); + for (0..20) |_| try dominant_buf.appendSlice(testing.allocator, " // FROBNICATE token\n"); + try dominant_buf.appendSlice(testing.allocator, "}\n"); + try explorer.indexFile("src/dominant.zig", dominant_buf.items); + try explorer.indexFile("src/a.zig", "// FROBNICATE here\npub fn a() void {}\n"); + try explorer.indexFile("src/b.zig", "// FROBNICATE here\npub fn b() void {}\n"); + try explorer.indexFile("src/c.zig", "// FROBNICATE here\npub fn c() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{"query":"FROBNICATE","scope":true,"max_results":100} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_search, &parsed.value.object, &out, &store, &explorer, &agents); + + // Count "src/dominant.zig:" occurrences (one per emitted match line). + var dominant_lines: usize = 0; + var i: usize = 0; + while (std.mem.indexOfPos(u8, out.items, i, "src/dominant.zig:")) |pos| { + dominant_lines += 1; + i = pos + 1; + } + // The plain-search per-file cap is 5; scope=true should match. Without + // any cap, all 20 matches surface and starve the smaller files. + try testing.expect(dominant_lines <= 5); + // The other files still surface — the cap shouldn't tank recall, just + // bound the dominant file's share. + try testing.expect(std.mem.indexOf(u8, out.items, "src/a.zig:") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "src/b.zig:") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "src/c.zig:") != null); +} + + +test "issue-391: codedb_callers tool exists" { + // codedb_callers is the proposed reverse-callgraph tool: given a symbol + // name, return the call sites across the index. It fuses the existing + // word index with outline scopes, replacing the multi-step + // "codedb_word → eyeball → codedb_outline per file" workflow. + // + // The minimum surface contract: the Tool enum exposes a codedb_callers + // variant so dispatch can route to it. Today it does not, so the + // workflow has to be assembled by hand on the client side. + try testing.expect(@hasField(mcp_mod.Tool, "codedb_callers")); +} + + +test "issue-391: codedb_callers returns call sites with scope" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + try explorer.indexFile("def.zig", "pub fn fooBar() void {}\n"); + try explorer.indexFile("a.zig", "pub fn callerA() void {\n fooBar();\n}\n"); + try explorer.indexFile("b.zig", "pub fn callerB() void {\n fooBar();\n}\n"); + + const args_json = + \\{"name":"fooBar"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_callers, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.indexOf(u8, out.items, "2 call sites for 'fooBar'") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "a.zig:2") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "b.zig:2") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "callerA") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "callerB") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "def.zig:1") == null); +} + + +test "issue-391: codedb_callers rejects missing name" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const args_json = + \\{} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_callers, &parsed.value.object, &out, &store, &explorer, &agents); + + try testing.expect(std.mem.startsWith(u8, out.items, "error:")); + try testing.expect(std.mem.indexOf(u8, out.items, "name") != null); +} + + +test "issue-393: BM25 ranking surfaces high-density file before single-mention file" { + // Multi-term content queries today return matches in scan order with only + // a per-line occurrence count tiebreaker (explore.zig:1674-1688). On a + // large repo this dumps every match with no notion of which *file* is the + // most relevant — a file that mentions every query term many times ranks + // identically to one that mentions a single term once. + // + // BM25 over the existing trigram + word index would score documents by + // (per-term tf * idf) with length normalization, so the file densely + // covering both terms surfaces above the noise file. + // + // Minimum surface contract: Explorer exposes `searchContentRanked` which + // takes a multi-term query and returns results ordered by descending + // BM25 score across files (highest-scoring document's match comes first). + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // dense.zig: hits both query terms many times across many lines. + try explorer.indexFile("src/dense.zig", + \\pub fn parseTokenStream() void { + \\ const token = nextToken(); + \\ parseToken(token); + \\ parseToken(token); + \\ parseToken(token); + \\ const stream = parseTokenStream(); + \\ parseTokenStream(); + \\ _ = token; + \\ _ = stream; + \\} + ); + // sparse.zig: mentions one term once, in passing. + try explorer.indexFile("src/sparse.zig", + \\pub fn unrelated() void { + \\ // a passing mention of parse here + \\ return; + \\} + ); + // Noise files dilute df-based scoring; BM25 must still rank dense first. + try explorer.indexFile("src/noise_a.zig", "pub fn a() void {}\n"); + try explorer.indexFile("src/noise_b.zig", "pub fn b() void {}\n"); + try explorer.indexFile("src/noise_c.zig", "pub fn c() void {}\n"); + + try testing.expect(@hasDecl(Explorer, "searchContentRanked")); + + const results = try explorer.searchContentRanked("parse Token", testing.allocator, 16); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + try testing.expect(results.len > 0); + // Top-ranked result must come from the dense file. + try testing.expectEqualStrings("src/dense.zig", results[0].path); + // Score must be populated and strictly positive when ranking is on. + try testing.expect(results[0].score > 0.0); + // Results must be sorted by score descending across distinct documents: + // the first dense.zig score must exceed the first sparse.zig score. + var dense_score: f32 = -1.0; + var sparse_score: f32 = -1.0; + for (results) |r| { + if (dense_score < 0 and std.mem.eql(u8, r.path, "src/dense.zig")) dense_score = r.score; + if (sparse_score < 0 and std.mem.eql(u8, r.path, "src/sparse.zig")) sparse_score = r.score; + } + if (sparse_score >= 0) { + try testing.expect(dense_score > sparse_score); + } +} + + +test "issue-400: BM25 ranks both-terms file above single-term files" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("both.zig", + \\pub fn parseToken() void { + \\ parseToken(); + \\ parseToken(); + \\} + ); + try explorer.indexFile("only_parse.zig", + \\pub fn parseFoo() void { + \\ parse(); + \\} + ); + try explorer.indexFile("only_token.zig", + \\pub fn tokenStream() void { + \\ token(); + \\} + ); + + const results = try explorer.searchContentRanked("parse Token", testing.allocator, 8); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + try testing.expect(results.len > 0); + try testing.expectEqualStrings("both.zig", results[0].path); + try testing.expect(results[0].score > 0.0); +} + + +test "issue-400-bug1: searchContentRanked returns ranked results when skip_file_words=true" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + explorer.word_index.skip_file_words = true; + try explorer.indexFile("a.zig", "apple banana\n"); + try explorer.indexFile("b.zig", "apple\n"); + const results = try explorer.searchContentRanked("apple", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + try testing.expect(results.len > 0); +} + + +test "issue-400-bug2: total_tokens stays consistent across re-index when skip_file_words=true" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + explorer.word_index.skip_file_words = true; + try explorer.indexFile("a.zig", "one two three four\n"); + try explorer.indexFile("a.zig", "five six seven\n"); + try explorer.indexFile("a.zig", "eight\n"); + try testing.expectEqual(@as(u64, 1), explorer.word_index.total_tokens); +} + + +test "bm25-recall-a: single-term tf ordering" { + // 3 docs with identical length but "apple" on different numbers of lines. + // The index deduplicates per (doc, line), so tf = number of lines with the term. + // Equal doc lengths mean length normalization is constant; higher tf must rank higher. + // Each doc has exactly 10 tokens (5 lines x 2 tokens each). + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // doc1: apple on 1 of 5 lines + try explorer.indexFile("doc1.txt", "apple filler\nfiller filler\nfiller filler\nfiller filler\nfiller filler"); + // doc2: apple on 5 of 5 lines (max tf) + try explorer.indexFile("doc2.txt", "apple filler\napple filler\napple filler\napple filler\napple filler"); + // doc3: apple on 2 of 5 lines + try explorer.indexFile("doc3.txt", "apple filler\napple filler\nfiller filler\nfiller filler\nfiller filler"); + + const results = try explorer.searchContentRanked("apple", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + try testing.expectEqual(@as(usize, 3), results.len); + try testing.expectEqualStrings("doc2.txt", results[0].path); + try testing.expectEqualStrings("doc3.txt", results[1].path); + try testing.expectEqualStrings("doc1.txt", results[2].path); + try testing.expect(results[0].score > results[1].score); + try testing.expect(results[1].score > results[2].score); +} + + +test "bm25-recall-b: both-terms doc beats high-tf single-term doc" { + // doc1 has apple+banana (both query terms, one occurrence each). + // doc2 has only apple, but repeated 3x (high tf). + // doc3 has only banana, once. + // BM25 sums idf*tf_norm per term: doc1 accumulates two idf contributions + // while doc2 only gets one -- doc1 must rank first. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("doc1.txt", "apple banana cherry"); + try explorer.indexFile("doc2.txt", "apple apple apple"); + try explorer.indexFile("doc3.txt", "banana date elderberry"); + + const results = try explorer.searchContentRanked("apple banana", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + try testing.expect(results.len >= 2); + try testing.expectEqualStrings("doc1.txt", results[0].path); + try testing.expect(results[0].score > 0.0); + var doc2_score: f32 = -1.0; + for (results) |r| { + if (std.mem.eql(u8, r.path, "doc2.txt")) { + doc2_score = r.score; + break; + } + } + if (doc2_score >= 0.0) { + try testing.expect(results[0].score > doc2_score); + } +} + + +test "bm25-recall-c: df-saturation -- ubiquitous term has near-zero idf" { + // "the" appears in all 11 docs -> idf near zero, barely contributes. + // "unique_marker" appears only in special.txt -> high idf, special.txt ranks first. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("d1.txt", "the quick brown fox"); + try explorer.indexFile("d2.txt", "the lazy dog jumps"); + try explorer.indexFile("d3.txt", "the sun rises east"); + try explorer.indexFile("d4.txt", "the moon shines bright"); + try explorer.indexFile("d5.txt", "the rain in spain"); + try explorer.indexFile("d6.txt", "the cat sat mat"); + try explorer.indexFile("d7.txt", "the wind blows cold"); + try explorer.indexFile("d8.txt", "the tide comes in"); + try explorer.indexFile("d9.txt", "the stars align now"); + try explorer.indexFile("d10.txt", "the clock ticks forward"); + try explorer.indexFile("special.txt", "the unique_marker is here"); + + const results = try explorer.searchContentRanked("the unique_marker", testing.allocator, 20); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + try testing.expect(results.len > 0); + try testing.expectEqualStrings("special.txt", results[0].path); + if (results.len > 1) { + try testing.expect(results[0].score > results[1].score); + } +} + + +test "bm25-recall-d: length normalization favors shorter doc" { + // short.txt: 5 tokens, one "needle". + // long.txt: ~50 tokens, one "needle". + // BM25 with b=0.75 penalizes longer docs; short.txt must rank higher. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("short.txt", "needle alpha beta gamma delta"); + try explorer.indexFile("long.txt", + "aa bb cc dd ee ff gg hh ii jj kk ll mm nn oo pp qq rr ss tt uu vv ww xx yy zz " ++ + "aa bb cc dd ee ff gg hh ii jj kk ll mm nn oo pp qq rr ss tt uu vv ww xx needle yy zz" + ); + + const results = try explorer.searchContentRanked("needle", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + try testing.expectEqual(@as(usize, 2), results.len); + try testing.expectEqualStrings("short.txt", results[0].path); + try testing.expect(results[0].score > results[1].score); +} + + +test "bm25-recall-e: empty and pathological queries return empty without crash" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("file.txt", "some content here"); + + { + const r = try explorer.searchContentRanked("", testing.allocator, 10); + defer testing.allocator.free(r); + try testing.expectEqual(@as(usize, 0), r.len); + } + { + const r = try explorer.searchContentRanked(" ", testing.allocator, 10); + defer testing.allocator.free(r); + try testing.expectEqual(@as(usize, 0), r.len); + } + { + const r = try explorer.searchContentRanked("nonexistent_xyz_term_99", testing.allocator, 10); + defer testing.allocator.free(r); + try testing.expectEqual(@as(usize, 0), r.len); + } +} + + +test "bm25-stress: 1000-doc index, common token, max_results cap honored" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + var path_buf: [64]u8 = undefined; + var content_buf: [256]u8 = undefined; + for (0..1000) |i| { + const path = std.fmt.bufPrint(&path_buf, "stress/doc{d}.txt", .{i}) catch unreachable; + const content = std.fmt.bufPrint(&content_buf, + "common token alpha beta gamma doc{d} extra filler words here now", .{i} + ) catch unreachable; + try explorer.indexFile(path, content); + } + + const cap = 25; + const results = try explorer.searchContentRanked("common", testing.allocator, cap); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + try testing.expect(results.len <= cap); + try testing.expect(results.len > 0); + for (results) |r| { + try testing.expect(r.score > 0.0); + } + for (1..results.len) |i| { + try testing.expect(results[i - 1].score >= results[i].score); + } +} + + +test "bm25-state-sync: re-index and remove update total_tokens correctly" { + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + + try explorer.indexFile("sync.txt", "alpha beta gamma delta epsilon"); + try testing.expectEqual(@as(u64, 5), explorer.word_index.total_tokens); + + try explorer.indexFile("sync.txt", "alpha beta"); + try testing.expectEqual(@as(u64, 2), explorer.word_index.total_tokens); + + explorer.removeFile("sync.txt"); + try testing.expectEqual(@as(u64, 0), explorer.word_index.total_tokens); +} + + +test "issue-425: codedb_callers excludes substring matches in unrelated identifiers" { + // handleCallers (mcp.zig:1339) currently calls searchContentWithScope(name) + // which is a *substring* full-text search. The only de-dup it performs is + // dropping lines that match the canonical definition of `name` itself. + // That means a search for "fooBar" returns lines mentioning the unrelated + // identifier "fooBarExtended" — both its definition site and any reference + // — as if they were call sites. The fix is a whole-word check on the hit + // line so substring matches in longer identifiers are excluded. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + try explorer.indexFile("def.zig", "pub fn fooBar() void {}\n"); + // A different symbol whose name contains "fooBar" as a substring. + try explorer.indexFile("other.zig", "pub fn fooBarExtended() void {}\n"); + // A genuine call site. + try explorer.indexFile("a.zig", "pub fn callerA() void {\n fooBar();\n}\n"); + + const args_json = + \\{"name":"fooBar"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_callers, &parsed.value.object, &out, &store, &explorer, &agents); + + // Real call site must still appear. + try testing.expect(std.mem.indexOf(u8, out.items, "a.zig:2") != null); + // Substring-only matches in unrelated identifiers must NOT. + try testing.expect(std.mem.indexOf(u8, out.items, "other.zig") == null); + try testing.expect(std.mem.indexOf(u8, out.items, "fooBarExtended") == null); + // Header reports the real count (1), not the inflated count (2). + try testing.expect(std.mem.indexOf(u8, out.items, "1 call sites for 'fooBar'") != null); +} + + +test "issue-426: codedb_callers excludes non-code files (markdown, docs)" { + // handleCallers (mcp.zig:1339) feeds searchContentWithScope across every + // indexed file regardless of language. Markdown and other documentation + // files that mention the symbol in prose surface as if they were call + // sites. The fix is a language gate: skip results from non-code files. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store = Store.init(testing.allocator); + defer store.deinit(); + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + try explorer.indexFile("def.zig", "pub fn fooBar() void {}\n"); + try explorer.indexFile("a.zig", "pub fn callerA() void {\n fooBar();\n}\n"); + // Prose mention in a docs file — the identifier appears as a whole + // word, so this is independent of the substring-match bug (#425): + // even a perfect whole-word match on a markdown file is still not a + // call site. + try explorer.indexFile( + "docs/notes.md", + "# Notes\n\nThe fooBar helper is documented here for posterity.\n", + ); + + const args_json = + \\{"name":"fooBar"} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, args_json, .{}); + defer parsed.deinit(); + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_callers, &parsed.value.object, &out, &store, &explorer, &agents); + + // Real call site present. + try testing.expect(std.mem.indexOf(u8, out.items, "a.zig:2") != null); + // Markdown mention must NOT appear as a call site. + try testing.expect(std.mem.indexOf(u8, out.items, "docs/notes.md") == null); + // Header reflects the real count. + try testing.expect(std.mem.indexOf(u8, out.items, "1 call sites for 'fooBar'") != null); +} + + +test "issue-427: searchContent Tier 1 sort starves the definition-dense file" { + // searchContent's Tier 1 (explore.zig:1590-1598) sorts trigram candidates + // by file content length ASCENDING and then applies a per-file cap of + // max(1, max_results / estimated_total). When several small unrelated + // files match the query, they each contribute one hit and saturate the + // result quota before the canonical (large, definition-dense) file is + // ever scanned — so the file with the most occurrences of the term is + // missing from the output. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // 8 small files. Each contains one occurrence of the term as a whole + // word. They sort first under the length-ascending Tier 1 order. + const small_count: usize = 8; + var i: usize = 0; + while (i < small_count) : (i += 1) { + var path_buf: [32]u8 = undefined; + const path = try std.fmt.bufPrint(&path_buf, "small_{d}.zig", .{i}); + try explorer.indexFile(path, "fn s() void { _ = widgetX; }\n"); + } + + // Canonical file: many lines mentioning widgetX, padded so its content + // length is larger than every small file (sort key: content length). + const canonical_content = + "fn canonical() void {\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + " _ = widgetX;\n" ++ + " // padding line for content length, to push this file to the\n" ++ + " // tail of the length-ascending sort. The reranker should still\n" ++ + " // surface it because it has the most occurrences of the term.\n" ++ + " _ = 0;\n" ++ + "}\n"; + try explorer.indexFile("canonical.zig", canonical_content); + + // max_results small enough that 8 small files can saturate the quota. + // word_hits.len = small_count (8) + canonical occurrences (4) = 12. + // max_results * 2 = 10. 12 > 10 → Tier 0 gate fails → Tier 1 fires. + const results = try explorer.searchContent("widgetX", testing.allocator, 5); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + // The canonical file MUST appear in the result set. Pre-fix it does not: + // small files fill all 5 slots first under length-asc order, and the + // early-return at result_list.len >= max_results returns before the + // canonical file is ever read. + var found_canonical = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "canonical.zig")) { + found_canonical = true; + break; + } + } + try testing.expect(found_canonical); +} + + +test "issue-429-a: searchContent rerank boosts files whose basename matches the query" { + // Two files, same hit count, same content length. The current rerank + // (explore.zig:1700-1712) sorts ties by path-asc, so a file named + // "unrelated.zig" outranks "widgetX.zig" even though the latter's + // basename matches the query exactly. The basename match is a strong + // intent signal — the developer is asking about that file's subject. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("src/unrelated.zig", "pub fn process() void { _ = widgetX; }\n"); + try explorer.indexFile("src/widgetX.zig", "pub fn process() void { _ = widgetX; }\n"); + + const results = try explorer.searchContent("widgetX", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len >= 2); + try testing.expectEqualStrings("src/widgetX.zig", results[0].path); +} + + +test "issue-429-b: searchContent rerank penalizes test/vendor/examples paths" { + // Two files, same hit count, same content. Pre-fix the path-asc + // tiebreaker promotes "examples/sample.zig" (e < s) above + // "src/sample.zig". Post-fix path priors push code roots above + // example/test/vendor directories so the source-of-truth lands first. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("examples/sample.zig", "pub fn x() void { _ = someTerm; }\n"); + try explorer.indexFile("src/sample.zig", "pub fn x() void { _ = someTerm; }\n"); + + const results = try explorer.searchContent("someTerm", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len >= 2); + try testing.expectEqualStrings("src/sample.zig", results[0].path); +} + + +test "issue-429-c: searchContent rerank boosts lines that are symbol definitions" { + // Two files. "aaa.zig" has a passing comment mention of `fooSym`. The + // alphabetically-later "zzz_def.zig" has the actual definition. Both + // tie on per-line occurrence count. Pre-fix the path-asc tiebreaker + // promotes the comment mention ("aaa" < "zzz"). Post-fix the rerank + // recognises that the line in zzz_def.zig is a symbol definition and + // ranks it first. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("aaa.zig", "// fooSym is referenced here in a comment\n"); + try explorer.indexFile("zzz_def.zig", "pub fn fooSym() void {}\n"); + + const results = try explorer.searchContent("fooSym", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len >= 2); + try testing.expectEqualStrings("zzz_def.zig", results[0].path); +} + + +test "issue-430: Tier 0 markdown dominance starves canonical source file" { + // Tier 0 of searchContent (explore.zig:1525-1554) iterates the word + // index posting list in insertion order with a per-file cap of + // max(1, max_results/5). When a handful of markdown documents + // (CHANGELOG.md, benchmarks/*.md, design docs) each mention the query + // many times AND happen to appear earlier in the posting list than the + // canonical source file, they saturate result_list before the source + // file is reached. The existing #363a fix asserted *presence* with a + // small corpus; this is the high-density regime where presence still + // fails because Tier 0 hits max_results before the source file's + // posting-list entries are processed. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // 5 markdown files each with 10 mentions of fooBar — indexed FIRST so + // they land at the head of the posting list. With max_results=50 and + // per-file cap=10, these 5 files alone fill all 50 slots. + const md_block = "fooBar mentioned here.\nfooBar mentioned here.\n" ++ + "fooBar mentioned here.\nfooBar mentioned here.\n" ++ + "fooBar mentioned here.\nfooBar mentioned here.\n" ++ + "fooBar mentioned here.\nfooBar mentioned here.\n" ++ + "fooBar mentioned here.\nfooBar mentioned here.\n"; + var i: usize = 0; + while (i < 5) : (i += 1) { + var path_buf: [64]u8 = undefined; + const path = try std.fmt.bufPrint(&path_buf, "docs/notes_{d}.md", .{i}); + try explorer.indexFile(path, md_block); + } + + // Source file with the canonical definition + several real call sites, + // indexed LAST so its posting-list entries come after the markdown noise. + try explorer.indexFile("src/foo.zig", + "pub fn fooBar() void {}\n" ++ + "pub fn caller1() void { fooBar(); }\n" ++ + "pub fn caller2() void { fooBar(); }\n" ++ + "pub fn caller3() void { fooBar(); }\n"); + + const results = try explorer.searchContent("fooBar", testing.allocator, 50); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + var found_source = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "src/foo.zig")) { + found_source = true; + break; + } + } + // The canonical source file MUST appear in the results. Pre-fix it does + // not: 5 markdown files × 10 hits = 50 entries fill result_list before + // the source file is reached, then Tier 0 returns at max_results. + try testing.expect(found_source); +} + + +test "issue-431: searchContent does not crash when query is longer than content" { + // searchInContent (explore.zig:3881) computes + // const end = content.len - query.len + 1; + // without checking that query.len <= content.len. When the query is + // longer than the file content, the subtraction underflows in usize + // and the binary panics with integer overflow (or aborts with SIGBUS + // in ReleaseFast). Reproducer: index a tiny file, search for a query + // longer than the file's content. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("a.zig", "fn x() void {}\n"); + + var q_buf: [256]u8 = undefined; + @memset(&q_buf, 'a'); + const q = q_buf[0..256]; + + const results = try explorer.searchContent(q, testing.allocator, 5); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len == 0); +} + + +test "issue-429-d: searchContent rerank boosts path-segment match" { + // Two files, same hit count, same content. The query "parser" appears + // as a directory segment of one path. Pre-fix the alphabetic tiebreak + // promotes "src/handlers/foo.zig" (h < p). Post-fix the path-segment + // match boost surfaces "src/parser/foo.zig" first. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("src/handlers/foo.zig", "// parser is mentioned here\n"); + try explorer.indexFile("src/parser/foo.zig", "// parser is mentioned here\n"); + + const results = try explorer.searchContent("parser", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len >= 2); + try testing.expectEqualStrings("src/parser/foo.zig", results[0].path); +} + + +test "issue-429-e: searchContent rerank penalises doc-language files so code beats markdown noise" { + // CHANGELOG.md and benchmark docs often mention an identifier many times + // in a single line, which under per-line frequency outscores any single + // code call site. The reranker now halves doc-language scores so a code + // call site with one occurrence still wins. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // Doc file with the identifier mentioned four times on one line — + // pre-fix this scores 4 on per-line frequency. + try explorer.indexFile( + "CHANGELOG.md", + "# Changelog\n\nfooBar — fooBar fooBar fooBar in the changelog.\n", + ); + // Code call site with the identifier mentioned once. + try explorer.indexFile( + "src/caller.zig", + "pub fn caller() void {\n fooBar();\n}\n", + ); + + const results = try explorer.searchContent("fooBar", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len >= 2); + try testing.expectEqualStrings("src/caller.zig", results[0].path); +} + + +test "issue-448-a: rerank boosts basename when query contains stem" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("src/aaa.zig", "// Explorer is mentioned here\n"); + try explorer.indexFile("src/explore.zig", "// Explorer is mentioned here\n"); + + const results = try explorer.searchContent("Explorer", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + try testing.expect(results.len >= 2); + try testing.expectEqualStrings("src/explore.zig", results[0].path); +} + + +test "issue-448-b: rerank symbol definition boost is case-insensitive" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("aaa.zig", "// store is mentioned here\n"); + try explorer.indexFile("zzz.zig", "pub const Store = struct {};\n"); + + const results = try explorer.searchContent("store", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + try testing.expect(results.len >= 2); + try testing.expectEqualStrings("zzz.zig", results[0].path); +} + + +test "issue-449: popular markdown should not disable Tier 0 code-first behavior" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + const md_block = + "fooBar mentioned here.\n" ++ + "fooBar mentioned here.\n" ++ + "fooBar mentioned here.\n" ++ + "fooBar mentioned here.\n" ++ + "fooBar mentioned here.\n"; + + var i: usize = 0; + while (i < 10) : (i += 1) { + var path_buf: [64]u8 = undefined; + const path = try std.fmt.bufPrint(&path_buf, "docs/notes_{d}.md", .{i}); + try explorer.indexFile(path, md_block); + } + + try explorer.indexFile("src/foo.zig", + "pub fn fooBar() void {}\n" ++ + "pub fn caller1() void { fooBar(); }\n" ++ + "pub fn caller2() void { fooBar(); }\n" ++ + "pub fn caller3() void { fooBar(); }\n"); + + const results = try explorer.searchContent("fooBar", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + var found_source = false; + for (results) |r| { + if (std.mem.eql(u8, r.path, "src/foo.zig")) found_source = true; + } + try testing.expect(found_source); +} + + +test "issue-450: prefix tier respects max_results" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try explorer.indexFile("a.zig", "const abcx = 1;\n"); + try explorer.indexFile("b.zig", "const abcy = 1;\n"); + try explorer.indexFile("c.zig", "const zzabczz = 1;\n"); + + const results = try explorer.searchContent("abc", testing.allocator, 2); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + try testing.expect(results.len <= 2); +} + + +test "rerank-trace: appends one JSON line per searchContent when enabled" { + const tmp_io = testing.io; + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const tmp_path_len = try tmp.dir.realPathFile(tmp_io, ".", &path_buf); + const tmp_path = path_buf[0..tmp_path_len]; + + const trace_path = try std.fmt.allocPrint(testing.allocator, "{s}/rerank-traces.jsonl", .{tmp_path}); + defer testing.allocator.free(trace_path); + + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + explorer.io = tmp_io; + explorer.rerank_trace_path = trace_path; + + try explorer.indexFile("src/widgetX.zig", "pub fn process() void { _ = widgetX; }\n"); + try explorer.indexFile("src/unrelated.zig", "pub fn process() void { _ = widgetX; }\n"); + + const results = try explorer.searchContent("widgetX", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len >= 2); + + const f = try std.Io.Dir.cwd().openFile(tmp_io, trace_path, .{}); + defer f.close(tmp_io); + const size = try f.length(tmp_io); + try testing.expect(size > 0); + + const data = try testing.allocator.alloc(u8, @intCast(size)); + defer testing.allocator.free(data); + _ = try f.readPositionalAll(tmp_io, data, 0); + + try testing.expectEqual(@as(u8, '\n'), data[data.len - 1]); + var nl_count: usize = 0; + for (data) |c| if (c == '\n') { + nl_count += 1; + }; + try testing.expectEqual(@as(usize, 1), nl_count); + + try testing.expect(std.mem.indexOf(u8, data, "\"query\":\"widgetX\"") != null); + try testing.expect(std.mem.indexOf(u8, data, "src/widgetX.zig") != null); + try testing.expect(std.mem.indexOf(u8, data, "\"results\":[") != null); +} + + +test "rerank-trace: disabled by default — no file is created" { + const tmp_io = testing.io; + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const tmp_path_len = try tmp.dir.realPathFile(tmp_io, ".", &path_buf); + const tmp_path = path_buf[0..tmp_path_len]; + + const probe_path = try std.fmt.allocPrint(testing.allocator, "{s}/should-not-exist.jsonl", .{tmp_path}); + defer testing.allocator.free(probe_path); + + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + explorer.io = tmp_io; + // rerank_trace_path stays null — opt-in only. + + try explorer.indexFile("a.zig", "pub fn t() void { _ = sym; }\n"); + try explorer.indexFile("b.zig", "pub fn t() void { _ = sym; }\n"); + + const results = try explorer.searchContent("sym", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len >= 1); + + const open_err = std.Io.Dir.cwd().openFile(tmp_io, probe_path, .{}); + try testing.expectError(error.FileNotFound, open_err); +} + + +test "rerank-trace: clobbers when file exceeds size limit" { + const tmp_io = testing.io; + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const tmp_path_len = try tmp.dir.realPathFile(tmp_io, ".", &path_buf); + const tmp_path = path_buf[0..tmp_path_len]; + + const trace_path = try std.fmt.allocPrint(testing.allocator, "{s}/big.jsonl", .{tmp_path}); + defer testing.allocator.free(trace_path); + + { + const f = try std.Io.Dir.cwd().createFile(tmp_io, trace_path, .{ .truncate = true }); + defer f.close(tmp_io); + const target_size: u64 = 11 * 1024 * 1024; + var chunk: [4096]u8 = undefined; + @memset(&chunk, 'x'); + var written: u64 = 0; + while (written < target_size) : (written += chunk.len) { + try f.writePositionalAll(tmp_io, &chunk, written); + } + } + + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + explorer.io = tmp_io; + explorer.rerank_trace_path = trace_path; + + try explorer.indexFile("a.zig", "pub fn t() void { _ = sym; }\n"); + try explorer.indexFile("b.zig", "pub fn t() void { _ = sym; }\n"); + + const results = try explorer.searchContent("sym", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + + const f = try std.Io.Dir.cwd().openFile(tmp_io, trace_path, .{}); + defer f.close(tmp_io); + const new_size = try f.length(tmp_io); + try testing.expect(new_size > 0); + try testing.expect(new_size < 16 * 1024); +} + + +test "rerank-trace: single-result query records non-zero rerank score" { + // Pre-fix: rerankAndFinalize only scored when items.len > 1, so a + // single-result trace logged score=0.0 — misleading for offline analysis + // because it looked identical to a zero-confidence match. The fix runs + // scoring unconditionally and only sorts when there's more than one item. + const tmp_io = testing.io; + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const tmp_path_len = try tmp.dir.realPathFile(tmp_io, ".", &path_buf); + const tmp_path = path_buf[0..tmp_path_len]; + + const trace_path = try std.fmt.allocPrint(testing.allocator, "{s}/single.jsonl", .{tmp_path}); + defer testing.allocator.free(trace_path); + + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + explorer.io = tmp_io; + explorer.rerank_trace_path = trace_path; + + // Only one file mentions the query — guarantees results.len == 1. + try explorer.indexFile("src/loneSym.zig", "pub fn loneSym() void {}\n"); + try explorer.indexFile("src/other.zig", "pub fn unrelated() void {}\n"); + + const results = try explorer.searchContent("loneSym", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expectEqual(@as(usize, 1), results.len); + // Symbol-def boost (+5) + basename-substring boost (+8) + per-line freq + // means score is well above zero — verifies scoring actually ran. + try testing.expect(results[0].score > 1.0); + + const f = try std.Io.Dir.cwd().openFile(tmp_io, trace_path, .{}); + defer f.close(tmp_io); + const size = try f.length(tmp_io); + const data = try testing.allocator.alloc(u8, @intCast(size)); + defer testing.allocator.free(data); + _ = try f.readPositionalAll(tmp_io, data, 0); + + try testing.expect(std.mem.indexOf(u8, data, "\"score\":0.0000") == null); + try testing.expect(std.mem.indexOf(u8, data, "src/loneSym.zig") != null); +} + + +test "issue-negq: negative-query search short-circuits Tier 5 full scan" { + // When a query contains trigrams that no indexed file contains (a + // definitively-negative query), searchContent should return [] without + // running the Tier 5 full-scan fallback. On the buggy path Tier 5 fires + // anyway, scanning every outline — measurable as 100ms+ p50 on real + // codebases (see benchmarks/search-shootout, react corpus). + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + // Index enough files that Tier 5 would be observably wasteful if it ran. + var i: usize = 0; + while (i < 50) : (i += 1) { + var buf: [32]u8 = undefined; + const path = try std.fmt.bufPrint(&buf, "file_{d}.zig", .{i}); + try explorer.indexFile(path, "fn process() void { _ = thing; }\n"); + } + + // 'zzqqxxnopematch' — trigrams 'zzq','zqq','qqx',... none of which appear + // in any indexed file. The trigram index can definitively rule this out + // without any content scan. + const results = try explorer.searchContent("zzqqxxnopematch", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.line_text); + testing.allocator.free(r.path); + } + testing.allocator.free(results); + } + + try testing.expectEqual(@as(usize, 0), results.len); + // The fix: Tier 5 must NOT fire when the trigram index has already + // ruled out a match. On main this expectation fails (count == 1). + try testing.expectEqual(@as(u64, 0), explorer.search_tier5_count); +} + + +test "issue-471a: codedb_find accepts query/name/path/pattern/q aliases" { + // Real-user telemetry (24h) showed 71% of codedb_find calls failing with + // "missing 'query'" because agents passed the search term under `name`, + // `path`, `pattern`, or `q` (misled by the "FILE-NAME search" framing in + // the tool description). Regression: every common alias must succeed. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + try explorer.indexFile("src/auth_middleware.go", "package auth\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const aliases = [_][]const u8{ "query", "name", "path", "pattern", "q" }; + for (aliases) |key| { + const bundle_json = try std.fmt.allocPrint( + testing.allocator, + "{{\"ops\":[{{\"tool\":\"codedb_find\",\"arguments\":{{\"{s}\":\"main\"}}}}]}}", + .{key}, + ); + defer testing.allocator.free(bundle_json); + + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + // Every alias must succeed: no "missing" error, and the matching + // file must appear in the response. + if (std.mem.indexOf(u8, out.items, "missing 'query'") != null) { + std.debug.print("alias '{s}' failed with: {s}\n", .{ key, out.items }); + return error.AliasRejected; + } + try testing.expect(std.mem.indexOf(u8, out.items, "main.zig") != null); + } +} + + +test "issue-471b: codedb_find error message enumerates accepted aliases" { + // If an agent calls codedb_find with no recognized key, the error message + // must enumerate the accepted aliases so the agent can self-correct on + // the next call instead of repeating the same broken call. + var explorer = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer explorer.deinit(); + try explorer.indexFile("src/main.zig", "pub fn main() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + _ = try agents.register("__filesystem__"); + + var bench_ctx = mcp_mod.BenchContext.init(testing.allocator, ".", Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer bench_ctx.deinit(); + + const bundle_json = + \\{"ops":[{"tool":"codedb_find","arguments":{"bogus":"main"}}]} + ; + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, bundle_json, .{}); + defer parsed.deinit(); + + var out: std.ArrayList(u8) = .empty; + defer out.deinit(testing.allocator); + bench_ctx.runDispatch(io, testing.allocator, .codedb_bundle, &parsed.value.object, &out, &store, &explorer, &agents); + + // Error must enumerate the alias list so the agent can self-correct. + try testing.expect(std.mem.indexOf(u8, out.items, "missing 'query'") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "name") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "path") != null); + try testing.expect(std.mem.indexOf(u8, out.items, "pattern") != null); +} + diff --git a/src/test_snapshot.zig b/src/test_snapshot.zig new file mode 100644 index 0000000..e12b22a --- /dev/null +++ b/src/test_snapshot.zig @@ -0,0 +1,714 @@ +const std = @import("std"); +const cio = @import("cio.zig"); +const testing = std.testing; +const io = std.testing.io; +const Store = @import("store.zig").Store; +const Explorer = @import("explore.zig").Explorer; +const explore = @import("explore.zig"); +const Language = explore.Language; +const SymbolKind = explore.SymbolKind; +const WordIndex = @import("index.zig").WordIndex; +const TrigramIndex = @import("index.zig").TrigramIndex; +const SparseNgramIndex = @import("index.zig").SparseNgramIndex; +const snapshot_mod = @import("snapshot.zig"); +const snapshot_json = @import("snapshot_json.zig"); +const watcher = @import("watcher.zig"); +const git_mod = @import("git.zig"); +const AgentRegistry = @import("agent.zig").AgentRegistry; +const edit_mod = @import("edit.zig"); + + +test "issue-35: edits immediately update explorer and snapshot output" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const rel_path = try std.fmt.allocPrint(testing.allocator, ".zig-cache/tmp/{s}/edit-live-sync.zig", .{tmp.sub_path}); + defer testing.allocator.free(rel_path); + + var file = try tmp.dir.createFile(io, "edit-live-sync.zig", .{}); + defer file.close(io); + try file.writeStreamingAll(io, "pub fn oldName() void {}\n"); + + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var explorer = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile(rel_path, "pub fn oldName() void {}\n"); + + var store = Store.init(testing.allocator); + defer store.deinit(); + _ = try store.recordSnapshot(rel_path, "pub fn oldName() void {}\n".len, std.hash.Wyhash.hash(0, "pub fn oldName() void {}\n")); + + var agents = AgentRegistry.init(testing.allocator); + defer agents.deinit(); + const agent_id = try agents.register("issue-35-agent"); + + const before_snap = try snapshot_json.buildSnapshot(&explorer, &store, testing.allocator); + defer testing.allocator.free(before_snap); + try testing.expect(std.mem.indexOf(u8, before_snap, "oldName") != null); + + _ = try edit_mod.applyEdit(io, testing.allocator, &store, &agents, &explorer, .{ + .path = rel_path, + .agent_id = agent_id, + .op = .replace, + .range = .{ 1, 1 }, + .content = "pub fn newName() void {}", + }); + + const new_results = try explorer.searchContent("newName", testing.allocator, 10); + defer { + for (new_results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(new_results); + } + try testing.expect(new_results.len == 1); + + const old_results = try explorer.searchContent("oldName", testing.allocator, 10); + defer { + for (old_results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(old_results); + } + try testing.expect(old_results.len == 0); + + const after_snap = try snapshot_json.buildSnapshot(&explorer, &store, testing.allocator); + defer testing.allocator.free(after_snap); + try testing.expect(std.mem.indexOf(u8, after_snap, "newName") != null); + try testing.expect(std.mem.indexOf(u8, after_snap, "oldName") == null); +} + + +test "snapshot_json: snapshot builds and is valid JSON" { + // Explorer uses arena for internal data + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + var explorer = Explorer.init(alloc, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try explorer.indexFile("src/main.zig", "pub fn main() void {}"); + try explorer.indexFile("src/lib.zig", "pub const version = 1;"); + + var store = @import("store.zig").Store.init(alloc); + defer store.deinit(); + _ = try store.recordSnapshot("src/main.zig", 100, 0xABC); + + const snap = try snapshot_json.buildSnapshot(&explorer, &store, testing.allocator); + defer testing.allocator.free(snap); + + // Must be valid JSON + const parsed = try std.json.parseFromSlice(std.json.Value, testing.allocator, snap, .{}); + defer parsed.deinit(); + + // Must have expected top-level keys (matches buildSnapshot output) + try testing.expect(parsed.value.object.contains("seq")); + try testing.expect(parsed.value.object.contains("tree")); + try testing.expect(parsed.value.object.contains("outlines")); + try testing.expect(parsed.value.object.contains("symbol_index")); + try testing.expect(parsed.value.object.contains("dep_graph")); + + const tree = parsed.value.object.get("tree").?.string; + try testing.expect(std.mem.indexOf(u8, tree, "src/") != null); + try testing.expect(std.mem.indexOf(u8, tree, "main.zig") != null); + + const symbol_index = parsed.value.object.get("symbol_index").?.object; + try testing.expect(symbol_index.contains("main")); + try testing.expect(symbol_index.contains("version")); +} + + +test "issue-44: snapshot stale after working tree changes cause stale query results" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/test.snapshot", .{dir_path}); + defer testing.allocator.free(snap_path); + const file_abs = try std.fmt.allocPrint(testing.allocator, "{s}/stale.zig", .{dir_path}); + defer testing.allocator.free(file_abs); + + // Step 1: write file with old content, index it, write snapshot. + try tmp.dir.writeFile(io, .{ .sub_path = "stale.zig", .data = "pub fn oldFunc() void {}" }); + { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp.indexFile(file_abs, "pub fn oldFunc() void {}"); + try snapshot_mod.writeSnapshot(io, &exp, ".", snap_path, arena.allocator()); + } + + // Step 2: modify file AFTER snapshot creation (simulating uncommitted working tree change). + // Sleep 10ms so the file mtime is strictly greater than the snapshot's indexed_at timestamp. + cio.sleepMs(10); + try tmp.dir.writeFile(io, .{ .sub_path = "stale.zig", .data = "pub fn newFunc() void {}" }); + + // Step 3: load snapshot into a fresh explorer (what MCP startup does). + // scan_done is set to true immediately; watcher then builds known-FileMap + // from current disk mtimes, recording the already-modified file's mtime as + // the baseline. It will never be re-indexed unless changed a second time. + var arena2 = std.heap.ArenaAllocator.init(testing.allocator); + defer arena2.deinit(); + var exp2 = Explorer.init(arena2.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store2 = Store.init(testing.allocator); + defer store2.deinit(); + + const loaded = snapshot_mod.loadSnapshot(io, snap_path, &exp2, &store2, arena2.allocator()); + try testing.expect(loaded); + + // Step 4: after the fix, loadSnapshot should detect that the disk file's + // mtime > snapshot indexed_at and re-index it from disk, making "newFunc" + // visible. Currently no such path exists. + // Expected (after fix): results.len == 1 + // Current (bug): results.len == 0 — stale snapshot content is never evicted. + const results = try exp2.searchContent("newFunc", testing.allocator, 10); + defer { + for (results) |r| { + testing.allocator.free(r.path); + testing.allocator.free(r.line_text); + } + testing.allocator.free(results); + } + try testing.expect(results.len == 1); +} + + +test "issue-46: empty-repo snapshot rejected on load" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/test.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, testing.allocator); + + var arena2 = std.heap.ArenaAllocator.init(testing.allocator); + defer arena2.deinit(); + var exp2 = Explorer.init(arena2.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store = Store.init(testing.allocator); + defer store.deinit(); + + const loaded = snapshot_mod.loadSnapshot(io, snap_path, &exp2, &store, testing.allocator); + try testing.expect(!loaded); + try testing.expect(exp2.outlines.count() == 0); +} + + +test "issue-220: snapshot fast load restores outlines and lazily rebuilds word index" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const aa = arena.allocator(); + + var exp = Explorer.init(aa, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp.indexFile("src/store.zig", "pub const Store = struct {};\n"); + try exp.indexFile("src/main.zig", "const Store = @import(\"store.zig\").Store;\npub fn main() void {}\n"); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/fast.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, testing.allocator); + + var arena2 = std.heap.ArenaAllocator.init(testing.allocator); + defer arena2.deinit(); + var exp2 = Explorer.init(arena2.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store = Store.init(testing.allocator); + defer store.deinit(); + + const loaded = snapshot_mod.loadSnapshot(io, snap_path, &exp2, &store, arena2.allocator()); + try testing.expect(loaded); + try testing.expectEqual(@as(usize, 2), exp2.outlines.count()); + try testing.expectEqual(@as(u32, 0), exp2.trigram_index.fileCount()); + try testing.expectEqual(@as(usize, 0), exp2.word_index.index.count()); + try testing.expect(exp2.wordIndexCanLoadFromDisk()); + try testing.expect(!exp2.wordIndexIsComplete()); + try testing.expect(!exp2.wordIndexNeedsPersist()); + + const deps = try exp2.getImportedBy("src/store.zig", testing.allocator); + defer { + for (deps) |dep| testing.allocator.free(dep); + testing.allocator.free(deps); + } + try testing.expectEqual(@as(usize, 1), deps.len); + try testing.expect(std.mem.eql(u8, deps[0], "src/main.zig")); + + const hits = try exp2.searchWord("Store", testing.allocator); + defer testing.allocator.free(hits); + try testing.expect(hits.len >= 1); + try testing.expect(exp2.word_index.index.count() > 0); + try testing.expect(exp2.wordIndexIsComplete()); + try testing.expect(exp2.wordIndexNeedsPersist()); +} + + +test "snapshot: writer streams uncached file contents for large repos" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + try tmp.dir.createDirPath(io, "src"); + + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + var rel_buf: [64]u8 = undefined; + var content_buf: [128]u8 = undefined; + for (0..1002) |i| { + const rel = try std.fmt.bufPrint(&rel_buf, "src/file_{d}.zig", .{i}); + const content = try std.fmt.bufPrint(&content_buf, "pub fn func_{d}() usize {{ return {d}; }}\n", .{ i, i }); + try tmp.dir.writeFile(io, .{ .sub_path = rel, .data = content }); + try exp.indexFileOutlineOnly(rel, content); + } + + try testing.expectEqual(@as(usize, 1002), exp.outlines.count()); + // With CLOCK eviction (#208) the ContentCache holds up to 16384 entries — all 1002 fit. + try testing.expectEqual(@as(u32, 1002), exp.contents.count()); + + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/large.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, testing.allocator); + + var loaded_without_root = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer loaded_without_root.deinit(); + var store_without_root = Store.init(testing.allocator); + defer store_without_root.deinit(); + + try testing.expect(snapshot_mod.loadSnapshot(io, snap_path, &loaded_without_root, &store_without_root, testing.allocator)); + try testing.expectEqual(@as(usize, 1002), loaded_without_root.outlines.count()); + // CLOCK cache holds all 1002 — word index can be rebuilt from memory without root dir. + const hits_no_root = try loaded_without_root.searchWord("func_1001", testing.allocator); + defer testing.allocator.free(hits_no_root); + try testing.expectEqual(@as(usize, 1), hits_no_root.len); + + var loaded = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + loaded.setRoot(io, dir_path); + defer loaded.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + + try testing.expect(snapshot_mod.loadSnapshot(io, snap_path, &loaded, &store, testing.allocator)); + try testing.expectEqual(@as(usize, 1002), loaded.outlines.count()); + + const hits = try loaded.searchWord("func_1001", testing.allocator); + defer testing.allocator.free(hits); + try testing.expectEqual(@as(usize, 1), hits.len); + try testing.expectEqualStrings("src/file_1001.zig", loaded.word_index.hitPath(hits[0])); + try testing.expect(loaded.wordIndexIsComplete()); +} + + +test "issue-220: partial word index state rebuilds before search" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + try exp.indexFile("src/a.zig", "pub const Alpha = 1;\n"); + try exp.indexFile("src/b.zig", "pub const Beta = 2;\n"); + + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/partial.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, testing.allocator); + + var exp2 = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp2.deinit(); + var store = Store.init(testing.allocator); + defer store.deinit(); + + try testing.expect(snapshot_mod.loadSnapshot(io, snap_path, &exp2, &store, testing.allocator)); + try testing.expect(exp2.wordIndexCanLoadFromDisk()); + try testing.expect(!exp2.wordIndexIsComplete()); + + try exp2.indexFileSkipTrigram("src/b.zig", "pub const Gamma = 3;\n"); + try testing.expect(!exp2.wordIndexCanLoadFromDisk()); + try testing.expect(!exp2.wordIndexIsComplete()); + + const alpha_hits = try exp2.searchWord("Alpha", testing.allocator); + defer testing.allocator.free(alpha_hits); + try testing.expectEqual(@as(usize, 1), alpha_hits.len); + try testing.expect(std.mem.eql(u8, exp2.word_index.hitPath(alpha_hits[0]), "src/a.zig")); + + const gamma_hits = try exp2.searchWord("Gamma", testing.allocator); + defer testing.allocator.free(gamma_hits); + try testing.expectEqual(@as(usize, 1), gamma_hits.len); + try testing.expect(std.mem.eql(u8, exp2.word_index.hitPath(gamma_hits[0]), "src/b.zig")); + try testing.expect(exp2.wordIndexIsComplete()); + try testing.expect(exp2.wordIndexNeedsPersist()); +} + + +test "issue-220: word index persistence tracking skips redundant rewrites" { + var exp = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp.deinit(); + + try exp.indexFile("src/a.zig", "pub const Alpha = 1;\n"); + try testing.expect(exp.wordIndexIsComplete()); + try testing.expect(exp.wordIndexNeedsPersist()); + + const first_gen = exp.wordIndexGenerationToPersist() orelse return error.TestUnexpectedResult; + exp.markWordIndexPersisted(first_gen); + try testing.expect(!exp.wordIndexNeedsPersist()); + try testing.expect(exp.wordIndexGenerationToPersist() == null); + + try exp.indexFile("src/a.zig", "pub const Beta = 2;\n"); + try testing.expect(exp.wordIndexNeedsPersist()); + + const second_gen = exp.wordIndexGenerationToPersist() orelse return error.TestUnexpectedResult; + try testing.expect(second_gen != first_gen); + exp.markWordIndexPersisted(first_gen); + try testing.expect(exp.wordIndexNeedsPersist()); + exp.markWordIndexPersisted(second_gen); + try testing.expect(!exp.wordIndexNeedsPersist()); +} + + +test "issue-45: snapshot written in non-git directory cannot be loaded" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const aa = arena.allocator(); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + var exp = Explorer.init(aa, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp.indexFile("dummy.zig", "const x = 1;"); + + const snap_path = try std.fs.path.join(aa, &.{ dir_path, "test.codedb" }); + + // Write snapshot with a non-git root_path — git_head will be all-zeros + try snapshot_mod.writeSnapshot(io, &exp, "/tmp", snap_path, aa); + + // Snapshot file was created + std.Io.Dir.cwd().access(io, snap_path, .{}) catch { + return error.TestUnexpectedResult; + }; + + // readSnapshotGitHead returns null for non-git dirs (all-zero sentinel). + // The snapshot loading logic in main.zig handles this by checking if the + // current project also has no git — if so, it loads the snapshot. + const snap_head = snapshot_mod.readSnapshotGitHead(io, snap_path); + try testing.expect(snap_head == null); +} + + +test "issue-47: concurrent snapshot writes from parallel instances corrupt file" { + // BUG: Two codedb instances indexing the same repo write codedb.snapshot + // concurrently with no file locking. The second writer can overwrite a + // partially-written snapshot, producing a corrupt file that loadSnapshot + // rejects or — worse — reads garbage section offsets from. + // + // Simulate: two threads write snapshots to the same path concurrently, + // then verify the final file is still loadable. + var arena1 = std.heap.ArenaAllocator.init(testing.allocator); + defer arena1.deinit(); + var arena2 = std.heap.ArenaAllocator.init(testing.allocator); + defer arena2.deinit(); + + var exp1 = Explorer.init(arena1.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp1.indexFile("a.zig", "pub fn alpha() void {}"); + var exp2 = Explorer.init(arena2.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp2.indexFile("b.zig", "pub fn beta() void {}"); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/concurrent.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + + const WriterCtx = struct { + exp: *Explorer, + path: []const u8, + dir: []const u8, + alloc: std.mem.Allocator, + failed: std.atomic.Value(bool) = std.atomic.Value(bool).init(false), + + fn run(ctx: *@This()) void { + for (0..10) |_| { + snapshot_mod.writeSnapshot(io, ctx.exp, ctx.dir, ctx.path, ctx.alloc) catch { + ctx.failed.store(true, .release); + return; + }; + } + } + }; + + var ctx1 = WriterCtx{ .exp = &exp1, .path = snap_path, .dir = dir_path, .alloc = arena1.allocator() }; + var ctx2 = WriterCtx{ .exp = &exp2, .path = snap_path, .dir = dir_path, .alloc = arena2.allocator() }; + + const t1 = try std.Thread.spawn(.{}, WriterCtx.run, .{&ctx1}); + const t2 = try std.Thread.spawn(.{}, WriterCtx.run, .{&ctx2}); + t1.join(); + t2.join(); + + // Neither writer should have errored + try testing.expect(!ctx1.failed.load(.acquire)); + try testing.expect(!ctx2.failed.load(.acquire)); + + // The final snapshot must be loadable (not corrupt) + var arena3 = std.heap.ArenaAllocator.init(testing.allocator); + defer arena3.deinit(); + var exp3 = Explorer.init(arena3.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store3 = Store.init(testing.allocator); + defer store3.deinit(); + const loaded = snapshot_mod.loadSnapshot(io, snap_path, &exp3, &store3, arena3.allocator()); + + // Expected: loaded == true (snapshot is valid, written atomically) + // Current (bug): may be false — last writer's rename can land mid-write of + // the first writer's tmp file, or both rename the same .tmp path. + try testing.expect(loaded); +} + + +test "issue-42: scan thread is joined before allocator-backed state is freed" { + var gpa = std.heap.DebugAllocator(.{}){}; + const allocator = gpa.allocator(); + + const data_dir = try allocator.dupe(u8, "/tmp/codedb_test_issue42"); + + const SharedCtx = struct { + data_dir: []const u8, + done: std.atomic.Value(bool) = std.atomic.Value(bool).init(false), + ok: std.atomic.Value(bool) = std.atomic.Value(bool).init(false), + + fn run(ctx: *@This()) void { + cio.sleepMs(10); + if (ctx.data_dir.len > 0) { + _ = ctx.data_dir[0]; + ctx.ok.store(true, .release); + } + ctx.done.store(true, .release); + } + }; + + var ctx = SharedCtx{ .data_dir = data_dir }; + const t = try std.Thread.spawn(.{}, SharedCtx.run, .{&ctx}); + t.join(); + + try testing.expect(ctx.done.load(.acquire)); + try testing.expect(ctx.ok.load(.acquire)); + allocator.free(data_dir); + _ = gpa.deinit(); +} + + +test "issue-40: truncated snapshot silently loads partial data" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try exp.indexFile("src/a.zig", "const a = 1;\n"); + try exp.indexFile("src/b.zig", "const b = 2;\n"); + try exp.indexFile("src/c.zig", "const c = 3;\n"); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/test.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, testing.allocator); + + const trunc_path = try std.fmt.allocPrint(testing.allocator, "{s}/trunc.codedb", .{dir_path}); + defer testing.allocator.free(trunc_path); + { + const orig = try std.Io.Dir.cwd().readFileAlloc(io, snap_path, testing.allocator, .limited(1024 * 1024)); + defer testing.allocator.free(orig); + const trunc_file = try std.Io.Dir.cwd().createFile(io, trunc_path, .{}); + defer trunc_file.close(io); + // Keep only header (256 bytes) — content section data will be missing + try trunc_file.writeStreamingAll(io, orig[0..@min(256, orig.len)]); + } + + var arena2 = std.heap.ArenaAllocator.init(std.heap.page_allocator); + defer arena2.deinit(); + var exp2 = Explorer.init(arena2.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store = Store.init(arena2.allocator()); + + const loaded = snapshot_mod.loadSnapshot(io, trunc_path, &exp2, &store, arena2.allocator()); + try testing.expect(!loaded); +} + + +test "issue-41: snapshot not validated against repo identity allows cross-project loading" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + var exp = Explorer.init(arena.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + try exp.indexFile("src/projectA.zig", "const project = \"A\";\n"); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/test.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, testing.allocator); + + var arena2 = std.heap.ArenaAllocator.init(testing.allocator); + defer arena2.deinit(); + var exp2 = Explorer.init(arena2.allocator(), Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + var store = Store.init(testing.allocator); + defer store.deinit(); + + const loaded = snapshot_mod.loadSnapshotValidated(io, snap_path, "/some/other/project", &exp2, &store, testing.allocator); + try testing.expect(!loaded); +} + + +test "snapshot: symbol detail longer than 4096 bytes survives round-trip" { + // Regression for readSectionString rejecting names/details > 4096 bytes. + // Before the fix max_len was 4096; any detail longer than that triggered + // error.InvalidData and loadSnapshot returned false. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const aa = arena.allocator(); + + // Build a Zig source whose first function line exceeds 4 096 characters. + var src: std.ArrayList(u8) = .empty; + defer src.deinit(testing.allocator); + try src.appendSlice(testing.allocator, "pub fn bigSig("); + var param_i: usize = 0; + while (src.items.len < 5000) : (param_i += 1) { + var pb: [20]u8 = undefined; + const ps = std.fmt.bufPrint(&pb, "p{d}: u8, ", .{param_i}) catch break; + try src.appendSlice(testing.allocator, ps); + } + try src.appendSlice(testing.allocator, ") void {}\n"); + try testing.expect(src.items.len > 4096); // guard: ensure we actually generated a long line + var exp = Explorer.init(aa, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp.indexFile("src/big.zig", src.items); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/big.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, testing.allocator); + + var exp2 = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp2.deinit(); + var store2 = Store.init(testing.allocator); + defer store2.deinit(); + + const loaded = snapshot_mod.loadSnapshot(io, snap_path, &exp2, &store2, testing.allocator); + try testing.expect(loaded); // must survive long detail + + var sym_arena = std.heap.ArenaAllocator.init(testing.allocator); + defer sym_arena.deinit(); + const results = try exp2.findAllSymbols("bigSig", sym_arena.allocator()); + try testing.expect(results.len >= 1); +} + + +test "snapshot: corrupted OUTLINE_STATE section falls back to CONTENT load" { + // Regression for the codedb 0.2.56 writer u16 overflow bug: when OUTLINE_STATE + // contains a detail that overflows u16 the section cursor de-syncs, making + // subsequent file records parse as garbage and loadOutlineStateMap throws. + // The catch fallback must produce an empty map so loadSnapshotFast falls + // through to indexFileOutlineOnly for every file in CONTENT. + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const aa = arena.allocator(); + + var exp = Explorer.init(aa, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + try exp.indexFile("src/a.zig", "pub fn aFunc() void {}\n"); + try exp.indexFile("src/b.zig", "pub fn bFunc() void {}\n"); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/corrupt.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, testing.allocator); + + // Overwrite the first 16 bytes of OUTLINE_STATE data with 0xFF. + // This makes the file_count field read as 0xFFFFFFFF — far more records + // than the data contains — causing readSectionString to eventually fail + // with error.InvalidData (runs off the end of the bytes slice). + { + var sections = (try snapshot_mod.readSections(io, snap_path, testing.allocator)).?; + defer sections.deinit(); + const ols = sections.get(@intFromEnum(snapshot_mod.SectionId.outline_state)) orelse return; + const f = try std.Io.Dir.cwd().openFile(io, snap_path, .{ .mode = .read_write }); + defer f.close(io); + try f.writePositionalAll(io, &([_]u8{0xFF} ** 16), ols.offset); + } + + var exp2 = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp2.deinit(); + var store2 = Store.init(testing.allocator); + defer store2.deinit(); + + const loaded = snapshot_mod.loadSnapshot(io, snap_path, &exp2, &store2, testing.allocator); + try testing.expect(loaded); // must survive OUTLINE_STATE corruption + + // Symbols must still be found — re-indexed from CONTENT + var sym_arena = std.heap.ArenaAllocator.init(testing.allocator); + defer sym_arena.deinit(); + const results = try exp2.findAllSymbols("aFunc", sym_arena.allocator()); + try testing.expect(results.len >= 1); +} + + +test "issue-379: snapshot loader returns true with zero outlines for empty-explorer snapshot" { + var arena = std.heap.ArenaAllocator.init(testing.allocator); + defer arena.deinit(); + const aa = arena.allocator(); + + var exp = Explorer.init(aa, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var path_buf: [std.fs.max_path_bytes]u8 = undefined; + const dir_path_len = try tmp.dir.realPathFile(io, ".", &path_buf); + const dir_path = path_buf[0..dir_path_len]; + const snap_path = try std.fmt.allocPrint(testing.allocator, "{s}/empty.codedb", .{dir_path}); + defer testing.allocator.free(snap_path); + + try snapshot_mod.writeSnapshot(io, &exp, dir_path, snap_path, testing.allocator); + + var exp2 = Explorer.init(testing.allocator, Explorer.DEFAULT_CONTENT_CACHE_CAPACITY); + defer exp2.deinit(); + var store2 = Store.init(testing.allocator); + defer store2.deinit(); + + const loaded = snapshot_mod.loadSnapshot(io, snap_path, &exp2, &store2, testing.allocator); + if (loaded) { + try testing.expect(exp2.outlines.count() > 0); + } +} + From 2ca64acf243782d039a21195475c00c0bf2277b5 Mon Sep 17 00:00:00 2001 From: justrach <54503978+justrach@users.noreply.github.com> Date: Sun, 24 May 2026 15:19:12 +0800 Subject: [PATCH 6/7] =?UTF-8?q?release:=20v0.2.5818=20=E2=80=94=20MCP=20st?= =?UTF-8?q?ability=20+=20issue-44=20+=20security=20+=20correctness=20fixes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 4.7 (1M context) --- codedb.snapshot | Bin 132865 -> 3227967 bytes src/release_info.zig | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/codedb.snapshot b/codedb.snapshot index 466b0a96e9c4033a7c695f997591964b2880c702..49a7b5ca0a7862f8832dc61fcd78e6a7c7ebaf6a 100644 GIT binary patch literal 3227967 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∾NoHh%!@y;&_pFDfvnJ49pwbue; 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

8>LWwtCsep!p-weNiDPk^Zu1Y|KIefptnD(}u=G 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

c7!6j? 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%0A<3Al7kL*%Kq9ETcg~je;?=hB09D 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 #gHDJ16l%FkmG_ zYE~nJf@B=?=K88kRGe#J8d=e0v)40HNF~ZpNIe3Ma}gTGcLlj$Na;w5$WC9DHsmpo z)q{sDx)g1PqeFSO5JPZ&f|_*430{i}V{@kIUTa|zhK!i&&O%2qL1pyWCtO&R--ev9m=o*!fSet_!>}6Dlh2qhKh}J|tTjP#>J`a-h1k z*$m17%cCeIy*OwsLrECL*`zg!W%E3Ahxj4M5rf{q+%5;Koq_xinD{{3;L#8j7+cD* zehe)ir(tTVdBEdfIue^OpRgyw1)c0Nkp({+A=S|t^@Xa}sBC@9j})$u%wf3ppN1No zN}FjnEj^dLeMjz_rzwDtsyLhPn@kC7utGq7g=^>M*iE0{{Fx_P>hhK zCZDOpDmqe#WZaq!Ul538&$As&x|*!v3yiC{76pCk>vZL|FTIflp?Qh*zCi56MTF-7 zM0h?%S&B_|={p!;y29l_<$RXuoUPZCJ3BOgo5X!Lx7O3R?^>*E6XZM%2*L2g0KMXV7{ zqkvzu8$!hB$Jd?x^JSv_uOPdQMGS50fqdgqzA3|FK^Wn>G`x8g6ol1R!c)NvQNoYT zF)}E0$dhs!MbOU?C-e+No|>2E7644?*D6>{&ipvW`?&x(Rh2>K8O4BjGj>)nl(t*J ze$9bsqTnB?3Pou&q!%>;sum#Kpzl#_&X>iHgwGrv4+@!Z_9K>-z*f{Z*xb)D}j~~skSc8cnl~yo!Fj2-6o4~tB zF7zEV6S^w|iy#B6e1sQ7L&>a_lis+|4$BZ$z_DXQ9B*cTl@l^du z^ayr2oPx?C1y0UWsM%3sZ9Jx-L3Y|dHSw!lpQqyV!B}LBdr_~~Mb$dK$REQAE0mI( z18xpZdZ&a@2z1ND1?EEx8zP>Bm@*H$WRJ-^Cg0+)Af03IT@Q7HPqvs2AX&46xNOvgOMCfI^gU{PD8AFBzM=E8Yed0rSm z7Jvp+(FzaW)Or6Tn2c@ZnP8gRgw|-z`T9_7XyJ!J!zWpxmZic{Ier+v2M2^E?u3&f z?xx`LsqGOvY}Gn}_WdkS42y9kr;O1)nm}n9Ng{0?en0m3c=`FGN6=?vOge=C?Q%evpM((X$GM#k|LGgxn*-tl|%5fntL6fqLW>26wE(Uk=F-sy;v> z*2DsVDeN{_%S}a%fb&H0aZeO9%UA7vfuMSoY(RySFK9EWXqETs#}^�OEOZv+IR) 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%0DdjYH)EsCW*ficTV2)A?brcF@oQ#>Ikd0jQ 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≪;fm`qL>@!gr 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

R8-iFON`;tkz0Z(sY~xItn)wQJw7b< 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%0A5^o#8weh*8M_vNT7ic z`-60VEtPjfiSP}UlP9`T#5~O2zP)&cM$dP+BD%73RpzaHjgM9F_Mf)7EZ^(D3;qeT zN-kzyGZN%TY~e0u^G0GTBPf|?2v^41N==jy7a5 zR11qKWxUtWU}4c0%sW_s90N|R!X405KW0)3YXQ?~xiuf`VhmP`mkGf>86$m;y4}W2 z-!bs|s<1!38FdQ(SQY{0FnQwufTJS9j-A#ARdKr~>jDJqL+w06G zLgj(ERQt#S6LYKtWPt=#iRIA|ClsWGT_5nrLo_GH3hGSs%Y4bRt9;3U0&C{fP=m|l zjoR%h1kQjbOGG9eC2hXVdXD!CR;#{Zut06(a|)jrwB><<)ms)m1Ih%CP+gPcO(C|B z;28*WgwCE`1unk94a=K7XR#8AC2s3pQ2{t;?N)Yx>^3++mr+k+u#6O1)W^t{x7Iq@ z5Z#Xsj>nz7L3h7{RN*uWWqdn7JlXuIg>0PF_P=DvZTYKv_uj*tt;snxm^)(I@(};j z7=_2t8kP%(@a$xW{=qko>!Ejc@!M#bA;A|s__V*1jvlj)9`|BG%nG)-M{clouA5*;$>I(}P%b>%$1DoXzzaOF~E;389tWBh{J=-Zqj(QTo-FJ42& zDaEl^Tx0ByY94#6cah8y18fF3wo8w&`{M*#JJRG3jS1kYJWj+(iPEcMWQ6XeyQj!1 zOLjzxl5c!?XT-TW9-QhJEBwM(+_7>kdA;kp;AAT+%Xu=e}L!j3l-2brl zQEis(LUc1^DDWTARsVng-aV=(mBktost++>ZEK~2cl`-r!ymeM@t|;|3^-Emc!p-E z*$>ctIJl}@WeP6;IvGms+vtpJ*hf3wadZUc?w~sqAfltB1q%HmV>crjHsTl^y9f9l z*to{#V*I`K~vTWeo_-h`L1zu({K572;}g(0vE z!0sCqZDb4U6WCvAPcR57Ai)keY!X2r713+r7_PA=ZBxaGf;%^)d*kd;2Obh`n!Z!O zhAjz*%U9t7Hv{5=xWEj8hW#{*zMYKv$H*K-Kwjn^E-(!H!RaNCgj)_Q_wMo_t^|&b zULayaqxl@}d>AgyxszKEbG{_=KyRUgi18;Fu?P0-@3r

;o6{tT+t25EtgRVJ{hU zU;lU_%IF!=g|G~L9$+M&GV45*0%N?qzdzxreQd;%T^I8)U4?!@CM>ufEC@fQVaFWl zTP^aB6~<|yR~RNo(E3@v)rHyqU^`4)K*V-_q3{_tCcc2x_kH$~X*rVt#M}7rQi$DV ziJpU-G2>nr89G2qy6?bjG(2<)W!R0bfP-V~U7V}&7T~EXlT@1;E+naydE_JD7#IeQ zDFOv2-&hs%;H6N~$ySybCYQHm#+`!{lfLK=-tEH@ig7Tpv*a(4#rfdOTy_}-H>R6x z8ZbHsg>Q$=90_Z%!W{WQtVXWRmXS^S1^)W{k?H+rupq>iMq7;?L@SfG+Qk0cGs-GjKeO*c)L0^DyNYP$ymZ^oZvDno3hDK`XeA7mwW^{ z1ICyO$d_lf8&G9e0$NErVU|f!H@8YjmSir{Nf#@C>@Cf+-bG-0&>?9tNN4=^xMORU zyR+c><`_Ckww2_DEt~U*W!uCDzFQwYF*}Bh^2nWM;AGOzxENz8g%*6;*qM)l2iTmz z&$?Jg(F2?}pXCyUTrWBkV zwwbkJpq-6cNnXuZ(|KV37+Vy2DYiBat^%GLP-lk4)k2i7+0)VJcm(G&gI3~oqQSug zQ&?|QOiwXO9AII%dsx9MII`^lO?yQvYDY-0U^+64owh=a0OPvAH?P~Q*2EBZM& zo|?t#CF}3Q$%OTuas!GeKxV`*#}X@8U!y#NhA0yHz>^=@%jOTSaokDHk^KUr{?Dr>H_6iO3A{vnee?Ps93H z{W3^<2o73q%VF`F7C(pq)*plJaAajtwqdM7OPUx@(8)d&x?~64lk~jk&z{{b0le9s z5d@Js{D=y#I1C>L-_`-tS>QHt&MB(o&$3+6CygWlPD;pffK!|bsh8BHig^d&!;pef z2b*JYgxI69b36(FFV07O3|46}NiagmHu);ntDPW{V$^~|&gV+JHL(9whOj|}0sco9 zq!9u;y``Y{*;ygUx~CafwLj=}j=DpXfkG|!v_zKp6p%nyW8`63pK|E_30%MM+A3`$ z4JOnxrnwB>*P~^whuNuG^2Nk*4$dBQu42cE6sTN;I)q_FRn`GB*d9O?B>O*uD+FIjhqpnBTAs6a7LA zeU?y@U&*tqWQ70&!gSq9)<>Hyu^qcPZBT6wEG}NYbLo;bh!etfr~=#TU3|wg)&VhCZ?C(IMr}$H+U@6C$3R)~?bA(+jeH%N)AWfR zrOeOh@50R&kq$ZTAT@L+TOA)^YKN}{<^7f^q-y%g)fXr0m1{jC(uF8m@f%Pe%L~V^ zlR7HjB>(tLJ!!n@lc^Egr!XSC-$jZR!qZEfMe6^?(`4s3&OE@h&o!|~H*%>4y(JOu zUVl%j=do}nfgZD~H(3Uyi4O9W2_5aF#A_=4wxpElk+M=+=hFu) zYs<7(6`Vz>b`|>2WTl{;9f{s3qOqBla}pRT(o=Zdu;LR7YD)m~9Y+HAj1`oW;5N2-++|5it^obC-!AstqEbd*L z0Cz!iA&H~nYa$UPGc_hn}oBKW;|*B4X7boe28vrG*>XaSb7*Y zM8}y?oG2q^G&zh86?|-p>Oy>6Sy#Ud4hIxfL2V3_%RGUDflepPn7!89F1%aBz@7*! ziJ~F#G)hH7wlsqb3vMtufQ6Qal@yVr!MBV(CA!EHgIK2wlM-R<*rw1rtyS0!nr|a<>sF$9s zLr6uNXl2?r`&uRj{>pxa;x7p=TZQ{FDG0X*^Gz{)WG~71K$R%5hgX%$tdh86`U77N zP$(jjHnCmI6$9LpYTtM_F+&6;`lvo)Xl^YY zSiPK{F+8tG&&))abDa9FtBii8T@nQvFfqJfB;p&o`B)l+k%;wmIY#wTEV|wx4)W~# z7fLQ1M&M%qbbXzbaJ5DxHDow1X-f^07VM>|8;!;d(EYrE`gQ|`ZiP!*E>o|n2u)qOK z;swKsWc8~xzDHdWN$o~3A~?(@21lumbcF4}eY{{rK3`nU54^a}tn!b|T#@36%n8#( zbIje!JQbGzus2OJ>1v>$ovz>MZkM`M%nu1(GV`vj%C!D~`)$Aj*f0Sq)0~x3c@l5c zpay0)WXq*=%fq&wV1c7mFSBjAl}FUU~UJ3<_Ftgj{8XMsXm7 zN(QmfVi_FT(7=3Y4%#VXADyj?2SAxM){sX z8q#1QGc;ZUREY3&r85}~IuH|Ec1}fUu&wFjzzBaZl+@Kt^`dKX##N_YNMzJS zJ01A8JS9V$gyrj@$Q^)IW4S*vxOgd6JLy694K_Umowq}0bL^okP3JaM*hE#ue6=I> zIy*gVfP^7%JUTPteklqV-WN31?edSsS^#UfLzq7da5~Z1DqAA8t(;6@ipJz%)Bxja zNykvHCRb*v#K6xdR9-u%8MiMhTpH0LEg^?1lt`tyTt$4XqgyvSw3}h0of(*19B_lj z-Yc?NF9^6z0|t1-y8UPFHAuceRbXg&g#S2aW2uBNMPr*A(BWp!4wrZA_pE(#x*dDy zqmxjOf{nz>=c1k)*CA9TIy8GNAkGD@4)uVgKHEH@szU#ugGiVJKkS)In_RD^F(faf zX{ysK_)!<6Hgg8`K#-=q0C`?j(lE77FQq0ueTN`Y=%rMouR#dtT!HLBkjhKg-S!J? ztxBBgR~Z6%cNQE+#Y4+dypWsHuZFi@j>7 zUd*3B6R3kIM1giA?fv8BCqsNl+bm{Br_b~oA__GGjMnjT>>naX1` z*@fFpxvzFAL-D)Sj-JyQO@`MuftVOwkv^L#SRp4h1Q(Gn4=M=am6_oZbS=#skZJ^LJ3ZnA@Gc7e(168>gGoW@0TO~o8;V~la z2Lddwlik0Tk0 z@0wzq4$T)DtTjGv{W!_S-yk9ApRqM{`K1&vv9Hi|OzDp;)Lcl-uhNn%r+1LZ;C@lt z0e%)Jy$QbT=yvHs_(QGqQZjipF#p|y&JNR*5SG_vB){EV3KXf`L5woED>6_9l4SBD z6FR3DvsXlBxObL_%Eq93P}-cv zq^jtrbNYcVg|^N5#pGf~%GQAq>b%y$mSl5<(Z!i-k+aa;A$G(5NI(BSLJ6#|Z$h=8 z^Ji20sKSrWMTZSz69-Kc(N;M*f}HUOU0hP&*v0{Q@N#DKR3fktZqFG#B>r3Be^0mlEGY& z-YiUUqj6-sPAWu$+BCDScf37FtttLd*@DrK8zGu$vX2mLrp}t>NSBpB8J6JNMvF|1 zeXydRL_qjAszyMZgyCmb1Vmm1Y~tKJqaxu%P6`XD%n*o0ka6TW1Yjm{JJxb=k6DVB_#Ps6%E2$S*jbYlYf@%e>p6Y@5~8W7ei4TD8Ci=HzZ;|{?^ zBgcdRX>+>TtkI;drmFcXn3z4^VGp>a%8lmo7M_!G&-oBYZlLGz-X4`qdl|#5Q>5ibaj-_5z=C=4c(TtXfYpfl;vUKC zpp#LqOeZ^faT`F*pqUGGMBPzrG77c_pXK`6gRjiZXug+REFlS?qIN-0F7;oAVE}P5uxVTHK%XRU$jU97Gij z`Q5o)ly`%mWj`g#nM)a*upJe85k`2i#RstiZF3P^28y%U!O7;%@n}q!<`Y)pXrKdk zv)yi^F;z%X$Lh!&1q}Wm?1L@ZVGTt0r)<7NBObJCXHsox^3z8##jOlO%VRpkqX8*C z_B?mld7PYggNEfG97Sn*u^F#hiaiy1^@1I(Y}Z0KKoU5U9;#@ALM-4*SE#uXc4T{t ztjg%XEWDet1TxxIWM`o&A(yo;Osf^MlpVP`?FZ|E`-)|$Pwg3EiR3oZX+&RLj=^gK zts*O$Vg}OP5W2&X?g#ZCn2;EXv607X5s>*Fv)eC2A%d0iMVAOY{u~ien0Q*?_p{{R zvI)eJyN~n;_neE8#X4z5tyQ{+1}Gym6;E5t+i(Yk#PX%pqcG2*PVKcg1HjZQGfs&0YOD+U zEztDu7@OaEQnz=R9(ny#F2lb}A6XWvR!}HdCJgQxdaE=+=t5Oe|Jmf6o`HgQEwUSCWlYgilX9Mlf#oD-2usCK9jByd|HI3lf6^H` zQoYcSm|iezVA3u&?d?$k7JKzH>RlnqVo4cyMKloUDwmqFxufI_oe_c*XIPjgGOTgH z(|HE?Q|34!!5d3{I8F0}Z_GxyI)a#SuYR<2fh4JC)ntQ{&NP{38~aM%ikTfbz$;XI zdcGXLyF$+SnvS+Wlyq7)VRhDzbyTmY0jDz$8}C{A1oje-ixjsu!k7#ua1Sjq`WeWP z8VOl78UN|R$!2!|@Ze_Dco>+~)KzTXVl$8^nI6jEF_~|em81Q6ya6n1o==s6u#o3A zB;7fLjYImuHbCh&*)F95kWE4`jd_>(LP!J^MJ@IRP@k1Uk$KlW0DFd4SLtcQXe?*D-@wf|Q!;dW1ZuzU(rS z$sD;VZ|UB|NZ89fNm0BD>8w%?L~HNBBLrXGJEX!DWf^`fhqmYDl)X4l-1+u{|1`JE z6uQ%+9jx&*JU}Z+qBmd9S6k8aq2)lLq7{Z=s9sUt5^L)lNyVu$`FSGC*MYJzb7Zkx zCd97=kC4ZO6+&V0P*TF0F{H}IQ-8Ls5i?P0{|1atsN&mqRm^l@dNXUKtOZwbVxwen8YGd;Vv zn5`sdNVf?gvM1N&?JbSX}dY&g6yl~ct8T=@Nh_iWNJ438tEHa3k z*y5JFtz5Dp|CC;Xzwr-Vho{VZ9r*&?_YsqcGYw@R1mt7~o7_8~5Ue#LO=npb` z1WAOAiC`Bkd-Q@H3t2%?Wz-|Ihfx+qPK3S@*dhZ*mgvh{k=b#)VEZ=Yt|3gtpMMQ4 zTWeBu5WJ+%!4IvL{w?|P($$O?pxL*^C_Bo28(V12r%n(4NE%NaLU?}naN}urkcIP< zQ~oa59K2<1N;J2@auGQ)!fotS_V|0I$>0}mNv5{qCqEl+)znax_|FK{eO;tBj5-)0*-(q;0QPZ zj({WJ2si?cfFs}tI0BBq83_FK8Na!2=`JF0K8l|2?7N7EKeHp?2si?cfFs}tI0BA< zBj5-)0*-(q;0QPZj({WJ2si?cfFs}tI0BAbC>Umnf&?{gog@9%^A z?YXOS!0n-hKZzsY2si?cfFs}tI0BAi{x|GdZl_`mq`MaT2&?iK<@`@8kj{qOVbb_8w{0;cV6(=++A+#~|i9N_x@CeinMIRcJ=Bk+46 zFs=Q6ujlalIs%TsO(Sr&^t&Z^)AYCv_cNZ*f9>0Ccrt&6n@7OufAg689UXz2LZB+& z)gw3cEPkKchJf?JZKKFlKaWy)mZfjMT=gA&yxW9;OZaV~hChoV;0QPZj({WJ2si?c zfFp3b5b*i|w~HP(`!r7do5kDj<_I_fj({WJ2si?cfFs}tI0BA>-X*huFb!J|h^<%$fiE=ljo$J;s5DKmT;&MlP58cf!YK zq3!44cP>6CJQ~TOx7z4$`>VhFBrL1Jf8R4#j7{I=xqvr^c$wD zGhV(Z?AGel@^-7+j0&4;#X{7ID)sWy!>HORY_6=`FBWReo$B-IPPq~qEN^VAEw8Su zKL{;%TkS?AD*sk(cWSL>*jFsHTdkMEH zgGv;378-{KmF;Jhz3RPgRI7LH?N{puAa2V}}*kN0(ImmLo zScvm0cWS?fHtQ?JLg%pYv{g?>vGTHbN=M~#tyzo8<;nU8gUR$!I@v`j)5UhH+37Z_ z?a2bapZszutWT1C!Zfonw4(h<2M{Wsk@-HXp3MKri?iyx8D>GV(uk{@RK2|0ZElAW zKMNBrY>d~UctRyb@6D^7YE-G!!_J-RZa#C=?K_)=xDx$%zw~C&!+NFD8OG~G?e2C| z4o40mt`&2^Ksaft#@WHyX{sZKbY5ddj-3jjY=(c7$*}>&cQfhnYek6rwuPY`JgWNs?*Tn$hicHEwWc>AOr;BUOrX`!bhS=}}la zyE;i8323jcf#>^ku|Fq!XI;oD_m5u$2oNAZfB*pk1PBlyK!5-N0t5(LCxN}A$w&L< z?c{A|*Yei8t>f867nuM70t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7e?!U%jl*+_1^JK1h@OWfl0ttXEizrJ^rMtJ>a+$#QF@Oi$^JU+5L1PBly zK!5-N0t5&UAV7e?P+&fOB6yh3#XnQX#<~vAXZ?A}tm9vY8W|%20t5&UAV7dXB9Q#8 z-)S1&b)KeT8vz0Y2oOjG(r?hD>y`uv5cp65*OL#Ga~uHz1PBlyK!5;&*$a&S41M-} z>wy3P0tBvxfX{ZWMxA6yfB*pk1PBlyKwyyt+?OnJb&ZVx0RjXF5Fii>c*kcR5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ;Hn7tcdM>S zrQ}IqngZ$n?Gi6f`#F$w|1|p)i@;(EoOT9HI@0+#)Ao)oGKNXVs@*&Z%*V`|Cy|ex z%Vk$2+uzMs!_nV-wRP-zF!Y$_v#j|v<4!YHQhRrY(=?sGSXW^t&Y#-iWc2qRi!&A@ zxv0S2(bnWT5g1ndHE52tXuEW=kfdh^!faZdR{X*&+Fw`ZL`(Mj`i{@5zmdYGR Date: Sun, 24 May 2026 15:39:38 +0800 Subject: [PATCH 7/7] feat: per-tier search breakdown telemetry (OTEL-style spans) Instruments searchContent with nanoTimestamp() around each of the 7 search tiers plus rerank. Stores a SearchBreakdown struct on the Explorer after every search, emitted as a search_breakdown telemetry event for codedb_search/codedb_find/codedb_word calls. Fields: tier0_ns through tier5_ns, rerank_ns, tier_reached, candidate_count, result_count. ~160ns overhead per search (8 clock_gettime calls on Apple Silicon). Co-Authored-By: Claude Opus 4.7 (1M context) --- src/explore.zig | 105 +++++++++++++++++++++++++++++++++------------- src/mcp.zig | 4 ++ src/telemetry.zig | 43 +++++++++++++++++++ 3 files changed, 123 insertions(+), 29 deletions(-) diff --git a/src/explore.zig b/src/explore.zig index 1e538a4..08a1023 100644 --- a/src/explore.zig +++ b/src/explore.zig @@ -181,6 +181,20 @@ pub const SearchResult = struct { score: f32 = 0.0, }; +pub const SearchBreakdown = struct { + tier0_ns: i128 = 0, + tier05_ns: i128 = 0, + tier1_ns: i128 = 0, + tier2_ns: i128 = 0, + tier3_ns: i128 = 0, + tier4_ns: i128 = 0, + tier5_ns: i128 = 0, + rerank_ns: i128 = 0, + tier_reached: u8 = 0, + candidate_count: u32 = 0, + result_count: u32 = 0, +}; + pub const DependencyGraph = struct { forward: std.StringHashMap(std.ArrayList([]const u8)), reverse: std.StringHashMap(std.StringHashMap(void)), @@ -522,6 +536,7 @@ pub const Explorer = struct { /// assert the short-circuit holds (issue: negative-query slow path). /// Production code does not read this field. search_tier5_count: u64 = 0, + last_search_breakdown: SearchBreakdown = .{}, pub const DEFAULT_CONTENT_CACHE_CAPACITY: u32 = 16384; @@ -1520,6 +1535,9 @@ pub const Explorer = struct { if (max_results == 0) return try allocator.alloc(SearchResult, 0); + var breakdown: SearchBreakdown = .{}; + defer self.last_search_breakdown = breakdown; + var result_list: std.ArrayList(SearchResult) = .empty; errdefer result_list.deinit(allocator); @@ -1533,6 +1551,7 @@ pub const Explorer = struct { // docs, and files with more exact word hits are considered first so // popular identifiers and skip-trigram canonical files are not hidden // behind earlier low-signal posting-list entries. + const t0_start = cio.nanoTimestamp(); const word_hits = self.word_index.search(query); if (word_hits.len > 0) { const Tier0File = struct { @@ -1587,13 +1606,19 @@ pub const Explorer = struct { searched.put(stats.path, {}) catch {}; try searchInContent(stats.path, ref.data, query, allocator, tier0_per_file_cap, max_results, &result_list); } - if (result_list.items.len >= max_results) - return self.rerankAndFinalize(&result_list, query, allocator); + if (result_list.items.len >= max_results) { + breakdown.tier0_ns = cio.nanoTimestamp() - t0_start; + breakdown.tier_reached = 0; + breakdown.result_count = @intCast(result_list.items.len); + const t_rerank = cio.nanoTimestamp(); + const res = self.rerankAndFinalize(&result_list, query, allocator); + breakdown.rerank_ns = cio.nanoTimestamp() - t_rerank; + return res; + } } + breakdown.tier0_ns = cio.nanoTimestamp() - t0_start; - // Tier 0.5: prefix expansion — find all indexed keys that begin with the query. - // Activates when Tier 0 found nothing and query is ≥3 chars, catching partial - // identifier queries like "searchC" that match "searchContent" in the word index. + const t05_start = cio.nanoTimestamp(); if (result_list.items.len == 0 and query.len >= 3) { const prefix_hits = try self.word_index.searchPrefix(query, allocator, max_results); defer allocator.free(prefix_hits); @@ -1616,14 +1641,23 @@ pub const Explorer = struct { searched.put(hit_path, {}) catch {}; if (result_list.items.len >= max_results) break; } - if (result_list.items.len >= max_results) - return self.rerankAndFinalize(&result_list, query, allocator); + if (result_list.items.len >= max_results) { + breakdown.tier05_ns = cio.nanoTimestamp() - t05_start; + breakdown.tier_reached = 1; + breakdown.result_count = @intCast(result_list.items.len); + const t_rerank = cio.nanoTimestamp(); + const res = self.rerankAndFinalize(&result_list, query, allocator); + breakdown.rerank_ns = cio.nanoTimestamp() - t_rerank; + return res; + } } + breakdown.tier05_ns = cio.nanoTimestamp() - t05_start; + const t1_start = cio.nanoTimestamp(); const candidate_paths = self.trigram_index.candidates(query, allocator); defer if (candidate_paths) |cp| allocator.free(cp); + if (candidate_paths) |cp| breakdown.candidate_count = @intCast(cp.len); - // Tier 1: trigram candidates — fast path, skips files already found by Tier 0. if (candidate_paths) |cp| { if (cp.len > 0) { // Issue #427: rank candidates by per-file word-index hit count @@ -1662,18 +1696,25 @@ pub const Explorer = struct { const ref = self.readContentForSearch(path, allocator) orelse continue; defer ref.deinit(); try searchInContent(path, ref.data, query, allocator, max_per_file, max_results, &result_list); - if (result_list.items.len >= max_results) - return self.rerankAndFinalize(&result_list, query, allocator); + if (result_list.items.len >= max_results) { + breakdown.tier1_ns = cio.nanoTimestamp() - t1_start; + breakdown.tier_reached = 2; + breakdown.result_count = @intCast(result_list.items.len); + const t_rerank = cio.nanoTimestamp(); + const res = self.rerankAndFinalize(&result_list, query, allocator); + breakdown.rerank_ns = cio.nanoTimestamp() - t_rerank; + return res; + } } } } - // Mark all Tier 1 candidates as searched. if (candidate_paths) |cp| { for (cp) |p| searched.put(p, {}) catch {}; } + breakdown.tier1_ns = cio.nanoTimestamp() - t1_start; - // Tier 2: sparse candidates — LAZY, only computed when Tier 1 found nothing. + const t2_start = cio.nanoTimestamp(); if (result_list.items.len == 0) { const sparse_paths = self.sparse_ngram_index.candidates(query, allocator); defer if (sparse_paths) |sp| allocator.free(sp); @@ -1688,8 +1729,9 @@ pub const Explorer = struct { } } } + breakdown.tier2_ns = cio.nanoTimestamp() - t2_start; - // Tier 3: skip_trigram_files not already searched. + const t3_start = cio.nanoTimestamp(); if (result_list.items.len < max_results) { var skip_iter = self.skip_trigram_files.keyIterator(); while (skip_iter.next()) |key_ptr| { @@ -1701,8 +1743,9 @@ pub const Explorer = struct { if (result_list.items.len >= max_results) break; } } + breakdown.tier3_ns = cio.nanoTimestamp() - t3_start; - // Tier 4: word index scan — for files not yet searched. + const t4_start = cio.nanoTimestamp(); if (result_list.items.len < max_results) { const tier4_hits = self.word_index.search(query); if (tier4_hits.len > 0) { @@ -1720,21 +1763,9 @@ pub const Explorer = struct { } } } + breakdown.tier4_ns = cio.nanoTimestamp() - t4_start; - // Tier 5: full scan fallback — only when NO results from any tier. - // Avoids 100ms+ scans on large repos when indices already found matches. - // - // Short-circuit Tier 5 whenever the trigram index was consulted with - // a query long enough to fully cover it (query.len >= 3). The trigram - // filter returns a SUPERSET of files containing the substring (every - // file containing the substring necessarily contains all its - // trigrams). If Tier 1 scanned that superset and found 0 results, no - // other trigram-indexed file can match either; skip_trigram_files - // were handled separately by Tier 3. Tier 5 would otherwise re-scan - // every indexed file for nothing — a measurable 2–3 ms p50 cost on - // queries whose constituent trigrams are common-but-not-co-occurring - // syllables (e.g. `Suspense` on a Rust corpus). The cp.len == 0 - // sub-case of this was already short-circuited before this change. + const t5_start = cio.nanoTimestamp(); const trigram_ruled_out = if (candidate_paths) |_| (query.len >= 3) else @@ -1750,7 +1781,23 @@ pub const Explorer = struct { if (result_list.items.len >= max_results) break; } } - return self.rerankAndFinalize(&result_list, query, allocator); + breakdown.tier5_ns = cio.nanoTimestamp() - t5_start; + + if (result_list.items.len > 0) { + breakdown.tier_reached = if (breakdown.tier5_ns > 0 and result_list.items.len > 0) 7 + else if (breakdown.tier4_ns > 0 and result_list.items.len > 0) 6 + else if (breakdown.tier3_ns > 0) 5 + else if (breakdown.tier2_ns > 0) 4 + else if (breakdown.tier1_ns > 0) 3 + else if (breakdown.tier05_ns > 0) 1 + else 0; + } + breakdown.result_count = @intCast(result_list.items.len); + + const t_rerank = cio.nanoTimestamp(); + const res = self.rerankAndFinalize(&result_list, query, allocator); + breakdown.rerank_ns = cio.nanoTimestamp() - t_rerank; + return res; } /// Run the multi-signal rerank in place, then transfer ownership of diff --git a/src/mcp.zig b/src/mcp.zig index ca85dd6..76bc144 100644 --- a/src/mcp.zig +++ b/src/mcp.zig @@ -995,6 +995,10 @@ fn handleCall( const is_error = std.mem.startsWith(u8, out.items, "error:"); telem.recordToolCall(name, elapsed, is_error, out.items.len); + if (std.mem.eql(u8, name, "codedb_search") or std.mem.eql(u8, name, "codedb_find") or std.mem.eql(u8, name, "codedb_word")) { + telem.recordSearchBreakdown(explorer.last_search_breakdown); + } + // Query + file access tracking WAL if (!is_error) { if (std.mem.eql(u8, name, "codedb_search") or std.mem.eql(u8, name, "codedb_find") or std.mem.eql(u8, name, "codedb_word")) { diff --git a/src/telemetry.zig b/src/telemetry.zig index 4e33ec5..bd8ea55 100644 --- a/src/telemetry.zig +++ b/src/telemetry.zig @@ -28,6 +28,19 @@ pub const Event = struct { index_size_bytes: u64, startup_time_ms: u64, }, + search_breakdown: struct { + tier0_ns: i64, + tier05_ns: i64, + tier1_ns: i64, + tier2_ns: i64, + tier3_ns: i64, + tier4_ns: i64, + tier5_ns: i64, + rerank_ns: i64, + tier_reached: u8, + candidate_count: u32, + result_count: u32, + }, }; }; @@ -169,6 +182,28 @@ pub const Telemetry = struct { self.record(tc); } + pub fn recordSearchBreakdown(self: *Telemetry, bd: explore.SearchBreakdown) void { + if (!self.enabled) return; + const clamp = struct { + fn f(v: i128) i64 { + return @intCast(@min(v, std.math.maxInt(i64))); + } + }.f; + self.record(.{ .search_breakdown = .{ + .tier0_ns = clamp(bd.tier0_ns), + .tier05_ns = clamp(bd.tier05_ns), + .tier1_ns = clamp(bd.tier1_ns), + .tier2_ns = clamp(bd.tier2_ns), + .tier3_ns = clamp(bd.tier3_ns), + .tier4_ns = clamp(bd.tier4_ns), + .tier5_ns = clamp(bd.tier5_ns), + .rerank_ns = clamp(bd.rerank_ns), + .tier_reached = bd.tier_reached, + .candidate_count = bd.candidate_count, + .result_count = bd.result_count, + } }); + } + pub fn recordCodebaseStats(self: *Telemetry, explorer: *explore.Explorer, startup_time_ms: u64) void { if (!self.enabled) return; @@ -275,6 +310,14 @@ pub const Telemetry = struct { stats.startup_time_ms, }); }, + .search_breakdown => |sb| { + try w.print(",\"event_type\":\"search_breakdown\",\"tier0_ns\":{d},\"tier05_ns\":{d},\"tier1_ns\":{d},\"tier2_ns\":{d},\"tier3_ns\":{d},\"tier4_ns\":{d},\"tier5_ns\":{d},\"rerank_ns\":{d},\"tier_reached\":{d},\"candidates\":{d},\"results\":{d}", .{ + sb.tier0_ns, sb.tier05_ns, sb.tier1_ns, + sb.tier2_ns, sb.tier3_ns, sb.tier4_ns, + sb.tier5_ns, sb.rerank_ns, sb.tier_reached, + sb.candidate_count, sb.result_count, + }); + }, } try w.writeAll("}\n"); return w.end;