xonecas.io
79113
Ma

mini-coding-agent / files

mini-coding-agent / src / main.zig

5.6 KB
1const std = @import("std");
2const platform = @import("platform.zig");
3const config = @import("config.zig");
4const prompt = @import("prompt.zig");
5const models = @import("models.zig");
6const session = @import("session.zig");
7const agent = @import("agent.zig");
8const tools = @import("tools.zig");
9const tui = @import("tui/tui.zig");
10const term = @import("tui/term.zig");
11const headless = @import("headless.zig");
12const message_mod = @import("message.zig");
13
14pub const panic = std.debug.FullPanic(panicRestore);
15
16fn panicRestore(msg: []const u8, ra: ?usize) noreturn {
17    term.restore();
18    std.debug.defaultPanic(msg, ra);
19}
20
21pub const debug = struct {
22    pub fn handleSegfault(addr: ?usize, name: []const u8, ctx: ?std.debug.CpuContextPtr) noreturn {
23        term.restore();
24        std.debug.defaultHandleSegfault(addr, name, ctx);
25    }
26};
27
28var cancel = std.atomic.Value(bool).init(false);
29
30const ParsedArgs = struct {
31    print: ?[]const u8 = null,
32    config: ?[]const u8 = null,
33    resume_id: ?[]const u8 = null,
34    no_config: bool = false,
35    no_session: bool = false,
36};
37
38fn parseArgs(a: std.mem.Allocator) !ParsedArgs {
39    var it = std.process.Args.Iterator.init(platform.args);
40    _ = it.next();
41    var result = ParsedArgs{};
42    while (it.next()) |arg| {
43        if (std.mem.startsWith(u8, arg, "--print=")) {
44            result.print = try a.dupe(u8, arg["--print=".len..]);
45        } else if (std.mem.startsWith(u8, arg, "-p=")) {
46            result.print = try a.dupe(u8, arg["-p=".len..]);
47        } else if (std.mem.eql(u8, arg, "-p") or std.mem.eql(u8, arg, "--print")) {
48            const value = it.next() orelse return error.MissingPrompt;
49            result.print = try a.dupe(u8, value);
50        } else if (std.mem.startsWith(u8, arg, "--config=")) {
51            result.config = try a.dupe(u8, arg["--config=".len..]);
52        } else if (std.mem.eql(u8, arg, "-c") or std.mem.eql(u8, arg, "--config")) {
53            const value = it.next() orelse return error.MissingConfig;
54            result.config = try a.dupe(u8, value);
55        } else if (std.mem.startsWith(u8, arg, "--resume=")) {
56            result.resume_id = try a.dupe(u8, arg["--resume=".len..]);
57        } else if (std.mem.eql(u8, arg, "--resume")) {
58            const value = it.next() orelse return error.MissingSession;
59            result.resume_id = try a.dupe(u8, value);
60        } else if (std.mem.eql(u8, arg, "--no-config")) {
61            result.no_config = true;
62        } else if (std.mem.eql(u8, arg, "--no-session")) {
63            result.no_session = true;
64        } else {
65            platform.printErr("unknown argument: {s}\n", .{arg});
66            return error.UnknownArg;
67        }
68    }
69    return result;
70}
71
72pub fn main(init: std.process.Init) void {
73    platform.setup(init);
74    const code = run() catch |e| {
75        platform.printErr("{s}\n", .{@errorName(e)});
76        std.process.exit(1);
77    };
78    std.process.exit(code);
79}
80
81fn run() !u8 {
82    const a = platform.gpa;
83
84    const args = parseArgs(a) catch |e| {
85        switch (e) {
86            error.MissingPrompt => platform.printErr("a prompt is required\n", .{}),
87            error.MissingConfig => platform.printErr("a config path is required\n", .{}),
88            error.MissingSession => platform.printErr("a session id is required\n", .{}),
89            else => {},
90        }
91        return 1;
92    };
93
94    const cfg = config.load(a, args.config, args.no_config) catch return 1;
95
96    var resolve_err: ?[]const u8 = null;
97    const model = models.resolve(a, &cfg, &resolve_err);
98    if (resolve_err) |message| {
99        platform.printErr("{s}\n", .{message});
100        return 1;
101    }
102
103    const cwd = std.process.currentPathAlloc(platform.io, a) catch ".";
104    var sess = session.Session.init(a, cfg.sessions_dir, cwd);
105    var resumed: std.ArrayList(message_mod.Message) = .empty;
106    if (args.resume_id) |id| {
107        sess.reopen(id, &resumed) catch |e| {
108            switch (e) {
109                error.NoSuchSession => platform.printErr("no session matching '{s}'\n", .{id}),
110                error.AmbiguousSession => platform.printErr("session id '{s}' is ambiguous\n", .{id}),
111                else => platform.printErr("{s}\n", .{@errorName(e)}),
112            }
113            return 1;
114        };
115    } else {
116        sess.disabled = args.no_session;
117    }
118
119    const model_ptr: ?*const models.Model = if (model) |m| blk: {
120        const ptr = try a.create(models.Model);
121        ptr.* = m;
122        break :blk ptr;
123    } else null;
124
125    const supports_images = if (model_ptr) |m| m.supports_images else false;
126    const built = try prompt.buildSystemPrompt(a, &cfg);
127    const opts = agent.Options{
128        .a = a,
129        .model = model_ptr,
130        .system_prompt = built.prompt,
131        .loaded = .{ .agent_files = built.loaded.agent_files, .skills = built.loaded.skills },
132        .tools_json = tools.json(a, cfg.tools, supports_images, cwd),
133        .supports_images = supports_images,
134        .session = &sess,
135        .cancel = &cancel,
136        .config = &cfg,
137    };
138
139    if (args.print) |print_text| {
140        if (model_ptr == null) {
141            platform.printErr("[error] no model configured; add \"provider\" and \"model\" to {s}\n", .{config.configPath(a)});
142            return 1;
143        }
144        return headless.run(a, print_text, opts, resumed.items);
145    }
146
147    const stdin_tty = std.Io.File.stdin().isTty(platform.io) catch false;
148    const stdout_tty = std.Io.File.stdout().isTty(platform.io) catch false;
149    if (!stdin_tty or !stdout_tty) {
150        platform.printErr("interactive mode requires a TTY; use -p for non-interactive mode\n", .{});
151        return 1;
152    }
153    try tui.run(opts, &cfg, cfg.tools, resumed.items);
154    return 0;
155}