From 4ad8215f1835cdfa61889e22d0ac5bc5bbeb00b2 Mon Sep 17 00:00:00 2001
From: UnknownRori <68576836+UnknownRori@users.noreply.github.com>
Date: Sun, 5 Oct 2025 10:05:30 +0700
Subject: [PATCH 1/5] update external libs

---
 external/flag.zig | 2 +-
 external/yaml.zig | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/external/flag.zig b/external/flag.zig
index be89a63..dc5859b 160000
--- a/external/flag.zig
+++ b/external/flag.zig
@@ -1 +1 @@
-Subproject commit be89a63c0cd06573236598e47fd881d7d75ba399
+Subproject commit dc5859b17a75d51b256422049a24088e80fa45a9
diff --git a/external/yaml.zig b/external/yaml.zig
index a2b44c7..1132c71 160000
--- a/external/yaml.zig
+++ b/external/yaml.zig
@@ -1 +1 @@
-Subproject commit a2b44c7cf8b7d4a486bd6ee551be981bc33fe8ba
+Subproject commit 1132c713495853bde247e4f03474d73c5585942f

From 4c5f03043a6bb893833cbd4c19f5f5efafa318bc Mon Sep 17 00:00:00 2001
From: UnknownRori <68576836+UnknownRori@users.noreply.github.com>
Date: Sun, 5 Oct 2025 10:06:15 +0700
Subject: [PATCH 2/5] update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e79050b..dc251d2 100644
--- a/README.md
+++ b/README.md
@@ -33,7 +33,7 @@ OPTIONS:
 
 ## Development
 
-Make sure you have `zig 0.14.1`
+Make sure you have `zig 0.15.1`
 
 ```sh
 git clone https://github.com/UnknownRori/raphael-zig

From c783132a21f1f5f677c9937b6b3093991c516ec4 Mon Sep 17 00:00:00 2001
From: UnknownRori <68576836+UnknownRori@users.noreply.github.com>
Date: Sun, 5 Oct 2025 10:30:58 +0700
Subject: [PATCH 3/5] compile but still broke

---
 src/app.zig           | 28 ++++++++++++++--------------
 src/document.zig      | 18 +++++++++---------
 src/http/request.zig  | 10 +++++-----
 src/http/response.zig | 17 ++++++++++-------
 src/http/router.zig   | 10 +++++-----
 src/http/server.zig   | 29 +++++++++++------------------
 src/main.zig          | 10 ++++++----
 src/metadata.zig      | 20 ++++++++++----------
 src/root.zig          | 31 +++++++++++++++++--------------
 9 files changed, 87 insertions(+), 86 deletions(-)

diff --git a/src/app.zig b/src/app.zig
index 34e558f..f1e834e 100644
--- a/src/app.zig
+++ b/src/app.zig
@@ -26,7 +26,7 @@ pub fn index(allocator: std.mem.Allocator, dir: []const u8) !void {
 pub fn serve(allocator: std.mem.Allocator) !void {
     const tfi = try lib.load_index(allocator);
 
-    var router = lib.Http.Router.init(allocator);
+    var router = try lib.Http.Router.init(allocator);
 
     var raphael_controller = try RaphaelController.init(tfi);
     defer raphael_controller.deinit();
@@ -72,7 +72,7 @@ pub const RaphaelController = struct {
     }
 
     pub fn load_favico(ctx: *anyopaque, req: *Request, res: *Response) !void {
-        const self: *Self = @alignCast(@ptrCast(ctx));
+        const self: *Self = @ptrCast(@alignCast(ctx));
 
         const contents = read_file(res.arena.allocator(), self.dir, "statics/favicon.ico") catch |err| {
             std.debug.print("[-] {any}\n", .{err});
@@ -85,7 +85,7 @@ pub const RaphaelController = struct {
     }
 
     pub fn load_sw(ctx: *anyopaque, req: *Request, res: *Response) !void {
-        const self: *Self = @alignCast(@ptrCast(ctx));
+        const self: *Self = @ptrCast(@alignCast(ctx));
 
         const contents = read_file(res.arena.allocator(), self.dir, "statics/sw.js") catch |err| {
             std.debug.print("[-] {any}\n", .{err});
@@ -99,7 +99,7 @@ pub const RaphaelController = struct {
 
     pub fn assets(ctx: *anyopaque, req: *Request, res: *Response) !void {
         // TODO : Create abstraction for this thing
-        const self: *Self = @alignCast(@ptrCast(ctx));
+        const self: *Self = @ptrCast(@alignCast(ctx));
         const dir = self.dir;
 
         const path = try std.mem.replaceOwned(u8, res.arena.allocator(), req.path[1..], "../", "");
@@ -120,7 +120,7 @@ pub const RaphaelController = struct {
     }
 
     pub fn show(ctx: *anyopaque, req: *Request, res: *Response) !void {
-        const self: *Self = @alignCast(@ptrCast(ctx));
+        const self: *Self = @ptrCast(@alignCast(ctx));
         const allocator = res.arena.allocator(); // Borrowing shit
 
         var data = std.json.parseFromSlice(std.json.Value, allocator, req.body.?.items, .{}) catch |err| {
@@ -133,8 +133,8 @@ pub const RaphaelController = struct {
         defer data.deinit();
 
         const query_input = data.value.object.get("file").?.string;
-        const result = try self.tfi.search(allocator, query_input);
-        defer result.deinit();
+        var result = try self.tfi.search(allocator, query_input);
+        defer result.deinit(allocator);
 
         const dir = try std.fs.cwd().openDir(std.fs.path.dirname(query_input).?, .{ .iterate = true });
         const contents = read_file(res.arena.allocator(), dir, std.fs.path.basename(query_input)) catch |err| {
@@ -146,7 +146,7 @@ pub const RaphaelController = struct {
     }
 
     pub fn query(ctx: *anyopaque, req: *Request, res: *Response) !void {
-        const self: *Self = @alignCast(@ptrCast(ctx));
+        const self: *Self = @ptrCast(@alignCast(ctx));
         const allocator = res.arena.allocator(); // Borrowing shit
 
         // TODO : Refactor this into paginator.zig
@@ -173,10 +173,10 @@ pub const RaphaelController = struct {
         defer data.deinit();
 
         const query_input = data.value.object.get("query").?.string;
-        const result = try self.tfi.search(allocator, query_input);
-        defer result.deinit();
+        var result = try self.tfi.search(allocator, query_input);
+        defer result.deinit(allocator);
 
-        var result_item = std.ArrayList(QueryResult).init(allocator);
+        var result_item = try std.ArrayList(QueryResult).initCapacity(allocator, 10);
         var temp_result = result.items;
 
         var max_offset = offset + item_per_page;
@@ -190,9 +190,9 @@ pub const RaphaelController = struct {
         }
 
         for (temp_result) |item| {
-            var tags = std.ArrayList([]u8).init(allocator);
+            var tags = try std.ArrayList([]u8).initCapacity(allocator, 1);
             for (item.metadata.tags.items) |tag| {
-                try tags.append(tag.items);
+                try tags.append(allocator, tag.items);
             }
 
             const data_query: QueryResult = .{
@@ -205,7 +205,7 @@ pub const RaphaelController = struct {
                 .weight = item.weight,
             };
 
-            try result_item.append(data_query);
+            try result_item.append(allocator, data_query);
         }
 
         try res.json(.Ok, .{
diff --git a/src/document.zig b/src/document.zig
index 3cfa53d..cf55b37 100644
--- a/src/document.zig
+++ b/src/document.zig
@@ -25,27 +25,27 @@ pub const Document = struct {
 
     pub fn parse(allocator: Allocator, contents: []const u8) !Self {
         // TODO : Refactor this stuff
-        var metadata = Metadata.init(allocator);
+        var metadata = try Metadata.init(allocator);
         if (std.mem.startsWith(u8, contents, "---")) {
             var skipHeader = std.mem.splitSequence(u8, contents, "---");
             _ = skipHeader.next().?;
             const header = skipHeader.next().?;
             var parser = try YAMLParser.init(allocator, header);
-            const meta = try parser.parse(allocator);
-            defer meta.deinit();
+            var meta = try parser.parse(allocator);
+            defer meta.deinit(allocator);
             for (meta.items) |item| {
                 switch (item) {
                     .Scalar => |n| {
                         if (std.mem.eql(u8, n.key.items, "description")) {
-                            try metadata.description.appendSlice(n.value.items);
+                            try metadata.description.appendSlice(allocator, n.value.items);
                         }
                     },
                     .Sequence => |n| {
                         if (std.mem.eql(u8, n.key.items, "tags")) {
                             for (n.value.items) |tag| {
                                 var tag_temp = try std.ArrayList(u8).initCapacity(allocator, tag.items.len);
-                                try tag_temp.appendSlice(tag.items);
-                                try metadata.tags.append(tag_temp);
+                                try tag_temp.appendSlice(allocator, tag.items);
+                                try metadata.tags.append(allocator, tag_temp);
                             }
                         }
                     },
@@ -55,7 +55,7 @@ pub const Document = struct {
         }
 
         if (metadata.description.items.len <= 0) {
-            try metadata.description.appendSlice("No description provided");
+            try metadata.description.appendSlice(allocator, "No description provided");
         }
         const tf_map = try tf.TermFreq.parse(allocator, contents);
 
@@ -175,7 +175,7 @@ pub const TermFreqDocuments = struct {
     }
 
     pub fn search(self: *Self, allocator: Allocator, term: []const u8) !std.ArrayList(SearchResult) {
-        var result = std.ArrayList(SearchResult).init(allocator);
+        var result = try std.ArrayList(SearchResult).initCapacity(allocator, 10);
 
         var tfi_iter = self.map.iterator();
         const term_uppercase = try std.ascii.allocUpperString(allocator, term);
@@ -191,7 +191,7 @@ pub const TermFreqDocuments = struct {
             // We don't give a frick with infinite rank like ur mom
             if (std.math.isInf(rank) or std.math.isNan(rank) or rank <= 0) continue;
 
-            try result.append(SearchResult.init(e.key_ptr.*, e.value_ptr.metadata, rank));
+            try result.append(allocator, SearchResult.init(e.key_ptr.*, e.value_ptr.metadata, rank));
         }
 
         std.mem.sort(SearchResult, result.items, {}, SearchResult.compareAsc);
diff --git a/src/http/request.zig b/src/http/request.zig
index 7c5ca6e..e6e9cd5 100644
--- a/src/http/request.zig
+++ b/src/http/request.zig
@@ -94,17 +94,17 @@ pub const Request = struct {
         };
     }
 
-    pub fn parseBody(self: *Self, reader: anytype) !void {
+    pub fn parseBody(self: *Self, reader: *std.Io.Reader) !void {
         const length_option = self.headers.get("Content-Length");
         var length: i32 = 0;
         if (length_option != null) length = try std.fmt.parseInt(u8, length_option.?, 10);
 
-        var str = std.ArrayList(u8).init(self.allocator);
+        var str = try std.ArrayList(u8).initCapacity(self.allocator, 256);
         while (length > 0) {
             length -= 1;
 
-            const byte = try reader.readByte();
-            try str.append(byte);
+            const byte = try reader.takeByte();
+            try str.append(self.allocator, byte);
         }
         self.body = str;
     }
@@ -113,6 +113,6 @@ pub const Request = struct {
         self.headers.deinit();
         self.query.deinit();
         self.params.deinit();
-        if (self.body != null) self.body.?.deinit();
+        if (self.body != null) self.body.?.deinit(self.allocator);
     }
 };
diff --git a/src/http/response.zig b/src/http/response.zig
index 2f116ca..e9d490b 100644
--- a/src/http/response.zig
+++ b/src/http/response.zig
@@ -50,31 +50,34 @@ pub const Response = struct {
     }
 
     pub fn json(self: *Self, code: HTTPStatus, content: anytype) !void {
-        const data = try std.json.stringifyAlloc(self.arena.allocator(), content, .{});
-        try self.response(code, .JSON, data);
+        var buffer_allocating = std.Io.Writer.Allocating.init(self.arena.allocator());
+        var writer = buffer_allocating.writer;
+        var jw = std.json.Stringify{ .writer = &writer, .options = .{ .whitespace = .minified } };
+        try jw.write(content);
+        try self.response(code, .JSON, buffer_allocating.toArrayList().items);
     }
 
     pub fn send(self: *Self, stream: std.net.Stream) !void {
         var strResponse = try std.ArrayList(u8).initCapacity(self.arena.allocator(), 1024);
-        defer strResponse.deinit();
+        defer strResponse.deinit(self.arena.allocator());
 
         const httpCode = try std.fmt.allocPrint(self.arena.allocator(), "HTTP/1.1 {} {s}\r\n", .{
             @intFromEnum(self.status),
             self.status.to_string(),
         });
         defer self.arena.allocator().free(httpCode);
-        try strResponse.appendSlice(httpCode);
+        try strResponse.appendSlice(self.arena.allocator(), httpCode);
 
         if (self.body != null) {
             const content_type = try std.fmt.allocPrint(self.arena.allocator(), "Content-Type: {s}\r\n", .{self.content_type.to_string()});
-            try strResponse.appendSlice(content_type);
+            try strResponse.appendSlice(self.arena.allocator(), content_type);
             defer self.arena.allocator().free(content_type);
 
             const content_length = try std.fmt.allocPrint(self.arena.allocator(), "Content-Length: {}\r\n\r\n", .{self.body.?.len});
-            try strResponse.appendSlice(content_length);
+            try strResponse.appendSlice(self.arena.allocator(), content_length);
             defer self.arena.allocator().free(content_length);
 
-            try strResponse.appendSlice(self.body.?);
+            try strResponse.appendSlice(self.arena.allocator(), self.body.?);
         }
 
         _ = try stream.write(strResponse.items);
diff --git a/src/http/router.zig b/src/http/router.zig
index c5a3454..a5225c7 100644
--- a/src/http/router.zig
+++ b/src/http/router.zig
@@ -15,20 +15,20 @@ pub const Router = struct {
 
     const Self = @This();
 
-    pub fn init(allocator: Allocator) Self {
+    pub fn init(allocator: Allocator) !Self {
         return Self{
-            .routes = std.ArrayList(Route).init(allocator),
+            .routes = try std.ArrayList(Route).initCapacity(allocator, 10),
             .allocator = allocator,
             .not_found = null,
         };
     }
 
-    pub fn deinit(self: Self) void {
-        self.routes.deinit();
+    pub fn deinit(self: *Self) void {
+        self.routes.deinit(self.allocator);
     }
 
     pub fn add(self: *Self, path: []const u8, method: Method, ctx: *anyopaque, handler: anytype) !void {
-        try self.routes.append(Route.init(path, method, ctx, handler));
+        try self.routes.append(self.allocator, Route.init(path, method, ctx, handler));
     }
 
     pub fn get(self: *Self, path: []const u8, ctx: *anyopaque, handler: anytype) !void {
diff --git a/src/http/server.zig b/src/http/server.zig
index 3715a80..506471c 100644
--- a/src/http/server.zig
+++ b/src/http/server.zig
@@ -34,8 +34,8 @@ pub const Server = struct {
     }
 
     pub fn listen(self: *Self) !void {
-        var server = try self.addr.listen(.{ .reuse_address = true, .reuse_port = true });
-        std.debug.print("Listening at {}\n", .{server.listen_address});
+        var server = try self.addr.listen(.{ .reuse_address = true });
+        std.debug.print("Listening at {any}\n", .{server.listen_address.in});
         defer server.deinit();
 
         // TODO : MEM LEAK SOMEWHERE
@@ -57,31 +57,24 @@ fn handle(parent_allocator: Allocator, router: Router, client: net.Server.Connec
     const allocator = arena.allocator();
     defer arena.deinit();
 
-    var buffer = String.init(allocator);
-    defer buffer.deinit();
-    const writer = buffer.writer();
-
-    var buffered_reader = std.io.bufferedReader(client.stream.reader());
-    var reader = buffered_reader.reader();
+    var buffer = std.Io.Writer.Allocating.init(allocator);
+    buffer.deinit();
+    var writer = buffer.writer;
 
     var buf: [1024]u8 = undefined;
+    var reader = client.stream.reader(&buf).interface_state;
+
     while (true) {
-        const line = reader.readUntilDelimiter(&buf, '\n') catch {
+        _ = reader.stream(&writer, .unlimited) catch {
             break;
         };
-        const trimmed = std.mem.trimRight(u8, line, "\r");
-
-        if (trimmed.len == 0) break;
-
-        _ = try writer.write(trimmed);
-        _ = try writer.write("\r\n");
     }
 
-    var request = try Request.parseHeader(allocator, buffer.items);
+    var request = try Request.parseHeader(allocator, buffer.toArrayList().items);
     defer request.deinit();
-    try request.parseBody(reader);
+    try request.parseBody(&reader);
 
-    std.debug.print("[{s}] {} - {s}\n", .{ request.method.to_string(), client.address, request.path });
+    std.debug.print("[{s}] {any} - {s}\n", .{ request.method.to_string(), client.address.in, request.path });
 
     var response = Response.init(allocator);
     defer response.deinit();
diff --git a/src/main.zig b/src/main.zig
index edc0cb7..bbcb1a9 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -12,9 +12,11 @@ pub fn main() !void {
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
 
-    const stderr = std.io.getStdErr().writer();
+    const stderr_file = std.fs.File.stderr();
+    var buffer: [1024]u8 = undefined;
+    var stderr = stderr_file.writer(&buffer).interface;
 
-    var args = flag.ArgsParser.init(allocator);
+    var args = try flag.ArgsParser.init(allocator);
     defer args.deinit();
     const prog = args.program();
     const dir = try args.flag_str("index", null, "Index a directory");
@@ -24,12 +26,12 @@ pub fn main() !void {
 
     const parse_result = !try args.parse();
     if (parse_result) {
-        try usage(stderr, &args, prog.*.?);
+        try usage(&stderr, &args, prog.*.?);
         return;
     }
 
     if (help.*) {
-        try usage(stderr, &args, prog.*.?);
+        try usage(&stderr, &args, prog.*.?);
         return;
     }
 
diff --git a/src/metadata.zig b/src/metadata.zig
index 4ddb177..d70d5ed 100644
--- a/src/metadata.zig
+++ b/src/metadata.zig
@@ -16,10 +16,10 @@ pub const MetaData = struct {
 
     const Self = @This();
 
-    pub fn init(allocator: Allocator) Self {
+    pub fn init(allocator: Allocator) !Self {
         return Self{
-            .tags = std.ArrayList(String).init(allocator),
-            .description = String.init(allocator),
+            .tags = try std.ArrayList(String).initCapacity(allocator, 10),
+            .description = try String.initCapacity(allocator, 10),
             .allocator = allocator,
         };
     }
@@ -39,13 +39,13 @@ pub const MetaData = struct {
     }
 
     pub fn deserializeJson(allocator: Allocator, object: std.json.ObjectMap) Error!Self {
-        var self = Self.init(allocator);
+        var self = try Self.init(allocator);
 
         const description = object.get("description");
         if (description == null) {
             return Error.InvalidDescription;
         }
-        try self.description.appendSlice(description.?.string);
+        try self.description.appendSlice(allocator, description.?.string);
 
         const tags = object.get("tags");
         if (tags == null) {
@@ -53,8 +53,8 @@ pub const MetaData = struct {
         }
         for (tags.?.array.items) |item| {
             var str = try String.initCapacity(allocator, item.string.len);
-            try str.appendSlice(item.string);
-            try self.tags.append(str);
+            try str.appendSlice(allocator, item.string);
+            try self.tags.append(allocator, str);
         }
 
         return self;
@@ -62,9 +62,9 @@ pub const MetaData = struct {
 
     pub fn deinit(self: *Self) void {
         for (self.tags.items) |item| {
-            item.deinit();
+            item.deinit(self.allocator);
         }
-        self.tags.deinit();
-        self.description.deinit();
+        self.tags.deinit(self.allocator);
+        self.description.deinit(self.allocator);
     }
 };
diff --git a/src/root.zig b/src/root.zig
index b5c2cd2..4496946 100644
--- a/src/root.zig
+++ b/src/root.zig
@@ -10,13 +10,13 @@ pub const Http = @import("./http/http.zig");
 
 const Allocator = std.mem.Allocator;
 
-fn json_config() std.json.StringifyOptions {
+fn json_config() std.json.Stringify.Options {
     const mode = @import("builtin").mode;
     if (mode == .Debug) {
-        return std.json.StringifyOptions{ .whitespace = .indent_1 };
+        return std.json.Stringify.Options{ .whitespace = .indent_1 };
     }
 
-    return std.json.StringifyOptions{ .whitespace = .minified };
+    return std.json.Stringify.Options{ .whitespace = .minified };
 }
 
 pub fn cmd_index(allocator: Allocator, directory: []const u8) !void {
@@ -25,11 +25,12 @@ pub fn cmd_index(allocator: Allocator, directory: []const u8) !void {
 
     try tfi.index(directory);
 
-    var buffer = std.ArrayList(u8).init(allocator);
-    defer buffer.deinit();
+    var buffer = try std.ArrayList(u8).initCapacity(allocator, 4096);
+    defer buffer.deinit(allocator);
 
-    var jw = std.json.writeStream(buffer.writer(), json_config());
-    defer jw.deinit();
+    const buffer_allocating = std.Io.Writer.Allocating.init(allocator);
+    var writer = buffer_allocating.writer;
+    var jw = std.json.Stringify{ .writer = &writer, .options = json_config() };
     try tfi.serializeJson(&jw);
 
     var index_file = try std.fs.cwd().createFile("index.json", .{});
@@ -38,18 +39,20 @@ pub fn cmd_index(allocator: Allocator, directory: []const u8) !void {
 }
 
 pub fn load_index(allocator: Allocator) !TermFreqDocument {
-    var str = std.ArrayList(u8).init(allocator);
-    defer str.deinit();
+    var str = try std.ArrayList(u8).initCapacity(allocator, 4096);
+    defer str.deinit(allocator);
 
     var fd = try std.fs.cwd().openFile("index.json", .{});
     defer fd.close();
-    var buf_reader = std.io.bufferedReader(fd.reader());
-    var in_reader = buf_reader.reader();
+    var buffer: [4096]u8 = undefined;
+    var buf_reader = fd.reader(&buffer);
 
     var buf: [4096]u8 = undefined;
-    while (try in_reader.readUntilDelimiterOrEof(&buf, '\n')) |line| {
-        try str.appendSlice(line);
-        try str.append('\n');
+    while (buf_reader.atEnd()) {
+        const size = buf_reader.read(&buf) catch {
+            break;
+        };
+        try str.appendSlice(allocator, buf[0..size]);
     }
     return try TermFreqDocument.fromJson(allocator, str.items);
 }

From e3dbd53f2cc10dcf5de05fd35d4b80da45bc9cfb Mon Sep 17 00:00:00 2001
From: UnknownRori <68576836+UnknownRori@users.noreply.github.com>
Date: Sun, 5 Oct 2025 10:46:13 +0700
Subject: [PATCH 4/5] fix: index, but not yet search

---
 src/app.zig  | 4 ++--
 src/main.zig | 7 ++++---
 src/root.zig | 9 ++++-----
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/app.zig b/src/app.zig
index f1e834e..88caeac 100644
--- a/src/app.zig
+++ b/src/app.zig
@@ -11,8 +11,8 @@ pub fn search(allocator: std.mem.Allocator, term: []const u8) !void {
     var tfi = try lib.load_index(allocator);
     defer tfi.deinit();
 
-    const result = try tfi.search(allocator, term);
-    defer result.deinit();
+    var result = try tfi.search(allocator, term);
+    defer result.deinit(allocator);
     for (result.items) |item| {
         item.print();
     }
diff --git a/src/main.zig b/src/main.zig
index bbcb1a9..f65e716 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -13,8 +13,8 @@ pub fn main() !void {
     const allocator = gpa.allocator();
 
     const stderr_file = std.fs.File.stderr();
-    var buffer: [1024]u8 = undefined;
-    var stderr = stderr_file.writer(&buffer).interface;
+    // For some reason it fail in here if using buffer
+    var stderr = stderr_file.writer(&.{}).interface;
 
     var args = try flag.ArgsParser.init(allocator);
     defer args.deinit();
@@ -36,7 +36,7 @@ pub fn main() !void {
     }
 
     if (search.* != null) {
-        try app.index(allocator, dir.*.?);
+        try app.search(allocator, search.*.?);
     } else if (serve.*) {
         try app.serve(allocator);
     } else if (dir.* != null) {
@@ -48,4 +48,5 @@ fn usage(stdout: anytype, args: *flag.ArgsParser, program: []const u8) !void {
     try stdout.print("USAGE: {s} [OPTIONS]\n", .{program});
     try stdout.print("OPTIONS:\n", .{});
     try args.options_print(stdout);
+    try stdout.flush();
 }
diff --git a/src/root.zig b/src/root.zig
index 4496946..1bc81d7 100644
--- a/src/root.zig
+++ b/src/root.zig
@@ -25,17 +25,16 @@ pub fn cmd_index(allocator: Allocator, directory: []const u8) !void {
 
     try tfi.index(directory);
 
-    var buffer = try std.ArrayList(u8).initCapacity(allocator, 4096);
-    defer buffer.deinit(allocator);
-
-    const buffer_allocating = std.Io.Writer.Allocating.init(allocator);
+    var buffer_allocating = std.Io.Writer.Allocating.init(allocator);
+    try buffer_allocating.ensureTotalCapacity(1024 * 1024);
     var writer = buffer_allocating.writer;
     var jw = std.json.Stringify{ .writer = &writer, .options = json_config() };
     try tfi.serializeJson(&jw);
+    try writer.flush();
 
     var index_file = try std.fs.cwd().createFile("index.json", .{});
     defer index_file.close();
-    try index_file.writeAll(buffer.items);
+    try index_file.writeAll(writer.buffer);
 }
 
 pub fn load_index(allocator: Allocator) !TermFreqDocument {

From da278fc26d8866fb365a86c23c9fd8d09c8e9254 Mon Sep 17 00:00:00 2001
From: UnknownRori <68576836+UnknownRori@users.noreply.github.com>
Date: Sun, 5 Oct 2025 12:27:24 +0700
Subject: [PATCH 5/5] barely working file read and write stream

---
 src/root.zig | 38 +++++++++++++++++++++++---------------
 1 file changed, 23 insertions(+), 15 deletions(-)

diff --git a/src/root.zig b/src/root.zig
index 1bc81d7..ab28175 100644
--- a/src/root.zig
+++ b/src/root.zig
@@ -25,34 +25,42 @@ pub fn cmd_index(allocator: Allocator, directory: []const u8) !void {
 
     try tfi.index(directory);
 
-    var buffer_allocating = std.Io.Writer.Allocating.init(allocator);
-    try buffer_allocating.ensureTotalCapacity(1024 * 1024);
+    var buffer_allocating = try std.Io.Writer.Allocating.initCapacity(allocator, 4096 * 4096);
+    defer buffer_allocating.deinit();
     var writer = buffer_allocating.writer;
     var jw = std.json.Stringify{ .writer = &writer, .options = json_config() };
     try tfi.serializeJson(&jw);
+
+    const str = writer.buffered();
     try writer.flush();
 
     var index_file = try std.fs.cwd().createFile("index.json", .{});
     defer index_file.close();
-    try index_file.writeAll(writer.buffer);
+    try index_file.writeAll(str);
 }
 
 pub fn load_index(allocator: Allocator) !TermFreqDocument {
-    var str = try std.ArrayList(u8).initCapacity(allocator, 4096);
-    defer str.deinit(allocator);
+    // var allocating = try std.Io.Writer.Allocating.initCapacity(allocator, 4096);
+    // defer allocating.deinit();
+    // var writer = allocating.writer;
+
+    var str = try std.ArrayList(u8).initCapacity(allocator, 1);
 
-    var fd = try std.fs.cwd().openFile("index.json", .{});
+    var fd = try std.fs.cwd().openFile("./index.json", .{ .mode = .read_only });
     defer fd.close();
-    var buffer: [4096]u8 = undefined;
-    var buf_reader = fd.reader(&buffer);
-
-    var buf: [4096]u8 = undefined;
-    while (buf_reader.atEnd()) {
-        const size = buf_reader.read(&buf) catch {
-            break;
-        };
-        try str.appendSlice(allocator, buf[0..size]);
+    const stat = try fd.stat();
+    const buf = try allocator.alloc(u8, stat.size);
+    defer allocator.free(buf);
+    var reader = fd.reader(buf);
+
+    while (reader.interface.takeDelimiterExclusive('\n')) |line| {
+        try str.appendSlice(allocator, line);
+        // allocating.clearRetainingCapacity();
+    } else |err| switch (err) {
+        error.EndOfStream => {},
+        error.ReadFailed, error.StreamTooLong => return err,
     }
+    // std.debug.print("{s}\n", .{str.items});
     return try TermFreqDocument.fromJson(allocator, str.items);
 }