const std = @import("std");const io_mod = @import("../../core/shared/io.zig");const pathing = @import("../../core/workspace/pathing.zig");const permission_gate = @import("../../core/permissions/permission_gate.zig");const tool_dispatch = @import("../../core/tooling/tool_dispatch.zig"); const Allocator = std.mem.Allocator; pub const Input = struct {    path: []u8,     pub fn deinit(self: *Input, alloc: Allocator) void {        alloc.free(self.path);        self.* = .{ .path = &.{} };    }}; pub fn decode(ctx: tool_dispatch.DispatchContext, args_json: []const u8) tool_dispatch.DispatchError!tool_dispatch.DecodeResult {    var parsed = std.json.parseFromSlice(std.json.Value, ctx.allocator, args_json, .{}) catch {        return .{ .failure = try ctx.allocator.dupe(u8, "create_folder arguments must be valid JSON") };    };    defer parsed.deinit();     if (parsed.value != .object) {        return .{ .failure = try ctx.allocator.dupe(u8, "create_folder arguments must be an object") };    }     const path_value = parsed.value.object.get("path") orelse {        return .{ .failure = try ctx.allocator.dupe(u8, "create_folder field \"path\" is required") };    };    if (path_value != .string) {        return .{ .failure = try ctx.allocator.dupe(u8, "create_folder field \"path\" must be a string") };    }     const owned_path = try ctx.allocator.dupe(u8, path_value.string);    errdefer ctx.allocator.free(owned_path);     const input = try ctx.allocator.create(Input);    errdefer ctx.allocator.destroy(input);    input.* = .{ .path = owned_path };     return .{ .input = .{ .ptr = input, .deinit_fn = inputDeinit } };} fn inputDeinit(ptr: *anyopaque, alloc: Allocator) void {    const input: *Input = @ptrCast(@alignCast(ptr));    input.deinit(alloc);    alloc.destroy(input);} pub fn validate(_: tool_dispatch.DispatchContext, _: tool_dispatch.ToolInput) tool_dispatch.DispatchError!?[]u8 {    return null;} pub fn call(ctx: tool_dispatch.DispatchContext, erased: tool_dispatch.ToolInput) tool_dispatch.DispatchError!tool_dispatch.ToolResult {    const input = erased.as(Input);     var arena_state = std.heap.ArenaAllocator.init(ctx.allocator);    defer arena_state.deinit();    const arena = arena_state.allocator();     const target = pathing.resolveWorkspaceOrExternalCreatePath(arena, ctx.workspace_root, input.path) catch |err| {        if (err == error.OutOfMemory) return error.OutOfMemory;        return .{ .failure = try std.fmt.allocPrint(ctx.allocator, "Unable to resolve folder target: {s} ({s})", .{ input.path, @errorName(err) }) };    };     const rel = try displayPath(arena, ctx.workspace_root, target);    const zio = io_mod.getIo();    std.Io.Dir.createDirAbsolute(zio, target, .default_dir) catch |err| {        if (err == error.PathAlreadyExists) {            if (!targetIsDirectory(target)) {                return .{ .failure = try std.fmt.allocPrint(ctx.allocator, "create_folder failed: target exists and is not a directory: {s}", .{rel}) };            }            return .{ .success = try std.fmt.allocPrint(ctx.allocator, "directory already exists: {s}", .{rel}) };        }         pathing.ensureParentDirectories(target) catch |parent_err| {            return .{ .failure = try std.fmt.allocPrint(ctx.allocator, "create_folder failed: {s} ({s})", .{ rel, @errorName(parent_err) }) };        };        std.Io.Dir.createDirAbsolute(zio, target, .default_dir) catch {            return .{ .failure = try std.fmt.allocPrint(ctx.allocator, "create_folder failed: {s}", .{rel}) };        };    };     return .{ .success = try std.fmt.allocPrint(ctx.allocator, "created {s}", .{rel}) };} fn displayPath(arena: Allocator, workspace_root: []const u8, absolute_path: []const u8) ![]const u8 {    const rel = try pathing.workspaceRelativePath(arena, workspace_root, absolute_path);    return if (rel.len == 0) "." else rel;} fn targetIsDirectory(path: []const u8) bool {    const stat = std.Io.Dir.cwd().statFile(io_mod.getIo(), path, .{}) catch return false;    return stat.kind == .directory;} pub fn readsOnly(_: tool_dispatch.ToolInput) bool {    return false;} pub fn isIrreversible(_: tool_dispatch.ToolInput) bool {    return false;} const create_folder_dispatch_tool = tool_dispatch.Tool{    .name = "create_folder",    .description = "Create folder dispatch test fixture.",    .gateway_schema = .{        .name = "create_folder",        .description = "Create folder dispatch test fixture.",    },    .executor_kind = .create_folder,    .activity_kind = .write,    .requires_approval = true,    .permission_target_kind = .path_create_parent,    .decode = decode,    .validate = validate,    .call = call,    .reads_only_fn = readsOnly,    .irreversible_fn = isIrreversible,}; fn noopInputDeinit(_: *anyopaque, _: Allocator) void {} fn validateStackInput(alloc: Allocator, input: *Input, workspace_root: []const u8) !?[]u8 {    return validate(.{ .allocator = alloc, .workspace_root = workspace_root }, .{ .ptr = input, .deinit_fn = noopInputDeinit });} fn expectDecodeFailure(args_json: []const u8, reason: []const u8) !void {    const alloc = std.testing.allocator;    const decoded = try decode(.{ .allocator = alloc }, args_json);    switch (decoded) {        .failure => |body| {            defer alloc.free(body);            try std.testing.expectEqualStrings(reason, body);        },        .input => |input| {            defer input.deinit(alloc);            try std.testing.expect(false);        },    }} fn createFolderArgsJson(alloc: Allocator, path: []const u8) ![]u8 {    var out: std.Io.Writer.Allocating = .init(alloc);    defer out.deinit();     try out.writer.writeAll("{\"path\":");    try std.json.Stringify.value(path, .{}, &out.writer);    try out.writer.writeByte('}');    return try out.toOwnedSlice();} fn dispatchCreateFolder(alloc: Allocator, workspace_root: []const u8, path: []const u8) !tool_dispatch.DispatchResult {    const args = try createFolderArgsJson(alloc, path);    defer alloc.free(args);     const registry = tool_dispatch.Registry{ .tools = &.{create_folder_dispatch_tool} };    return tool_dispatch.dispatchToolCall(.{        .allocator = alloc,        .permission_mode = .auto,        .permission_decider = allowDecision,        .workspace_root = workspace_root,    }, registry, .{        .id = "call_1",        .name = "create_folder",        .arguments_json = args,    });} fn allowDecision(_: *const tool_dispatch.Tool, _: tool_dispatch.ToolInput, _: tool_dispatch.DispatchContext) permission_gate.Decision {    return .{ .action = .allow, .reason = "allowed by test" };} fn workspaceRoot(alloc: Allocator, tmp: std.testing.TmpDir) ![]u8 {    return io_mod.dirRealpathAlloc(alloc, tmp.dir, ".");} fn writeTempFile(alloc: Allocator, tmp: *std.testing.TmpDir, sub_path: []const u8, content: []const u8) ![]u8 {    if (std.fs.path.dirname(sub_path)) |parent| {        try tmp.dir.createDirPath(io_mod.getIo(), parent);    }    var file = try tmp.dir.createFile(std.testing.io, sub_path, .{});    defer file.close(io_mod.getIo());    try file.writeStreamingAll(io_mod.getIo(), content);    return io_mod.dirRealpathAlloc(alloc, tmp.dir, sub_path);} fn readAbsolute(alloc: Allocator, path: []const u8) ![]u8 {    var file = try std.Io.Dir.openFileAbsolute(io_mod.getIo(), path, .{});    defer file.close(io_mod.getIo());    return io_mod.readFileToEnd(alloc, &file, 1024 * 1024);} test "create_folder rejects invalid JSON" {    try expectDecodeFailure("{", "create_folder arguments must be valid JSON");} test "create_folder rejects non-object JSON" {    try expectDecodeFailure("[]", "create_folder arguments must be an object");} test "create_folder rejects missing path" {    try expectDecodeFailure("{}", "create_folder field \"path\" is required");} test "create_folder rejects non-string path" {    try expectDecodeFailure("{\"path\":1}", "create_folder field \"path\" must be a string");} test "create_folder leaves path normalization to active resolver" {    const alloc = std.testing.allocator;    var empty = Input{ .path = try alloc.dupe(u8, "") };    defer empty.deinit(alloc);    try std.testing.expect((try validateStackInput(alloc, &empty, "/tmp/workspace")) == null);     var whitespace_path = Input{ .path = try alloc.dupe(u8, " \t\r\n ") };    defer whitespace_path.deinit(alloc);    try std.testing.expect((try validateStackInput(alloc, &whitespace_path, "/tmp/workspace")) == null);} test "create_folder creates directory" {    const alloc = std.testing.allocator;    var tmp = std.testing.tmpDir(.{});    defer tmp.cleanup();    const workspace = try workspaceRoot(alloc, tmp);    defer alloc.free(workspace);    const path = try std.fs.path.join(alloc, &.{ workspace, "new-dir" });    defer alloc.free(path);     const result = try dispatchCreateFolder(alloc, workspace, "new-dir");    defer result.deinit(alloc);     try std.testing.expectEqual(.success, result.status);    try std.testing.expectEqualStrings("created new-dir", result.body);    const stat = try std.Io.Dir.cwd().statFile(io_mod.getIo(), path, .{});    try std.testing.expectEqual(std.Io.File.Kind.directory, stat.kind);} test "create_folder creates missing intermediate parents" {    const alloc = std.testing.allocator;    var tmp = std.testing.tmpDir(.{});    defer tmp.cleanup();    const workspace = try workspaceRoot(alloc, tmp);    defer alloc.free(workspace);    const path = try std.fs.path.join(alloc, &.{ workspace, "nested/dir/new-dir" });    defer alloc.free(path);     const result = try dispatchCreateFolder(alloc, workspace, "nested/dir/new-dir");    defer result.deinit(alloc);     try std.testing.expectEqual(.success, result.status);    try std.testing.expectEqualStrings("created nested/dir/new-dir", result.body);    const stat = try std.Io.Dir.cwd().statFile(io_mod.getIo(), path, .{});    try std.testing.expectEqual(std.Io.File.Kind.directory, stat.kind);} test "create_folder returns idempotent success for existing directory" {    const alloc = std.testing.allocator;    var tmp = std.testing.tmpDir(.{});    defer tmp.cleanup();    try tmp.dir.createDirPath(io_mod.getIo(), "existing");    const workspace = try workspaceRoot(alloc, tmp);    defer alloc.free(workspace);     const result = try dispatchCreateFolder(alloc, workspace, "existing");    defer result.deinit(alloc);     try std.testing.expectEqual(.success, result.status);    try std.testing.expectEqualStrings("directory already exists: existing", result.body);} test "create_folder returns failure when regular file exists" {    const alloc = std.testing.allocator;    var tmp = std.testing.tmpDir(.{});    defer tmp.cleanup();    const file_path = try writeTempFile(alloc, &tmp, "existing", "file\n");    defer alloc.free(file_path);    const workspace = try workspaceRoot(alloc, tmp);    defer alloc.free(workspace);     const result = try dispatchCreateFolder(alloc, workspace, "existing");    defer result.deinit(alloc);     try std.testing.expectEqual(.failure, result.status);    try std.testing.expectEqualStrings("create_folder failed: target exists and is not a directory: existing", result.body);    try std.testing.expect(std.mem.find(u8, result.body, workspace) == null);    const content = try readAbsolute(alloc, file_path);    defer alloc.free(content);    try std.testing.expectEqualStrings("file\n", content);} test "create_folder accepts external absolute path" {    const alloc = std.testing.allocator;    var tmp = std.testing.tmpDir(.{});    defer tmp.cleanup();    try tmp.dir.createDirPath(io_mod.getIo(), "workspace");    const outside = try io_mod.dirRealpathAlloc(alloc, tmp.dir, ".");    defer alloc.free(outside);    const outside_target = try std.fs.path.join(alloc, &.{ outside, "outside-dir" });    defer alloc.free(outside_target);    const workspace = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace");    defer alloc.free(workspace);     const result = try dispatchCreateFolder(alloc, workspace, outside_target);    defer result.deinit(alloc);     const expected = try std.fmt.allocPrint(alloc, "created {s}", .{outside_target});    defer alloc.free(expected);    try std.testing.expectEqual(.success, result.status);    try std.testing.expectEqualStrings(expected, result.body);    const stat = try std.Io.Dir.cwd().statFile(io_mod.getIo(), outside_target, .{});    try std.testing.expectEqual(std.Io.File.Kind.directory, stat.kind);} test "create_folder rejects dangling symlink escaping workspace" {    if (comptime @import("builtin").os.tag == .windows) return error.SkipZigTest;     const alloc = std.testing.allocator;    var tmp = std.testing.tmpDir(.{});    defer tmp.cleanup();    try tmp.dir.createDirPath(io_mod.getIo(), "workspace");    try tmp.dir.createDirPath(io_mod.getIo(), "external");    const workspace = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "workspace");    defer alloc.free(workspace);    const external = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "external");    defer alloc.free(external);    const outside_target = try std.fs.path.join(alloc, &.{ external, "created-dir" });    defer alloc.free(outside_target);    tmp.dir.symLink(std.testing.io, outside_target, "workspace/outside-link", .{ .is_directory = true }) catch |err| {        if (err == error.AccessDenied or std.mem.eql(u8, @errorName(err), "Permission" ++ "Denied")) return error.SkipZigTest;        return err;    };     const result = try dispatchCreateFolder(alloc, workspace, "outside-link");    defer result.deinit(alloc);     try std.testing.expectEqual(.failure, result.status);    try std.testing.expectEqualStrings("Unable to resolve folder target: outside-link (PathOutsideWorkspace)", result.body);    try std.testing.expectError(error.FileNotFound, std.Io.Dir.cwd().statFile(io_mod.getIo(), outside_target, .{}));} test "create_folder classifiers are mutating and reversible" {    const input = try std.testing.allocator.create(Input);    input.* = .{ .path = try std.testing.allocator.dupe(u8, "dir") };    const erased = tool_dispatch.ToolInput{ .ptr = input, .deinit_fn = inputDeinit };    defer erased.deinit(std.testing.allocator);     try std.testing.expect(!readsOnly(erased));    try std.testing.expect(!isIrreversible(erased));}