Merge branch 'zig-0.16-upgrade' into yolo

Author: pmarreck

build.zig

@@ -554,11 +554,11 @@ fn linkCommon(
 	ts_lib: *std.Build.Step.Compile,
 	lang_libs: []const *std.Build.Step.Compile,
 ) void {
-	compile.linkLibrary(sqlite3_lib);
-	compile.linkLibrary(vec_static_lib);
-	compile.linkLibrary(pcre2_lib);
-	compile.linkLibrary(ts_lib);
-	for (lang_libs) |lib| compile.linkLibrary(lib);
+	compile.root_module.linkLibrary(sqlite3_lib);
+	compile.root_module.linkLibrary(vec_static_lib);
+	compile.root_module.linkLibrary(pcre2_lib);
+	compile.root_module.linkLibrary(ts_lib);
+	for (lang_libs) |lib| compile.root_module.linkLibrary(lib);
 }
 
 fn buildTreeSitter(
@@ -569,6 +569,7 @@ fn buildTreeSitter(
 	const ts_module = b.createModule(.{
 		.target = target,
 		.optimize = optimize,
+		.link_libc = true,
 	});
 	const ts_lib = b.addLibrary(.{
 		.name = "tree_sitter",
@@ -580,7 +581,6 @@ fn buildTreeSitter(
 	});
 	ts_module.addIncludePath(b.path("deps/tree-sitter/lib/src"));
 	ts_module.addIncludePath(b.path("deps/tree-sitter/lib/include"));
-	ts_lib.linkLibC();
 	ts_lib.installHeader(b.path("deps/tree-sitter/lib/include/tree_sitter/api.h"), "tree_sitter/api.h");
 	return ts_lib;
 }
@@ -596,6 +596,7 @@ fn buildTreeSitterGrammar(
 	const module = b.createModule(.{
 		.target = target,
 		.optimize = optimize,
+		.link_libc = true,
 	});
 	const lib = b.addLibrary(.{
 		.name = name,
@@ -613,6 +614,5 @@ fn buildTreeSitterGrammar(
 	module.addIncludePath(b.path(dir));
 	module.addIncludePath(b.path("deps/tree-sitter/lib/include"));
 	module.addIncludePath(b.path("deps/tree-sitter/lib/src"));
-	lib.linkLibC();
 	return lib;
 }

build.zig.zon

@@ -1,16 +1,16 @@
 .{
     .name = .codescan,
     .version = "0.1.0",
-    .minimum_zig_version = "0.15.2",
+    .minimum_zig_version = "0.16.0",
     .paths = .{
         "build.zig",
         "build.zig.zon",
         "src",
     },
     .dependencies = .{
         .sqlite_vec = .{
-            .url = "git+https://github.com/pmarreck/sqlite-vec.git#742ac1607d5490c71758c9fde80820387391910d",
-            .hash = "sqlite_vec-0.1.7-alpha.2-4Cdt0OvwBACYsEQvfmbSw0sUHuXhcwD5PgjGyslHXU2q",
+            .url = "git+https://github.com/pmarreck/sqlite-vec.git#c9d3630f56637276829d9ab0c54b1116c6d3e2ef",
+            .hash = "sqlite_vec-0.1.7-alpha.2-4Cdt0CTyBADFzDhhNOTSAUplRsfH1qs-DqwP6FwrZ641",
         },
         .pcre2 = .{
             .url = "https://github.com/pmarreck/pcre2/archive/refs/tags/zig-0.16.0.tar.gz",

flake.lock

@@ -19,8 +19,8 @@
 				# Pre-fetch Zig build.zig.zon dependencies for sandboxed builds
 				sqlite-vec-src = pkgs.fetchgit {
 					url = "https://github.com/pmarreck/sqlite-vec.git";
-					rev = "742ac1607d5490c71758c9fde80820387391910d";
-					hash = "sha256-CFZAditwPGoWpAK7AG8BaxksfxjEzyGdlMvuZPsJ7CQ=";
+					rev = "c9d3630f56637276829d9ab0c54b1116c6d3e2ef";
+					hash = "sha256-9MBuzlHICNc0U4TIEEPd0gWAftxllXcU8bhilcaAh+k=";
 				};
 				pcre2-src = pkgs.fetchgit {
 					url = "https://github.com/pmarreck/pcre2.git";
@@ -33,7 +33,7 @@
 				# so we can pass it via --system to avoid network fetches
 				zigPkgCache = pkgs.linkFarm "zig-pkg-cache" [
 					{
-						name = "sqlite_vec-0.1.7-alpha.2-4Cdt0OvwBACYsEQvfmbSw0sUHuXhcwD5PgjGyslHXU2q";
+						name = "sqlite_vec-0.1.7-alpha.2-4Cdt0CTyBADFzDhhNOTSAUplRsfH1qs-DqwP6FwrZ641";
 						path = sqlite-vec-src;
 					}
 					{
@@ -48,7 +48,7 @@
 
 					src = ./.;
 
-					nativeBuildInputs = [ pkgs.zig_0_15 ];
+					nativeBuildInputs = [ pkgs.zig_0_16 ];
 
 					dontConfigure = true;
 					dontFixup = true;
@@ -80,7 +80,7 @@
 
 				devShells.default = pkgs.mkShell {
 					packages = with pkgs; [
-						zig_0_15
+						zig_0_16
 						jq
 						luajit
 						luajitPackages.cjson

flake.nix

@@ -203,9 +203,9 @@ pub fn parse(allocator: std.mem.Allocator, args: []const []const u8) !Parsed {
 		.type_filter = null,
 		.lang_filter = null,
 		.kind_filter = null,
-		.path_filters = .{},
+		.path_filters = .empty,
 		.file_filter = null,
-		.symbols_files = .{},
+		.symbols_files = .empty,
 		.pattern = null,
 		.include_body = false,
 		.from_ref = null,
@@ -962,7 +962,7 @@ pub fn parse(allocator: std.mem.Allocator, args: []const []const u8) !Parsed {
 
 		if (parsed.command == .search) {
 			if (!query_parts_inited) {
-				query_parts = .{};
+				query_parts = .empty;
 				query_parts_inited = true;
 			}
 			try query_parts.append(allocator, arg);

src/cli.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const io_singleton = @import("io_singleton.zig");
 const cli = @import("cli.zig");
 const env_expand = @import("env_expand.zig");
 
@@ -76,7 +77,7 @@ pub const default_template =
 
 pub const IgnoreOverride = struct {
 	language: []const u8,
-	patterns: std.ArrayListUnmanaged([]const u8) = .{},
+	patterns: std.ArrayListUnmanaged([]const u8) = .empty,
 
 	pub fn deinit(self: *IgnoreOverride, allocator: std.mem.Allocator) void {
 		for (self.patterns.items) |pattern| allocator.free(pattern);
@@ -132,10 +133,10 @@ pub const Config = struct {
 	docs_only: ?bool = null,
 	comments_only: ?bool = null,
 	include_node_modules: ?bool = null,
-	ignore_global: std.ArrayListUnmanaged([]const u8) = .{},
-	always_include: std.ArrayListUnmanaged([]const u8) = .{},
-	ignore_lang: std.ArrayListUnmanaged(IgnoreOverride) = .{},
-	lsp_overrides: std.ArrayListUnmanaged(LspOverride) = .{},
+	ignore_global: std.ArrayListUnmanaged([]const u8) = .empty,
+	always_include: std.ArrayListUnmanaged([]const u8) = .empty,
+	ignore_lang: std.ArrayListUnmanaged(IgnoreOverride) = .empty,
+	lsp_overrides: std.ArrayListUnmanaged(LspOverride) = .empty,
 	http_host: ?[]const u8 = null,
 	http_port: ?u16 = null,
 
@@ -469,9 +470,8 @@ pub fn parseText(allocator: std.mem.Allocator, text: []const u8) !Config {
 }
 
 pub fn loadFromPath(allocator: std.mem.Allocator, path: []const u8) !Config {
-	const file = try std.fs.cwd().openFile(path, .{});
-	defer file.close();
-	const data = try file.readToEndAlloc(allocator, 1024 * 1024);
+	const io = io_singleton.getOrInit();
+	const data = try std.Io.Dir.cwd().readFileAlloc(io, path, allocator, .limited(1024 * 1024));
 	defer allocator.free(data);
 	return parseText(allocator, data);
 }
@@ -489,7 +489,7 @@ fn appendPatterns(
 	value: []const u8,
 ) !void {
 	// Split on commas, respecting \, as an escaped literal comma
-	var buf = std.ArrayListUnmanaged(u8){};
+	var buf = @as(std.ArrayListUnmanaged(u8), .empty);
 	defer buf.deinit(allocator);
 	var i: usize = 0;
 	while (i < value.len) : (i += 1) {
@@ -523,7 +523,7 @@ fn getOrCreateOverride(
 	}
 	try list.append(allocator, .{
 		.language = try allocator.dupe(u8, lang),
-		.patterns = .{},
+		.patterns = .empty,
 	});
 	return &list.items[list.items.len - 1];
 }
@@ -549,7 +549,7 @@ pub const KV = struct {
 /// Keys not found in the original content are appended at the end.
 /// Returns a new allocated string with the updated content.
 pub fn writeConfigValues(allocator: std.mem.Allocator, content: []const u8, kvs: []const KV) ![]u8 {
-    var output: std.ArrayListUnmanaged(u8) = .{};
+    var output: std.ArrayListUnmanaged(u8) = .empty;
     defer output.deinit(allocator);
 
     // Track which kvs were matched
@@ -567,9 +567,9 @@ pub fn writeConfigValues(allocator: std.mem.Allocator, content: []const u8, kvs:
         var was_matched = false;
         for (kvs, 0..) |kv, idx| {
             // Match "#key=..." or "# key=..." or "key=..."
-            const trimmed = std.mem.trimLeft(u8, line, " \t");
+            const trimmed = std.mem.trimStart(u8, line, " \t");
             const after_hash = if (std.mem.startsWith(u8, trimmed, "#"))
-                std.mem.trimLeft(u8, trimmed[1..], " \t")
+                std.mem.trimStart(u8, trimmed[1..], " \t")
             else
                 trimmed;
 
@@ -734,9 +734,9 @@ test "default_template parses without error" {
 test "loadFromPath reads file" {
 	var tmp = std.testing.tmpDir(.{});
 	defer tmp.cleanup();
-	try tmp.dir.writeFile(.{ .sub_path = "config", .data = "top=3\n" });
+	try tmp.dir.writeFile(io_singleton.getOrInit(), .{ .sub_path = "config", .data = "top=3\n" });
 	const allocator = std.testing.allocator;
-	const path = try tmp.dir.realpathAlloc(allocator, "config");
+	const path = try tmp.dir.realPathFileAlloc(io_singleton.getOrInit(), "config", allocator);
 	defer allocator.free(path);
 	var cfg = try loadFromPath(allocator, path);
 	defer cfg.deinit(allocator);

src/config.zig

@@ -59,10 +59,9 @@ pub fn generateUnifiedDiff(allocator: std.mem.Allocator, old: []const u8, new: [
     const hunk_end_new = @min(last_diff_new.? + context, new_lines.len);
 
     // Build output
-    var buf = std.ArrayListUnmanaged(u8){};
-    defer buf.deinit(allocator);
-
-    const writer = buf.writer(allocator);
+    var alloc_writer = std.Io.Writer.Allocating.init(allocator);
+    defer alloc_writer.deinit();
+    const writer = &alloc_writer.writer;
 
     // File headers
     try writer.print("--- a/{s}\n", .{file_path});
@@ -96,14 +95,12 @@ pub fn generateUnifiedDiff(allocator: std.mem.Allocator, old: []const u8, new: [
         try writer.print(" {s}\n", .{old_lines[i]});
     }
 
-    const result = try allocator.alloc(u8, buf.items.len);
-    @memcpy(result, buf.items);
-    return result;
+    return try alloc_writer.toOwnedSlice();
 }
 
 /// Split content into lines (slices into the original content, no copying).
 fn splitLines(allocator: std.mem.Allocator, content: []const u8) ![]const []const u8 {
-    var lines = std.ArrayListUnmanaged([]const u8){};
+    var lines = @as(std.ArrayListUnmanaged([]const u8), .empty);
     defer lines.deinit(allocator);
 
     var start: usize = 0;

src/diff.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const io_singleton = @import("io_singleton.zig");
 const embedding_http = @import("embedding_http.zig");
 
 pub const Embedder = struct {
@@ -88,7 +89,7 @@ test "NullEmbedder returns empty embeddings and free is safe" {
 
 
 fn envOrDefault(allocator: std.mem.Allocator, key: []const u8, fallback: []const u8) ![]u8 {
-	const value = std.process.getEnvVarOwned(allocator, key) catch |err| switch (err) {
+	const value = io_singleton.getEnvVarOwned(allocator, key) catch |err| switch (err) {
 		error.EnvironmentVariableNotFound => return allocator.dupe(u8, fallback),
 		else => return err,
 	};

src/embedding.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const io_singleton = @import("io_singleton.zig");
 
 pub const HttpRequest = struct {
 	method: []const u8,
@@ -62,7 +63,7 @@ pub fn embed(
 
 	if (response.status != 200) {
 		var stderr_buf: [256]u8 = undefined;
-		var stderr_writer = std.fs.File.stderr().writer(&stderr_buf);
+		var stderr_writer = std.Io.File.stderr().writer(io_singleton.getOrInit(), &stderr_buf);
 		const stderr = &stderr_writer.interface;
 		const preview_len = @min(response.body.len, 500);
 		_ = stderr.print("error: embedding server returned HTTP {d}\n  url: {s}\n  model: {s}\n  body: {s}{s}\n", .{
@@ -117,7 +118,7 @@ pub fn buildEmbedRequest(
 		.openai => null,
 	};
 	const payload = EmbedRequest{ .model = model, .input = inputs, .keep_alive = effective_keep_alive };
-	var out: std.io.Writer.Allocating = .init(allocator);
+	var out: std.Io.Writer.Allocating = .init(allocator);
 	defer out.deinit();
 
 	var stream: std.json.Stringify = .{ .writer = &out.writer, .options = .{ .emit_null_optional_fields = false } };
@@ -306,7 +307,7 @@ pub const StdHttpTransport = struct {
 	client: std.http.Client,
 
 	pub fn init(allocator: std.mem.Allocator) StdHttpTransport {
-		return .{ .client = .{ .allocator = allocator } };
+		return .{ .client = .{ .allocator = allocator, .io = io_singleton.getOrInit() } };
 	}
 
 	pub fn deinit(self: *StdHttpTransport) void {
@@ -587,7 +588,7 @@ test "embed uses live Ollama" {
 }
 
 fn envOrDefault(allocator: std.mem.Allocator, key: []const u8, fallback: []const u8) ![]u8 {
-	const value = std.process.getEnvVarOwned(allocator, key) catch |err| switch (err) {
+	const value = io_singleton.getEnvVarOwned(allocator, key) catch |err| switch (err) {
 		error.EnvironmentVariableNotFound => return allocator.dupe(u8, fallback),
 		else => return err,
 	};

src/embedding_http.zig

@@ -22,18 +22,23 @@ const max_depth: u8 = 10;
 /// Expand `$VAR` / `${VAR}` / `${VAR:-DEF}` / `${VAR-DEF}` / `$$` references
 /// against the process environment. Caller owns the returned slice.
 pub fn expand(allocator: std.mem.Allocator, input: []const u8) ![]u8 {
-    var env = try std.process.getEnvMap(allocator);
-    defer env.deinit();
-    return expandWith(allocator, input, &env);
+    // Use the env map set in main() at startup. Tests use expandWith with an
+    // explicit env map and don't go through this path.
+    // For test code paths that reach expand() transitively without setting
+    // an env map, fall back to a lazy-initialized empty map so test logic
+    // that doesn't depend on env values still works.
+    const io_singleton = @import("io_singleton.zig");
+    const env_map = io_singleton.getEnvMapOrInit(allocator);
+    return expandWith(allocator, input, env_map);
 }
 
 /// Hermetic variant used by tests — pass an explicit EnvMap.
 pub fn expandWith(
     allocator: std.mem.Allocator,
     input: []const u8,
-    env: *const std.process.EnvMap,
+    env: *const std.process.Environ.Map,
 ) ![]u8 {
-    var out = std.ArrayListUnmanaged(u8){};
+    var out = @as(std.ArrayListUnmanaged(u8), .empty);
     errdefer out.deinit(allocator);
     try expandInto(allocator, &out, input, env, 0);
     return out.toOwnedSlice(allocator);
@@ -77,7 +82,7 @@ fn expandInto(
     allocator: std.mem.Allocator,
     out: *std.ArrayListUnmanaged(u8),
     input: []const u8,
-    env: *const std.process.EnvMap,
+    env: *const std.process.Environ.Map,
     depth: u8,
 ) std.mem.Allocator.Error!void {
     if (depth > max_depth) {
@@ -146,7 +151,7 @@ fn expandBracedBody(
     allocator: std.mem.Allocator,
     out: *std.ArrayListUnmanaged(u8),
     body: []const u8,
-    env: *const std.process.EnvMap,
+    env: *const std.process.Environ.Map,
     depth: u8,
 ) std.mem.Allocator.Error!void {
     if (body.len == 0) return; // `${}` → empty
@@ -194,8 +199,8 @@ fn expandBracedBody(
 
 // ---- Tests ----
 
-fn makeEnv(allocator: std.mem.Allocator, pairs: []const [2][]const u8) !std.process.EnvMap {
-    var env = std.process.EnvMap.init(allocator);
+fn makeEnv(allocator: std.mem.Allocator, pairs: []const [2][]const u8) !std.process.Environ.Map {
+    var env = std.process.Environ.Map.init(allocator);
     errdefer env.deinit();
     for (pairs) |p| try env.put(p[0], p[1]);
     return env;