feat: add zup CLI tool for project scaffolding

- Add zup.zig CLI tool for generating gRPC project boilerplate
- Add root.zig to expose framework modules
- Update build system to support zup CLI and module exports
- Update build.zig.zon with new dependencies

Author: 0xrinegade

build.zig

@@ -1,3 +1,4 @@
+
 const std = @import("std");
 
 pub fn build(b: *std.Build) void {
@@ -166,4 +167,34 @@ pub fn build(b: *std.Build) void {
     // Run step
     const run_step = b.step("run", "Run the server executable");
     run_step.dependOn(&run_server_cmd.step);
+
+    // Export modules for other packages
+    _ = b.addModule("zup", .{
+        .root_source_file = .{ .cwd_relative = "src/root.zig" },
+        .imports = &.{
+            .{ .name = "spice", .module = spice_dep.module("spice") },
+            .{ .name = "core", .module = core_module },
+            .{ .name = "framework", .module = framework_module },
+            .{ .name = "schema", .module = schema_module },
+            .{ .name = "runtime_router", .module = runtime_router_module },
+            .{ .name = "grpc_router", .module = grpc_router_module },
+        },
+    });
+
+    // Add zup CLI tool
+    const zup_cli = b.addExecutable(.{
+        .name = "zup",
+        .root_source_file = .{ .cwd_relative = "zup.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+    b.installArtifact(zup_cli);
+
+    const run_zup_cmd = b.addRunArtifact(zup_cli);
+    if (b.args) |args| {
+        run_zup_cmd.addArgs(args);
+    }
+    const run_zup_step = b.step("run-zup", "Run the zup CLI tool");
+    run_zup_step.dependOn(&run_zup_cmd.step);
+
 }

build.zig.zon

@@ -6,10 +6,10 @@
         "build.zig",
         "build.zig.zon",
     },
-    .dependencies = .{
-        .spice = .{
-            .url = "https://github.com/judofyr/spice/archive/main.tar.gz",
-            .hash = "12207a3bcf418fd5e029f56f3c8049165cf07d758b89d499d36f8a6475d21b425ea2",
-        },
+.dependencies = .{
+    .spice = .{
+        .url = "https://github.com/judofyr/spice/archive/main.tar.gz",
+        .hash = "12207a3bcf418fd5e029f56f3c8049165cf07d758b89d499d36f8a6475d21b425ea2",
     },
+},
 }

src/framework/trpc/grpc_test_client.zig

@@ -1,58 +1,90 @@
 const std = @import("std");
 const net = std.net;
 
-pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    const allocator = gpa.allocator();
-    defer _ = gpa.deinit();
-
-    // Connect to server
-    const address = try std.net.Address.parseIp("127.0.0.1", 13370);
-    const stream = try std.net.tcpConnectToAddress(address);
-    defer stream.close();
-
-    // Prepare request
-    var request = std.ArrayList(u8).init(allocator);
-    defer request.deinit();
-
-    const json_request = 
-        \\{"jsonrpc":"2.0","method":"health","id":1}
-    ;
+fn sendRequest(allocator: std.mem.Allocator, stream: net.Stream, request: []const u8) ![]const u8 {
+    var req_buf = std.ArrayList(u8).init(allocator);
+    defer req_buf.deinit();
 
     // Write gRPC header (uncompressed)
-    try request.append(0); // Uncompressed flag
+    try req_buf.append(0);
     var length_bytes: [4]u8 = undefined;
-    std.mem.writeInt(u32, &length_bytes, @intCast(json_request.len), .big);
-    try request.appendSlice(&length_bytes);
-    try request.appendSlice(json_request);
+    std.mem.writeInt(u32, &length_bytes, @intCast(request.len), .big);
+    try req_buf.appendSlice(&length_bytes);
+    try req_buf.appendSlice(request);
 
     // Send request
-    try stream.writeAll(request.items);
+    std.debug.print("Sending request: {s}\n", .{request});
+    try stream.writeAll(req_buf.items);
 
-    // Read response
+    // Read response header
+    std.debug.print("Reading response header...\n", .{});
     var header_buf: [5]u8 = undefined;
     const header_size = try stream.readAll(&header_buf);
-    if (header_size < 5) {
-        std.debug.print("Incomplete header received\n", .{});
-        return;
-    }
+    if (header_size < 5) return error.IncompleteHeader;
 
     const compressed = header_buf[0] == 1;
+    if (compressed) return error.CompressionNotSupported;
+
     const length = std.mem.readInt(u32, header_buf[1..5], .big);
+    const response = try allocator.alloc(u8, length);
+    errdefer allocator.free(response);
 
-    if (compressed) {
-        std.debug.print("Compression not supported\n", .{});
-        return;
+    const response_size = try stream.readAll(response);
+    if (response_size < length) {
+        allocator.free(response);
+        return error.IncompleteResponse;
     }
 
-    const response_buf = try allocator.alloc(u8, length);
-    defer allocator.free(response_buf);
+    std.debug.print("Received response of size {d}\n", .{response_size});
+    return response;
+}
 
-    const response_size = try stream.readAll(response_buf);
-    if (response_size < length) {
-        std.debug.print("Incomplete response received\n", .{});
-        return;
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+    defer _ = gpa.deinit();
+
+    const address = try std.net.Address.parseIp("127.0.0.1", 13370);
+
+    // Test health endpoint
+    {
+        std.debug.print("\nTesting health endpoint...\n", .{});
+        const stream = try std.net.tcpConnectToAddress(address);
+        defer stream.close();
+        
+        const health_req = 
+            \\{"jsonrpc":"2.0","method":"health","id":1}
+        ;
+        const health_resp = try sendRequest(allocator, stream, health_req);
+        defer allocator.free(health_resp);
+        std.debug.print("Health response: {s}\n", .{health_resp});
     }
 
-    std.debug.print("Response: {s}\n", .{response_buf});
+    // Test getUser endpoint
+    {
+        std.debug.print("\nTesting getUser endpoint...\n", .{});
+        const stream = try std.net.tcpConnectToAddress(address);
+        defer stream.close();
+        
+        const get_user_req = 
+            \\{"jsonrpc":"2.0","method":"getUser","id":2,"params":{"id":1}}
+        ;
+        const get_user_resp = try sendRequest(allocator, stream, get_user_req);
+        defer allocator.free(get_user_resp);
+        std.debug.print("GetUser response: {s}\n", .{get_user_resp});
+    }
+
+    // Test createUser endpoint
+    {
+        std.debug.print("\nTesting createUser endpoint...\n", .{});
+        const stream = try std.net.tcpConnectToAddress(address);
+        defer stream.close();
+        
+        const create_user_req = 
+            \\{"jsonrpc":"2.0","method":"createUser","id":3,"params":{"name":"Test User","email":"test@example.com"}}
+        ;
+        const create_user_resp = try sendRequest(allocator, stream, create_user_req);
+        defer allocator.free(create_user_resp);
+        std.debug.print("CreateUser response: {s}\n", .{create_user_resp});
+    }
 }

src/root.zig

@@ -0,0 +1,13 @@
+pub const core = @import("framework/core.zig");
+pub const framework = @import("framework/server.zig");
+pub const schema = @import("framework/trpc/schema.zig");
+pub const runtime_router = @import("framework/trpc/runtime_router.zig");
+pub const grpc_router = @import("framework/trpc/grpc_router.zig");
+
+test {
+    _ = core;
+    _ = framework;
+    _ = schema;
+    _ = runtime_router;
+    _ = grpc_router;
+}