Skip to content

graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs

Python
13.4 KB
Raw Blame
//! Line-composer image chips (#702).
//!
//! Ctrl-V / drop stage pixels on `Agent.pending_images` and insert `[Image #N]`.
//! Deleting a chip must drop that queue slot and rewrite remaining numbers so
//! the next paste is `#1` again — not a ghost `#2`. Content-derived paste
//! traces wait until submit (ADR 0056).

const std = @import("std");
const Allocator = std.mem.Allocator;

const Agent = @import("agent.zig").Agent;
const vision = @import("vision.zig");
const vision_queue = @import("vision_queue.zig");
const input_util = @import("input_util.zig");
const readline_keys = @import("readline_keys.zig");
const PasteStore = @import("readline_paste.zig").Store;

pub const Chip = struct { start: usize, end: usize, n: u8 };

/// `[Image #N]` starting at `i`, or null.
pub fn imageChipAt(text: []const u8, i: usize) ?Chip {
    if (!std.mem.startsWith(u8, text[i..], "[Image #")) return null;
    var p = i + "[Image #".len;
    var num: u16 = 0;
    while (p < text.len and text[p] >= '0' and text[p] <= '9') : (p += 1) {
        num = num *% 10 + (text[p] - '0');
    }
    if (num < 1 or num > vision_queue.cap or p >= text.len or text[p] != ']') return null;
    return .{ .start = i, .end = p + 1, .n = @intCast(num) };
}

/// Start of the image chip that `cur` is inside (including a trailing space).
pub fn left(text: []const u8, cur: usize) ?usize {
    var i: usize = 0;
    while (i < text.len) {
        if (imageChipAt(text, i)) |chip| {
            var end = chip.end;
            if (end < text.len and text[end] == ' ') end += 1;
            if (cur > chip.start and cur <= end) return chip.start;
            i = chip.end;
            continue;
        }
        i += 1;
    }
    return null;
}

/// End of the image chip that `cur` is inside (including a trailing space).
pub fn right(text: []const u8, cur: usize) ?usize {
    var i: usize = 0;
    while (i < text.len) {
        if (imageChipAt(text, i)) |chip| {
            var end = chip.end;
            if (end < text.len and text[end] == ' ') end += 1;
            if (cur >= chip.start and cur < end) return end;
            i = chip.end;
            continue;
        }
        i += 1;
    }
    return null;
}

/// Word motion/deletion must not enter an image chip. Modified Backspace used
/// the generic word boundary and turned `[Image #2] ` into literal `[Image`.
pub fn prevWord(text: []const u8, cur: usize, pastes: *const PasteStore) usize {
    return left(text, cur) orelse pastes.prevWord(text, cur);
}

pub fn nextWord(text: []const u8, cur: usize, pastes: *const PasteStore) usize {
    return right(text, cur) orelse pastes.nextWord(text, cur);
}

/// Drop composer slots the buffer no longer names and rewrite remaining `#N`s.
pub fn afterEdit(root: *Agent, gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize) void {
    var composer_slots: u16 = 0;
    for (root.pending_images[0..root.pending_image_len], 0..) |img, i| {
        if (img.from_composer) composer_slots |= @as(u16, 1) << @intCast(i);
    }
    const remap = vision_queue.retainReferenced(root, buf.items);
    rewriteChips(gpa, buf, cur, remap, composer_slots);
}

pub fn deleteAtom(root: *Agent, gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize, pastes: *PasteStore, from: usize, to: usize) void {
    pastes.edited(gpa, from, to, 0);
    input_util.delRange(buf, from, to);
    afterEdit(root, gpa, buf, cur);
}

pub fn deleteModified(root: *Agent, gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize, pastes: *PasteStore, action: readline_keys.ModifiedDelete) bool {
    const start = switch (action) {
        .delete_word => prevWord(buf.items, cur.*, pastes),
        .delete_to_start => 0,
    };
    if (start >= cur.*) return false;
    const old_cur = cur.*;
    deleteAtom(root, gpa, buf, cur, pastes, start, old_cur);
    cur.* = start;
    return true;
}

pub fn clearLine(root: *Agent, gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize, pastes: *PasteStore) void {
    buf.clearRetainingCapacity();
    pastes.clear(gpa);
    cur.* = 0;
    afterEdit(root, gpa, buf, cur);
}

/// Rewrite `[Image #old]` to the compacted chip numbers. Identity is a no-op.
pub fn rewriteChips(gpa: Allocator, buf: *std.ArrayList(u8), cur: *usize, remap: vision_queue.Remap, composer_slots: u16) void {
    var out: std.ArrayList(u8) = .empty;
    defer out.deinit(gpa);
    var i: usize = 0;
    var new_cur = cur.*;
    var changed = false;
    while (i < buf.items.len) {
        if (imageChipAt(buf.items, i)) |chip| {
            const new_n: u8 = if (chip.n >= 1 and chip.n <= vision_queue.cap) remap[chip.n - 1] else 0;
            const was_composer = chip.n >= 1 and chip.n <= vision_queue.cap and
                (composer_slots & (@as(u16, 1) << @intCast(chip.n - 1))) != 0;
            if (new_n == 0 and was_composer) {
                changed = true;
                var end = chip.end;
                if (end < buf.items.len and buf.items[end] == ' ') end += 1;
                if (cur.* >= end) {
                    new_cur -= end - chip.start;
                } else if (cur.* > chip.start) {
                    new_cur = out.items.len;
                }
                i = end;
                continue;
            }
            var tmp: [20]u8 = undefined;
            const repl = if (new_n == 0 or new_n == chip.n)
                buf.items[chip.start..chip.end]
            else blk: {
                changed = true;
                break :blk std.fmt.bufPrint(&tmp, "[Image #{d}]", .{new_n}) catch buf.items[chip.start..chip.end];
            };
            const old_len = chip.end - chip.start;
            if (cur.* >= chip.end) {
                if (repl.len >= old_len) new_cur += repl.len - old_len else new_cur -= old_len - repl.len;
            } else if (cur.* > chip.start) {
                new_cur = out.items.len + repl.len;
            }
            out.appendSlice(gpa, repl) catch return;
            i = chip.end;
            continue;
        }
        out.append(gpa, buf.items[i]) catch return;
        i += 1;
    }
    if (!changed) return;
    buf.clearRetainingCapacity();
    buf.appendSlice(gpa, out.items) catch return;
    cur.* = @min(new_cur, buf.items.len);
}

pub fn insertComposerChip(
    root: *Agent,
    gpa: Allocator,
    buf: *std.ArrayList(u8),
    cur: *usize,
    marks: *std.ArrayList([]const u8),
    pastes: *PasteStore,
) void {
    vision_queue.markLastComposer(root);
    const at = cur.*;
    input_util.insertImageChip(gpa, buf, cur, marks, root.pending_image_len);
    if (cur.* > at) pastes.edited(gpa, at, at, cur.* - at);
}

fn testAgent(gpa: Allocator) Agent {
    return .{
        .gpa = gpa,
        .arena = gpa,
        .io = undefined,
        .client = undefined,
        .provider = .{ .id = "xai", .kind = .responses, .auth = .bearer, .url = "", .api_key = "", .model = "grok-4", .context = 100_000 },
        .messages = undefined,
        .sub = false,
        .label = "test",
        .out = null,
    };
}

test "Cmd Delete removes UTF-8 prompt prefixes and is idempotent (#981)" {
    const gpa = std.testing.allocator;
    var root = testAgent(gpa);
    var pastes: PasteStore = .{};
    defer pastes.deinit(gpa);
    var buf: std.ArrayList(u8) = .empty;
    defer buf.deinit(gpa);

    try buf.appendSlice(gpa, "é alpha beta");
    var cur = buf.items.len;
    try std.testing.expect(deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_to_start));
    try std.testing.expectEqualStrings("", buf.items);
    try std.testing.expectEqual(@as(usize, 0), cur);
    try std.testing.expect(!deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_to_start));

    try buf.appendSlice(gpa, "é alpha beta");
    cur = "é alpha".len;
    try std.testing.expect(deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_to_start));
    try std.testing.expectEqualStrings(" beta", buf.items);
    try std.testing.expectEqual(@as(usize, 0), cur);
}

test "Option Delete still removes only the previous word (#981)" {
    const gpa = std.testing.allocator;
    var root = testAgent(gpa);
    var pastes: PasteStore = .{};
    defer pastes.deinit(gpa);
    var buf: std.ArrayList(u8) = .empty;
    defer buf.deinit(gpa);
    try buf.appendSlice(gpa, "one two");
    var cur = buf.items.len;

    try std.testing.expect(deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_word));
    try std.testing.expectEqualStrings("one ", buf.items);
    try std.testing.expectEqual(@as(usize, 4), cur);
}

test "Cmd Delete removes a composer image prefix atomically (#981)" {
    const gpa = std.testing.allocator;
    var root = testAgent(gpa);
    vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "one.png", .from_composer = true });
    var pastes: PasteStore = .{};
    defer pastes.deinit(gpa);
    var buf: std.ArrayList(u8) = .empty;
    defer buf.deinit(gpa);
    try buf.appendSlice(gpa, "[Image #1] tail");
    var cur: usize = "[Image #1] ".len;

    try std.testing.expect(deleteModified(&root, gpa, &buf, &cur, &pastes, .delete_to_start));
    try std.testing.expectEqualStrings("tail", buf.items);
    try std.testing.expectEqual(@as(usize, 0), cur);
    try std.testing.expectEqual(@as(u8, 0), root.pending_image_len);
}

test "imageChipAt parses a numbered marker" {
    const chip = imageChipAt("[Image #3] look", 0).?;
    try std.testing.expectEqual(@as(usize, 0), chip.start);
    try std.testing.expectEqual(@as(usize, 10), chip.end);
    try std.testing.expectEqual(@as(u8, 3), chip.n);
    try std.testing.expect(imageChipAt("see [Image #1]", 4) != null);
    try std.testing.expect(imageChipAt("[Image]", 0) == null);
}

test "left/right treat an image chip as one atom (#702)" {
    const text = "hi [Image #1] there";
    try std.testing.expectEqual(@as(usize, 3), left(text, 13).?); // on the trailing space
    try std.testing.expectEqual(@as(usize, 3), left(text, 12).?); // on ]
    try std.testing.expect(left(text, 3) == null);
    try std.testing.expectEqual(@as(usize, 14), right(text, 3).?);
    try std.testing.expect(right(text, 14) == null);
}

test "word deletion keeps repeated image chips atomic" {
    const gpa = std.testing.allocator;
    var pastes: PasteStore = .{};
    defer pastes.deinit(gpa);
    const text = "[Image #1] [Image #2] ";
    try std.testing.expectEqual(@as(usize, 11), prevWord(text, text.len, &pastes));
    try std.testing.expectEqual(@as(usize, text.len), nextWord(text, 11, &pastes));
}

test "afterEdit drops an abandoned chip and remaps the rest (#702)" {
    const gpa = std.testing.allocator;
    var root: Agent = .{
        .gpa = gpa,
        .arena = gpa,
        .io = undefined,
        .client = undefined,
        .provider = .{ .id = "xai", .kind = .responses, .auth = .bearer, .url = "", .api_key = "", .model = "grok-4", .context = 100_000 },
        .messages = undefined,
        .sub = false,
        .label = "test",
        .out = null,
    };
    vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "one.png", .from_composer = true });
    vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "BBB", .label = "two.png", .from_composer = true });
    var buf: std.ArrayList(u8) = .empty;
    defer buf.deinit(gpa);
    try buf.appendSlice(gpa, "[Image #2] look");
    var cur: usize = buf.items.len;
    afterEdit(&root, gpa, &buf, &cur);
    try std.testing.expectEqual(@as(u8, 1), root.pending_image_len);
    try std.testing.expectEqualStrings("BBB", root.pending_images[0].b64);
    try std.testing.expectEqualStrings("[Image #1] look", buf.items);
    try std.testing.expectEqual(@as(u8, 2), vision_queue.nextChipNumber(&root));
}

test "duplicate composer payload drops its stale chip before #2 is reused" {
    const gpa = std.testing.allocator;
    var root: Agent = .{
        .gpa = gpa,
        .arena = gpa,
        .io = undefined,
        .client = undefined,
        .provider = .{ .id = "xai", .kind = .responses, .auth = .bearer, .url = "", .api_key = "", .model = "grok-4", .context = 100_000 },
        .messages = undefined,
        .sub = false,
        .label = "test",
        .out = null,
    };
    vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "same.png", .from_composer = true });
    vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "same.png", .from_composer = true });
    var buf: std.ArrayList(u8) = .empty;
    defer buf.deinit(gpa);
    try buf.appendSlice(gpa, "[Image #1] [Image #2] ");
    var cur: usize = buf.items.len;
    afterEdit(&root, gpa, &buf, &cur);
    try std.testing.expectEqualStrings("[Image #1] ", buf.items);
    try std.testing.expectEqual(@as(usize, buf.items.len), cur);
    try std.testing.expectEqual(@as(u8, 1), root.pending_image_len);

    vision_queue.stage(&root, .{ .media_type = "image/png", .b64 = "AAA", .label = "same.png" });
    var marks: std.ArrayList([]const u8) = .empty;
    defer {
        for (marks.items) |mark| gpa.free(mark);
        marks.deinit(gpa);
    }
    var pastes: PasteStore = .{};
    defer pastes.deinit(gpa);
    insertComposerChip(&root, gpa, &buf, &cur, &marks, &pastes);
    try std.testing.expectEqualStrings("[Image #1] [Image #2] ", buf.items);
}

test "rewriteChips remaps #2 to #1 after the first slot is dropped (#702)" {
    const gpa = std.testing.allocator;
    var buf: std.ArrayList(u8) = .empty;
    defer buf.deinit(gpa);
    try buf.appendSlice(gpa, "[Image #2] look");
    var cur: usize = buf.items.len;
    var remap: vision_queue.Remap = @splat(0);
    remap[1] = 1;
    rewriteChips(gpa, &buf, &cur, remap, @as(u16, 1) << 1);
    try std.testing.expectEqualStrings("[Image #1] look", buf.items);
    try std.testing.expectEqual(@as(usize, buf.items.len), cur);
}