tmk241/mim
1
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases Wiki Activity
Files
629605bcdcc1e1a430456fdf10d97ae6bfa684c5
mim/src/tui.zig
T
slhx agent 629605bcdc Fix local editor raw mode and chrome
2026-06-21 15:22:41 +02:00

4904 lines
218 KiB
Zig
Raw Blame History

const std = @import("std");
const context_mod = @import("context.zig");
const diagnostics_mod = @import("diagnostics.zig");
const input = @import("input.zig");
const job_mod = @import("job.zig");
const leader_mod = @import("leader.zig");
const lsp_mod = @import("lsp.zig");
const pi_bridge = @import("pi_bridge.zig");
const protocol = @import("protocol.zig");
const replay = @import("replay.zig");
const repo_mod = @import("repo.zig");
const session_mod = @import("session.zig");
const symbol_mod = @import("symbol.zig");
const syntax_mod = @import("syntax.zig");
// First terminal thin client surface, scriptable for E2E-style tests.
// req: session/001, session/003, ui/001, coding/001, testing/001, testing/002
test {
_ = Client;
}
pub const EditorMode = enum {
normal,
insert,
select,
panel,
prompt,
};
const PrefixRail = enum {
none,
insert_space,
match,
go,
repeat,
delete,
change,
yank,
replace,
};
const PanelContext = enum {
none,
file_picker,
project_search,
language_provider_picker,
code_actions,
};
const EditSnapshot = struct {
bytes: []u8,
cursor_byte: usize,
};
const ObjectRange = struct {
start: usize,
end: usize,
};
const PairRange = struct {
open: usize,
close: usize,
};
pub const Error = error{
ViewportTooSmall,
InvalidResize,
UnknownTraceEvent,
ProtocolRejected,
ClientQuit,
NothingSaved,
};
pub const Viewport = struct {
width: usize,
height: usize,
pub fn validate(self: Viewport) !void {
if (self.width == 0 or self.height < 2) return Error.ViewportTooSmall;
}
};
pub const RenderDiagnostics = struct {
viewport_width: usize,
viewport_height: usize,
frame_bytes: usize,
frame_lines: usize,
max_line_cells: usize,
clipped_sources: usize,
};
pub const RenderResult = struct {
frame: []u8,
diagnostics: RenderDiagnostics,
warning: []u8,
pub fn deinit(self: RenderResult, allocator: std.mem.Allocator) void {
allocator.free(self.frame);
allocator.free(self.warning);
}
};
pub fn runTrace(allocator: std.mem.Allocator, viewport: Viewport, trace: []const u8) !TraceResult {
var client = try Client.init(allocator, viewport);
defer client.deinit();
var lines = std.mem.splitScalar(u8, trace, '\n');
while (lines.next()) |line| {
if (line.len == 0) continue;
try client.handleTraceLine(line);
}
const frame = try client.render(allocator);
errdefer allocator.free(frame);
const saved_bytes = if (client.saved_bytes) |bytes| try allocator.dupe(u8, bytes) else null;
errdefer if (saved_bytes) |bytes| allocator.free(bytes);
return .{ .frame = frame, .saved_bytes = saved_bytes, .quit = client.quit };
}
pub const TraceResult = struct {
frame: []u8,
saved_bytes: ?[]u8,
quit: bool,
pub fn deinit(self: TraceResult, allocator: std.mem.Allocator) void {
allocator.free(self.frame);
if (self.saved_bytes) |bytes| allocator.free(bytes);
}
};
pub const Client = struct {
allocator: std.mem.Allocator,
session: session_mod.Session,
leader: leader_mod.Leader,
repo: repo_mod.Index,
io: ?std.Io,
viewport: Viewport,
current_path: ?[]u8 = null,
job_cwd: ?[]u8 = null,
saved_bytes: ?[]u8 = null,
message: ?[]const u8 = null,
owned_message: ?[]u8 = null,
quit: bool = false,
mode: EditorMode = .normal,
prefix: PrefixRail = .none,
pending_count: usize = 0,
last_rail: PrefixRail = .none,
search_prompt_active: bool = false,
search_prompt: std.ArrayList(u8) = .empty,
search_query: []u8 = &.{},
search_matches: std.ArrayList(usize) = .empty,
search_index: usize = 0,
project_search_prompt_active: bool = false,
project_search_prompt: std.ArrayList(u8) = .empty,
panel_context: PanelContext = .none,
hover_rows: std.ArrayList([]u8) = .empty,
signature_rows: std.ArrayList([]u8) = .empty,
diagnostic_rows: std.ArrayList([]u8) = .empty,
language_edit_rows: std.ArrayList([]u8) = .empty,
format_provider_default: ?[]u8 = null,
format_on_save: bool = true,
skip_next_save_format: bool = false,
pending_language_capability: ?lsp_mod.ProviderCapability = null,
diagnostic_filter: ?[]u8 = null,
diagnostic_index: usize = 0,
diagnostic_selected: bool = false,
document_version: u64 = 1,
undo_stack: std.ArrayList(EditSnapshot) = .empty,
redo_stack: std.ArrayList(EditSnapshot) = .empty,
yank_bytes: ?[]u8 = null,
pub fn init(allocator: std.mem.Allocator, viewport: Viewport) !Client {
return initWithIo(allocator, viewport, null);
}
pub fn initWithIo(allocator: std.mem.Allocator, viewport: Viewport, io: ?std.Io) !Client {
try viewport.validate();
return .{
.allocator = allocator,
.session = session_mod.Session.init(allocator),
.leader = leader_mod.Leader.init(allocator),
.repo = repo_mod.Index.init(allocator),
.io = io,
.viewport = viewport,
};
}
pub fn deinit(self: *Client) void {
if (self.current_path) |path| self.allocator.free(path);
if (self.job_cwd) |cwd| self.allocator.free(cwd);
if (self.saved_bytes) |bytes| self.allocator.free(bytes);
if (self.owned_message) |bytes| self.allocator.free(bytes);
if (self.yank_bytes) |bytes| self.allocator.free(bytes);
self.search_prompt.deinit(self.allocator);
self.project_search_prompt.deinit(self.allocator);
self.allocator.free(self.search_query);
self.search_matches.deinit(self.allocator);
self.freeOwnedClientRows(&self.hover_rows);
self.freeOwnedClientRows(&self.signature_rows);
self.freeOwnedClientRows(&self.diagnostic_rows);
self.freeOwnedClientRows(&self.language_edit_rows);
if (self.format_provider_default) |provider| self.allocator.free(provider);
if (self.diagnostic_filter) |filter| self.allocator.free(filter);
self.freeSnapshotStack(&self.undo_stack);
self.freeSnapshotStack(&self.redo_stack);
self.repo.deinit();
self.leader.deinit();
self.session.deinit();
self.* = undefined;
}
pub fn handleTraceLine(self: *Client, line: []const u8) !void {
if (std.mem.eql(u8, line, "quit")) {
self.quit = true;
return;
}
if (self.quit) return Error.ClientQuit;
if (std.mem.startsWith(u8, line, "key ")) return self.handleTraceKey(line[4..]);
if (std.mem.startsWith(u8, line, "type ")) return self.handleInput(line[5..]);
if (std.mem.startsWith(u8, line, "repo_gitignore ")) return self.repo.addIgnorePattern(line[15..]);
if (std.mem.startsWith(u8, line, "repo_file ")) return self.addRepoFile(line[10..]);
if (std.mem.startsWith(u8, line, "lsp_hover_fixture ")) return self.addHoverFixture(line[18..]);
if (std.mem.startsWith(u8, line, "lsp_signature_fixture ")) return self.addSignatureFixture(line[22..]);
if (std.mem.startsWith(u8, line, "diagnostic_fixture ")) return self.addDiagnosticFixture(line[19..]);
if (std.mem.startsWith(u8, line, "diagnostic_filter ")) return self.setDiagnosticFilter(line[18..]);
if (std.mem.startsWith(u8, line, "language_edit ")) return self.addLanguageEditFixture(line[14..]);
if (std.mem.startsWith(u8, line, "language_default_format ")) return self.setFormatProviderDefault(line[24..]);
if (std.mem.startsWith(u8, line, "format_on_save ")) return self.setFormatOnSavePolicy(line[15..]);
if (std.mem.eql(u8, line, "save_without_format")) return self.saveWithoutFormat();
if (std.mem.startsWith(u8, line, "current_file ")) return self.setCurrentPath(line[13..]);
if (std.mem.startsWith(u8, line, "job_profile ")) return self.openJobProfileByName(line[12..]);
if (std.mem.startsWith(u8, line, "job_missing_tool ")) return self.openMissingToolJob(line[17..]);
if (std.mem.startsWith(u8, line, "job_timeout ")) return self.openTimeoutJob(line[12..]);
if (std.mem.eql(u8, line, "file_picker")) return self.openRepoList("files", false, false);
if (std.mem.eql(u8, line, "file_picker all")) return self.openRepoList("files", false, true);
if (std.mem.eql(u8, line, "file_tree")) return self.openRepoList("tree", true, false);
if (std.mem.eql(u8, line, "file_tree all")) return self.openRepoList("tree", true, true);
if (std.mem.eql(u8, line, "file_open_selected")) return self.openSelectedRepoFile();
if (std.mem.startsWith(u8, line, "search_text all ")) return self.openSearchList(line[16..], true);
if (std.mem.startsWith(u8, line, "search_text ")) return self.openSearchList(line[12..], false);
if (std.mem.eql(u8, line, "search_open_selected")) return self.openSelectedSearchResult();
if (std.mem.startsWith(u8, line, "git_status ")) return self.openGitStatus(line[11..]);
if (std.mem.startsWith(u8, line, "git_diff_selected ")) return self.openSelectedGitDiff(line[18..]);
if (std.mem.startsWith(u8, line, "git_open_changed_selected ")) return self.openSelectedGitFile(line[26..]);
if (std.mem.startsWith(u8, line, "job_run ")) return self.openJobRun(line[8..]);
if (std.mem.eql(u8, line, "job_status")) return self.openStaticJobRow("job-status", "job_status:idle");
if (std.mem.eql(u8, line, "job_cancel")) return self.openStaticJobRow("job-status", "job_cancel:no_running_job");
if (std.mem.startsWith(u8, line, "job_open_selected ")) return self.openSelectedJobLocation(line[18..]);
if (std.mem.eql(u8, line, "job_yank_selected")) return self.yankSelectedJobLine();
if (std.mem.startsWith(u8, line, "terminal_run ")) return self.openTerminalRun(line[13..]);
if (std.mem.eql(u8, line, "terminal_status")) return self.openStaticJobRow("terminal-status", "terminal_status:idle");
if (std.mem.eql(u8, line, "terminal_cancel")) return self.openStaticJobRow("terminal-status", "terminal_cancel:no_running_terminal");
if (std.mem.eql(u8, line, "terminal_exit")) return self.closeTerminalPanel();
if (std.mem.startsWith(u8, line, "syntax_spans ")) return self.openSyntaxSpans(line[13..]);
if (std.mem.startsWith(u8, line, "lsp_sync ")) return self.openLspSync(line[9..]);
if (std.mem.startsWith(u8, line, "lsp_diagnostics ")) return self.openLspDiagnostics(line[16..]);
if (std.mem.eql(u8, line, "lsp_diagnostics_open_selected")) return self.openSelectedLspDiagnostic();
if (std.mem.startsWith(u8, line, "lsp_definition ")) return self.openLspLocations("definition", line[15..]);
if (std.mem.startsWith(u8, line, "lsp_references ")) return self.openLspLocations("references", line[15..]);
if (std.mem.startsWith(u8, line, "lsp_document_symbols ")) return self.openLspSymbols("document", line[21..]);
if (std.mem.startsWith(u8, line, "lsp_workspace_symbols ")) return self.openLspSymbols("workspace", line[22..]);
if (std.mem.eql(u8, line, "lsp_navigation_open_selected")) return self.openSelectedLspNavigation();
if (std.mem.startsWith(u8, line, "lsp_rename ")) return self.openLspWorkspaceEdit("rename", line[11..]);
if (std.mem.startsWith(u8, line, "lsp_code_actions ")) return self.openLspCodeActions(line[17..]);
if (std.mem.eql(u8, line, "lsp_edit_apply_selected")) return self.applySelectedLspEdit();
if (std.mem.startsWith(u8, line, "lsp_hover ")) return self.openLspHover(line[10..]);
if (std.mem.startsWith(u8, line, "lsp_signature ")) return self.openLspSignature(line[14..]);
if (std.mem.eql(u8, line, "lsp_param_next")) return self.moveLspParameter(.next);
if (std.mem.eql(u8, line, "lsp_param_previous")) return self.moveLspParameter(.previous);
if (std.mem.startsWith(u8, line, "pi_run ")) return self.openPiRun(line[7..]);
if (std.mem.startsWith(u8, line, "panel_open ")) return self.applyProtocolCommand(line);
if (std.mem.startsWith(u8, line, "list_open ")) return self.applyProtocolCommand(line);
if (std.mem.startsWith(u8, line, "list_filter ")) return self.applyProtocolCommand(line);
if (std.mem.startsWith(u8, line, "message ")) {
self.message = line[8..];
return;
}
if (std.mem.eql(u8, line, "list_down")) return self.applyProtocol("command list_down");
if (std.mem.eql(u8, line, "list_up")) return self.applyProtocol("command list_up");
if (std.mem.eql(u8, line, "list_select")) return self.applyProtocol("command list_select");
if (std.mem.eql(u8, line, "list_cancel")) return self.applyProtocol("command list_cancel");
if (std.mem.eql(u8, line, "panel_close")) return self.applyProtocol("command panel_close");
if (std.mem.eql(u8, line, "panel_next")) return self.applyProtocol("command panel_next");
if (std.mem.eql(u8, line, "panel_prev")) return self.applyProtocol("command panel_prev");
if (std.mem.startsWith(u8, line, "open ")) return self.applyProtocol(line);
if (std.mem.startsWith(u8, line, "insert ")) return self.applyProtocolCommand(line);
if (std.mem.eql(u8, line, "left")) return self.applyProtocol("command move_left");
if (std.mem.eql(u8, line, "right")) return self.applyProtocol("command move_right");
if (std.mem.eql(u8, line, "backspace")) return self.applyMutatingProtocol("command delete_backward");
if (std.mem.eql(u8, line, "save")) return self.save();
if (std.mem.startsWith(u8, line, "resize ")) return self.resize(line[7..]);
if (std.mem.eql(u8, line, "render")) return;
return Error.UnknownTraceEvent;
}
pub fn render(self: *const Client, allocator: std.mem.Allocator) ![]u8 {
try self.viewport.validate();
const snap = try self.session.snapshot();
if (snap.active_panel_title != null) return self.renderPanel(allocator, snap);
return self.renderEditor(allocator, snap);
}
pub fn renderWithDiagnostics(self: *const Client, allocator: std.mem.Allocator) !RenderResult {
const frame = try self.render(allocator);
errdefer allocator.free(frame);
var diagnostics = diagnoseFrame(self.viewport, frame);
diagnostics.clipped_sources = try self.countClippedSources(allocator);
const warning = try renderWarningAlloc(allocator, diagnostics);
return .{ .frame = frame, .diagnostics = diagnostics, .warning = warning };
}
fn renderEditor(self: *const Client, allocator: std.mem.Allocator, snap: session_mod.Snapshot) ![]u8 {
var out = std.ArrayList(u8).empty;
errdefer out.deinit(allocator);
const max_body_lines = self.viewport.height - 1;
const cursor_line = lineIndexAt(snap.bytes, snap.cursor_byte);
const cursor_col = columnAt(snap.bytes, snap.cursor_byte);
const total_lines = countDocumentLines(snap.bytes);
const gutter_digits = @max(@as(usize, 2), decimalDigits(total_lines));
const gutter_width = @min(self.viewport.width, gutter_digits + 2);
const content_width = if (self.viewport.width > gutter_width) self.viewport.width - gutter_width else 0;
var visible_line_index: usize = 0;
var body_lines_used: usize = 0;
var line_iter = std.mem.splitScalar(u8, snap.bytes, '\n');
while (line_iter.next()) |line| : (visible_line_index += 1) {
if (body_lines_used >= max_body_lines) break;
try appendEditorLine(
allocator,
&out,
line,
visible_line_index + 1,
gutter_digits,
content_width,
visible_line_index == cursor_line,
cursor_col,
);
body_lines_used += 1;
}
while (body_lines_used < max_body_lines) : (body_lines_used += 1) {
try appendVirtualLine(allocator, &out, gutter_digits, content_width);
}
const leader_status = self.leader.status();
const prefix_status = self.prefixStatus();
const search_status = self.searchStatus();
const status = if (self.message) |message|
try std.fmt.allocPrint(allocator, "{s}", .{message})
else if (search_status.len != 0)
try std.fmt.allocPrint(allocator, "mode:{s} {s}", .{ @tagName(self.effectiveMode()), search_status })
else if (leader_status.len != 0)
try std.fmt.allocPrint(
allocator,
"mode:{s} {s}{s}{s}",
.{ @tagName(self.effectiveMode()), leader_status, if (self.leader.promptText().len > 0) ": " else "", self.leader.promptText() },
)
else if (prefix_status.len != 0)
try std.fmt.allocPrint(allocator, "mode:{s} {s}", .{ @tagName(self.effectiveMode()), prefix_status })
else
try std.fmt.allocPrint(
allocator,
"mode:{s} row={d} col={d} bytes={d}{s}",
.{ @tagName(self.effectiveMode()), cursor_line + 1, cursor_col + 1, snap.bytes.len, if (self.quit) " quit" else "" },
);
defer allocator.free(status);
try appendStatusLine(allocator, &out, status, self.viewport.width);
return out.toOwnedSlice(allocator);
}
fn renderPanel(self: *const Client, allocator: std.mem.Allocator, snap: session_mod.Snapshot) ![]u8 {
var out = std.ArrayList(u8).empty;
errdefer out.deinit(allocator);
const max_body_lines = self.viewport.height - 1;
var body_lines_used: usize = 0;
const path = try self.session.panelPathAlloc(allocator);
defer allocator.free(path);
const header = try std.fmt.allocPrint(allocator, "panel {s}", .{path});
defer allocator.free(header);
try appendVisibleCells(allocator, &out, header, self.viewport.width);
try out.append(allocator, '\n');
body_lines_used += 1;
const remaining_rows = max_body_lines - body_lines_used;
const rows = self.session.activeListRowsAlloc(allocator, remaining_rows) catch null;
if (rows) |list_rows| {
defer {
for (list_rows) |row| allocator.free(row);
allocator.free(list_rows);
}
for (list_rows) |row| {
if (body_lines_used >= max_body_lines) break;
try appendVisibleCells(allocator, &out, row, self.viewport.width);
try out.append(allocator, '\n');
body_lines_used += 1;
}
} else if (body_lines_used < max_body_lines) {
const title = snap.active_panel_title.?;
const detail = try std.fmt.allocPrint(allocator, "{s}: no content yet", .{title});
defer allocator.free(detail);
try appendVisibleCells(allocator, &out, detail, self.viewport.width);
try out.append(allocator, '\n');
body_lines_used += 1;
}
while (body_lines_used < max_body_lines) : (body_lines_used += 1) {
try out.append(allocator, '~');
try out.append(allocator, '\n');
}
const status = if (self.message) |message|
try std.fmt.allocPrint(allocator, "{s}", .{message})
else
try std.fmt.allocPrint(
allocator,
"panel {d}/{d} x close",
.{ snap.active_panel_index.? + 1, snap.panel_depth },
);
defer allocator.free(status);
try appendVisibleCells(allocator, &out, status, self.viewport.width);
return out.toOwnedSlice(allocator);
}
pub fn handleInput(self: *Client, raw: []const u8) !void {
if (self.quit) return Error.ClientQuit;
const event = input.normalize(raw);
self.message = null;
if (self.search_prompt_active) return self.applySearchPromptInput(event);
if (self.project_search_prompt_active) return self.applyProjectSearchPromptInput(event);
const leader_trigger = isLeaderTrigger(event) and self.effectiveMode() != .insert;
if (self.leader.capturesInput() or leader_trigger) {
if (self.prefix == .insert_space and isLeaderTrigger(event)) {
try self.insertText(" ");
self.prefix = .none;
return;
}
const action = try self.leader.handleEvent(event);
defer action.deinit(self.allocator);
try self.applyLeaderAction(action);
return;
}
try self.applyModeInput(event);
}
pub fn modeName(self: *const Client) []const u8 {
return @tagName(self.effectiveMode());
}
pub fn enterInsertMode(self: *Client) void {
self.mode = .insert;
self.message = "insert";
}
pub fn pendingRailName(self: *const Client) []const u8 {
return @tagName(self.prefix);
}
pub fn pendingCount(self: *const Client) usize {
return self.pending_count;
}
pub fn saved(self: *const Client) ![]const u8 {
return self.saved_bytes orelse Error.NothingSaved;
}
pub fn snapshotBytesAlloc(self: *const Client, allocator: std.mem.Allocator) ![]u8 {
const snap = try self.session.snapshot();
return allocator.dupe(u8, snap.bytes);
}
pub fn requestedQuit(self: *const Client) bool {
return self.quit;
}
pub fn clearQuit(self: *Client) void {
self.quit = false;
}
pub fn setStatusMessage(self: *Client, message: []const u8) void {
if (self.owned_message) |old| self.allocator.free(old);
self.owned_message = null;
self.message = message;
}
fn setOwnedStatusMessage(self: *Client, message: []u8) void {
if (self.owned_message) |old| self.allocator.free(old);
self.owned_message = message;
self.message = message;
}
fn effectiveMode(self: *const Client) EditorMode {
if (self.search_prompt_active or self.project_search_prompt_active or self.leader.isPromptActive()) return .prompt;
const snap = self.session.snapshot() catch return self.mode;
if (snap.active_panel_title != null) return .panel;
return self.mode;
}
fn searchStatus(self: *const Client) []const u8 {
if (self.project_search_prompt_active) return "project search: type query, Enter accept, Esc cancel";
if (self.search_prompt_active) return "search: type query, Enter accept, Esc cancel";
if (self.search_query.len != 0) return "search active: n next N previous";
return "";
}
fn prefixStatus(self: *const Client) []const u8 {
return switch (self.prefix) {
.none => if (self.pending_count != 0) "count pending" else "",
.insert_space => "insert-space: n normal Space literal text commits space+text",
.match => "match: m jump s inside a around ( { [ quotes",
.go => "go: d definition r references e diagnostic a parameter",
.repeat => "repeat: digits count . repeat-last",
.delete => "delete: d line h previous-char l char",
.change => "change: c line h previous-char l char",
.yank => "yank: y line",
.replace => "replace: next key replaces char",
};
}
fn freeOwnedClientRows(self: *Client, rows: *std.ArrayList([]u8)) void {
for (rows.items) |row| self.allocator.free(row);
rows.deinit(self.allocator);
rows.* = .empty;
}
pub fn addRepoFileContent(self: *Client, path: []const u8, file_bytes: []const u8) !void {
if (file_bytes.len > diagnostics_mod.max_file_bytes) {
self.message = "diagnostic:file_too_large";
return Error.ProtocolRejected;
}
self.repo.addFile(path, file_bytes) catch |err| {
self.message = "diagnostic:unsupported_file";
return err;
};
self.message = null;
}
fn addHoverFixture(self: *Client, payload: []const u8) !void {
var parts = std.mem.splitScalar(u8, payload, '|');
const provider = parts.next() orelse "fixture";
const headline = parts.next() orelse "hover";
const docs = parts.rest();
const row = try std.fmt.allocPrint(self.allocator, "provider:{s}:lsp:hover:{s}|{s}", .{ provider, headline, docs });
try self.hover_rows.append(self.allocator, row);
}
fn addSignatureFixture(self: *Client, payload: []const u8) !void {
var parts = std.mem.splitScalar(u8, payload, '|');
const provider = parts.next() orelse "fixture";
const signature = parts.rest();
const row = try std.fmt.allocPrint(self.allocator, "provider:{s}:lsp:signature:{s}", .{ provider, signature });
try self.signature_rows.append(self.allocator, row);
}
fn addDiagnosticFixture(self: *Client, payload: []const u8) !void {
var parts = std.mem.splitScalar(u8, payload, '|');
const provider = parts.next() orelse return Error.ProtocolRejected;
const version_text = parts.next() orelse return Error.ProtocolRejected;
const file = parts.next() orelse return Error.ProtocolRejected;
const start_text = parts.next() orelse return Error.ProtocolRejected;
const end_text = parts.next() orelse return Error.ProtocolRejected;
const severity_text = parts.next() orelse return Error.ProtocolRejected;
const message = parts.rest();
const version = std.fmt.parseUnsigned(u64, version_text, 10) catch return Error.ProtocolRejected;
const start = std.fmt.parseUnsigned(usize, start_text, 10) catch return Error.ProtocolRejected;
const end = std.fmt.parseUnsigned(usize, end_text, 10) catch return Error.ProtocolRejected;
const severity = diagnostics_mod.Severity.parse(severity_text) catch return Error.ProtocolRejected;
const row = diagnostics_mod.rowAlloc(self.allocator, provider, version, file, start, end, severity, message) catch return Error.ProtocolRejected;
try self.diagnostic_rows.append(self.allocator, row);
}
fn setDiagnosticFilter(self: *Client, provider: []const u8) !void {
if (self.diagnostic_filter) |old| self.allocator.free(old);
self.diagnostic_filter = if (std.mem.eql(u8, provider, "all")) null else try self.allocator.dupe(u8, diagnostics_mod.sanitizeToken(provider));
self.diagnostic_index = 0;
self.diagnostic_selected = false;
try self.openDiagnosticsPanel();
}
fn addRepoFile(self: *Client, payload: []const u8) !void {
const separator = std.mem.indexOfScalar(u8, payload, '=') orelse {
self.message = "diagnostic:unsupported_file:invalid_repo_file_payload";
return repo_mod.Error.InvalidPath;
};
try self.addRepoFileContent(payload[0..separator], payload[separator + 1 ..]);
}
fn openRepoList(self: *Client, title: []const u8, tree: bool, include_ignored: bool) !void {
const items = if (tree)
try self.repo.treeItemsAlloc(self.allocator, include_ignored)
else
try self.repo.pickerItemsAlloc(self.allocator, include_ignored);
defer self.allocator.free(items);
try self.session.openListPanel(title, items);
self.message = null;
}
fn openSelectedRepoFile(self: *Client) !void {
const selected = self.session.selectListPanel() catch return Error.ProtocolRejected;
const content = self.repo.content(selected) catch return Error.ProtocolRejected;
try self.session.openFixture(content);
try self.setCurrentPath(selected);
try self.session.closePanel();
self.message = null;
}
fn openSearchList(self: *Client, query: []const u8, include_ignored: bool) !void {
const rows = self.repo.searchRowsAlloc(self.allocator, query, include_ignored) catch return Error.ProtocolRejected;
defer {
for (rows) |row| self.allocator.free(row);
self.allocator.free(rows);
}
const truncated = rowsContain(rows, "diagnostic:search_truncated");
try self.session.openListPanel("search", rows);
self.message = if (truncated) "diagnostic:search_truncated" else null;
}
fn openSelectedSearchResult(self: *Client) !void {
const selected = self.session.selectListPanel() catch return Error.ProtocolRejected;
const match = self.repo.searchOffsetFromRow(selected) catch return Error.ProtocolRejected;
const content = self.repo.content(match.path) catch return Error.ProtocolRejected;
try self.session.openFixtureAt(content, match.offset);
try self.setCurrentPath(match.path);
try self.session.closePanel();
self.message = null;
}
fn setCurrentPath(self: *Client, path: []const u8) !void {
if (self.current_path) |old| self.allocator.free(old);
self.current_path = try self.allocator.dupe(u8, path);
}
fn openGitStatus(self: *Client, cwd: []const u8) !void {
const io = self.io orelse return Error.ProtocolRejected;
const rows = repo_mod.gitStatusRowsAlloc(self.allocator, io, cwd) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("git-status", rows);
self.message = null;
}
fn openSelectedGitDiff(self: *Client, cwd: []const u8) !void {
const io = self.io orelse return Error.ProtocolRejected;
const selected = self.session.selectListPanel() catch return Error.ProtocolRejected;
const path = repo_mod.gitPathFromStatusRow(selected) catch return Error.ProtocolRejected;
const rows = repo_mod.gitDiffRowsAlloc(self.allocator, io, cwd, path) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("git-diff", rows);
self.message = null;
}
fn openSelectedGitFile(self: *Client, cwd: []const u8) !void {
const io = self.io orelse return Error.ProtocolRejected;
const selected = self.session.selectListPanel() catch return Error.ProtocolRejected;
const path = repo_mod.gitPathFromStatusRow(selected) catch return Error.ProtocolRejected;
const content = repo_mod.readRepoFileAlloc(self.allocator, io, cwd, path) catch return Error.ProtocolRejected;
defer self.allocator.free(content);
try self.session.openFixture(content);
try self.session.closePanel();
self.message = null;
}
fn openJobRun(self: *Client, cwd_and_command: []const u8) !void {
const io = self.io orelse return Error.ProtocolRejected;
const split = splitCwdAndCommand(cwd_and_command) orelse return Error.ProtocolRejected;
var argv = std.ArrayList([]const u8).empty;
defer argv.deinit(self.allocator);
var parts = std.mem.splitScalar(u8, split.command, ' ');
while (parts.next()) |part| {
if (part.len == 0) continue;
try argv.append(self.allocator, part);
}
const rows = job_mod.runRowsAlloc(self.allocator, io, split.cwd, argv.items) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.setJobCwd(split.cwd);
try self.openJobPanel("job-output", rows);
}
fn openTerminalRun(self: *Client, cwd_and_command: []const u8) !void {
const io = self.io orelse return Error.ProtocolRejected;
const split = splitCwdAndCommand(cwd_and_command) orelse return Error.ProtocolRejected;
const rows = job_mod.shellRowsAlloc(self.allocator, io, split.cwd, split.command) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.setJobCwd(split.cwd);
try self.openJobPanel("terminal-output", rows);
}
fn openJobProfile(self: *Client, profile: job_mod.Profile) !void {
const io = self.io orelse return Error.ProtocolRejected;
const rows = job_mod.profileRowsAlloc(self.allocator, io, ".", profile, self.current_path) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.setJobCwd(".");
try self.openJobPanel("job-output", rows);
}
fn openJobProfileByName(self: *Client, name: []const u8) !void {
const profile = parseJobProfile(name) orelse return Error.ProtocolRejected;
try self.openJobProfile(profile);
}
fn openMissingToolJob(self: *Client, payload: []const u8) !void {
var parts = std.mem.splitScalar(u8, payload, ' ');
const profile_name = parts.next() orelse return Error.ProtocolRejected;
const tool = parts.next() orelse return Error.ProtocolRejected;
const profile = parseJobProfile(profile_name) orelse return Error.ProtocolRejected;
const rows = try job_mod.missingToolRowsAlloc(self.allocator, profile, tool);
defer freeOwnedRows(self.allocator, rows);
try self.setJobCwd(".");
try self.openJobPanel("job-output", rows);
}
fn openTimeoutJob(self: *Client, name: []const u8) !void {
const profile = parseJobProfile(name) orelse return Error.ProtocolRejected;
const rows = try job_mod.timeoutRowsAlloc(self.allocator, profile);
defer freeOwnedRows(self.allocator, rows);
try self.setJobCwd(".");
try self.openJobPanel("job-output", rows);
}
fn openCancelledJob(self: *Client) !void {
const rows = try job_mod.cancelRowsAlloc(self.allocator, .build);
defer freeOwnedRows(self.allocator, rows);
try self.setJobCwd(".");
try self.openJobPanel("job-output", rows);
}
fn setJobCwd(self: *Client, cwd: []const u8) !void {
if (self.job_cwd) |old| self.allocator.free(old);
self.job_cwd = try self.allocator.dupe(u8, cwd);
}
fn openJobPanel(self: *Client, title: []const u8, rows: []const []const u8) !void {
const snap = try self.session.snapshot();
if (snap.active_panel_title) |active| {
if (std.mem.eql(u8, active, "job-output") or std.mem.eql(u8, active, "terminal-output")) self.session.closePanel() catch {};
}
try self.session.openListPanel(title, rows);
self.message = null;
}
fn parseJobProfile(name: []const u8) ?job_mod.Profile {
if (std.mem.eql(u8, name, "lint_file")) return .lint_file;
if (std.mem.eql(u8, name, "lint_project")) return .lint_project;
if (std.mem.eql(u8, name, "build")) return .build;
if (std.mem.eql(u8, name, "test")) return .tests;
if (std.mem.eql(u8, name, "check")) return .check;
return null;
}
fn closeTerminalPanel(self: *Client) !void {
try self.session.closePanel();
self.message = null;
}
fn openSyntaxSpans(self: *Client, language: []const u8) !void {
const snap = try self.session.snapshot();
const rows = syntax_mod.rowsAlloc(self.allocator, language, snap.bytes) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("syntax-spans", rows);
self.message = null;
}
fn openLspSync(self: *Client, args: []const u8) !void {
const io = self.io orelse return Error.ProtocolRejected;
const parsed = parseLspSyncArgs(args) orelse return Error.ProtocolRejected;
const snap = try self.session.snapshot();
var argv = std.ArrayList([]const u8).empty;
defer argv.deinit(self.allocator);
var parts = std.mem.splitScalar(u8, parsed.command, ' ');
while (parts.next()) |part| {
if (part.len == 0) continue;
try argv.append(self.allocator, part);
}
const rows = lsp_mod.runDocumentSyncRowsAlloc(self.allocator, io, parsed.cwd, argv.items, .{
.uri = parsed.uri,
.language_id = parsed.language_id,
.text = snap.bytes,
}) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("lsp-sync", rows);
self.message = null;
}
fn openLspDiagnostics(self: *Client, payload: []const u8) !void {
const rows = lsp_mod.diagnosticRowsAlloc(self.allocator, payload) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("lsp-diagnostics", rows);
self.message = null;
}
fn openSelectedLspDiagnostic(self: *Client) !void {
const selected = self.session.selectListPanel() catch return Error.ProtocolRejected;
const location = lsp_mod.diagnosticLocationFromRow(selected) catch return Error.ProtocolRejected;
try self.jumpCurrentBufferToLspLocation(location);
}
fn openLspLocations(self: *Client, kind: []const u8, payload: []const u8) !void {
const rows = lsp_mod.locationRowsAlloc(self.allocator, kind, payload) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
const title = if (std.mem.eql(u8, kind, "definition")) "lsp-definition" else "lsp-references";
try self.session.openListPanel(title, rows);
self.message = null;
}
fn openLspSymbols(self: *Client, scope: []const u8, payload: []const u8) !void {
const rows = lsp_mod.symbolRowsAlloc(self.allocator, scope, payload) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
const title = if (std.mem.eql(u8, scope, "document")) "lsp-document-symbols" else "lsp-workspace-symbols";
try self.session.openListPanel(title, rows);
self.message = null;
}
fn openSelectedLspNavigation(self: *Client) !void {
const selected = self.session.selectListPanel() catch return Error.ProtocolRejected;
const location = lsp_mod.navigationLocationFromRow(selected) catch return Error.ProtocolRejected;
try self.jumpCurrentBufferToLspLocation(location);
}
fn openLspWorkspaceEdit(self: *Client, kind: []const u8, payload: []const u8) !void {
const rows = lsp_mod.workspaceEditRowsAlloc(self.allocator, kind, payload) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("lsp-edit-preview", rows);
self.message = null;
}
fn openLspCodeActions(self: *Client, payload: []const u8) !void {
const rows = lsp_mod.codeActionRowsAlloc(self.allocator, payload) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("lsp-code-actions", rows);
self.message = null;
}
fn applySelectedLspEdit(self: *Client) !void {
const selected = self.session.selectListPanel() catch return Error.ProtocolRejected;
const snap = try self.session.snapshot();
const applied = lsp_mod.applyEditRowAlloc(self.allocator, snap.bytes, selected) catch return Error.ProtocolRejected;
defer self.allocator.free(applied.bytes);
try self.session.openFixtureAt(applied.bytes, applied.cursor);
try self.session.closePanel();
self.message = null;
}
fn openLspHover(self: *Client, payload: []const u8) !void {
const rows = lsp_mod.hoverRowsAlloc(self.allocator, payload, self.viewport.width) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("lsp-hover", rows);
self.message = null;
}
fn openLspSignature(self: *Client, payload: []const u8) !void {
const rows = lsp_mod.signatureRowsAlloc(self.allocator, payload, self.viewport.width) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("lsp-signature", rows);
self.message = null;
}
fn moveLspParameter(self: *Client, direction: lsp_mod.ParameterDirection) !void {
const snap = try self.session.snapshot();
const moved = lsp_mod.parameterMoveRowsAlloc(self.allocator, snap.bytes, snap.cursor_byte, direction) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, moved.rows);
const bytes = try self.allocator.dupe(u8, snap.bytes);
defer self.allocator.free(bytes);
try self.session.openFixtureAt(bytes, moved.cursor);
try self.session.openListPanel("lsp-parameter", moved.rows);
self.message = null;
}
fn openPiRun(self: *Client, command_line: []const u8) !void {
const io = self.io orelse return Error.ProtocolRejected;
var argv = std.ArrayList([]const u8).empty;
defer argv.deinit(self.allocator);
var parts = std.mem.splitScalar(u8, std.mem.trim(u8, command_line, " "), ' ');
while (parts.next()) |part| {
if (part.len == 0) continue;
try argv.append(self.allocator, part);
}
const context_text = try context_mod.sessionContextAlloc(self.allocator, &self.session, "pi_run", "bridge", .{});
defer self.allocator.free(context_text);
const rows = pi_bridge.rowsAlloc(self.allocator, io, argv.items, context_text) catch return Error.ProtocolRejected;
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("pi-output", rows);
self.message = null;
}
fn jumpCurrentBufferToLspLocation(self: *Client, location: lsp_mod.DiagnosticLocation) !void {
const snap = try self.session.snapshot();
const bytes = try self.allocator.dupe(u8, snap.bytes);
defer self.allocator.free(bytes);
const offset = lsp_mod.byteOffsetForLineColumn(bytes, location.line, location.character) catch return Error.ProtocolRejected;
try self.session.openFixtureAt(bytes, offset);
try self.session.closePanel();
self.message = null;
}
fn openStaticJobRow(self: *Client, title: []const u8, row: []const u8) !void {
try self.session.openListPanel(title, &.{row});
self.message = null;
}
fn openSelectedJobLocation(self: *Client, cwd: []const u8) !void {
const selected = self.session.selectListPanel() catch return Error.ProtocolRejected;
const location = job_mod.locationFromRow(selected) catch return Error.ProtocolRejected;
if (self.current_path) |path| {
if (std.mem.eql(u8, path, location.path)) {
const snap = try self.session.snapshot();
const content = try self.allocator.dupe(u8, snap.bytes);
defer self.allocator.free(content);
const offset = job_mod.byteOffsetForLineColumn(content, location.line, location.column) catch return Error.ProtocolRejected;
try self.session.openFixtureAt(content, offset);
try self.session.closePanel();
self.message = null;
return;
}
}
const io = self.io orelse return Error.ProtocolRejected;
const content = repo_mod.readRepoFileAlloc(self.allocator, io, cwd, location.path) catch return Error.ProtocolRejected;
defer self.allocator.free(content);
const offset = job_mod.byteOffsetForLineColumn(content, location.line, location.column) catch return Error.ProtocolRejected;
try self.session.openFixtureAt(content, offset);
try self.setCurrentPath(location.path);
try self.session.closePanel();
self.message = null;
}
fn yankSelectedJobLine(self: *Client) !void {
const selected = self.session.activeListItem() catch return Error.ProtocolRejected;
if (self.yank_bytes) |old| self.allocator.free(old);
self.yank_bytes = try self.allocator.dupe(u8, selected);
self.message = "yanked job line";
}
fn handleTraceKey(self: *Client, key_name: []const u8) !void {
if (std.mem.eql(u8, key_name, "space")) return self.handleInput(" ");
if (std.mem.eql(u8, key_name, "enter")) return self.handleInput("\r");
if (std.mem.eql(u8, key_name, "backspace")) return self.handleInput("\x7f");
if (std.mem.eql(u8, key_name, "escape")) return self.handleInput("\x1b");
if (std.mem.eql(u8, key_name, "left")) return self.handleInput("\x1b[D");
if (std.mem.eql(u8, key_name, "right")) return self.handleInput("\x1b[C");
if (std.mem.eql(u8, key_name, "up")) return self.handleInput("\x1b[A");
if (std.mem.eql(u8, key_name, "down")) return self.handleInput("\x1b[B");
if (std.mem.eql(u8, key_name, "home")) return self.handleInput("\x1b[H");
if (std.mem.eql(u8, key_name, "end")) return self.handleInput("\x1b[F");
if (std.mem.eql(u8, key_name, "page_up")) return self.handleInput("\x1b[5~");
if (std.mem.eql(u8, key_name, "page_down")) return self.handleInput("\x1b[6~");
if (key_name.len == 1) return self.handleInput(key_name);
return Error.UnknownTraceEvent;
}
fn isLeaderTrigger(event: input.Event) bool {
return switch (event) {
.key => |key| key == .space,
.text => |text| std.mem.eql(u8, text, " "),
else => false,
};
}
fn applyModeInput(self: *Client, event: input.Event) !void {
if (self.prefix != .none) return self.applyPrefixInput(event);
if (self.applyCountPrefix(event)) return;
switch (self.effectiveMode()) {
.normal => try self.applyNormalModeInput(event),
.insert => try self.applyInsertModeInput(event),
.select => try self.applySelectModeInput(event),
.panel => try self.applyPanelModeInput(event),
.prompt => {},
}
}
fn applyCountPrefix(self: *Client, event: input.Event) bool {
switch (event) {
.text => |text| if (text.len == 1 and text[0] >= '0' and text[0] <= '9') {
const digit = text[0] - '0';
if (self.pending_count != 0 or digit != 0) {
self.pending_count = self.pending_count * 10 + digit;
self.last_rail = .repeat;
return true;
}
},
else => {},
}
return false;
}
fn takeRepeat(self: *Client) usize {
const repeat = if (self.pending_count == 0) 1 else self.pending_count;
self.pending_count = 0;
return repeat;
}
fn applyNormalModeInput(self: *Client, event: input.Event) !void {
switch (event) {
.text => |text| {
if (std.mem.eql(u8, text, "i")) {
self.mode = .insert;
self.message = "insert";
self.pending_count = 0;
return;
}
if (std.mem.eql(u8, text, "a")) {
try self.applyProtocol("command move_right");
self.mode = .insert;
self.message = "insert";
self.pending_count = 0;
return;
}
if (std.mem.eql(u8, text, "o")) {
try self.applyMutatingProtocol("command open_line_below");
self.mode = .insert;
self.message = "insert";
self.pending_count = 0;
return;
}
if (std.mem.eql(u8, text, "O")) {
try self.applyMutatingProtocol("command open_line_above");
self.mode = .insert;
self.message = "insert";
self.pending_count = 0;
return;
}
if (std.mem.eql(u8, text, "s")) {
self.mode = .select;
self.message = "select";
self.pending_count = 0;
return;
}
if (std.mem.eql(u8, text, "d")) return self.openPrefix(.delete);
if (std.mem.eql(u8, text, "c")) return self.openPrefix(.change);
if (std.mem.eql(u8, text, "y")) return self.openPrefix(.yank);
if (std.mem.eql(u8, text, "r")) return self.openPrefix(.replace);
if (std.mem.eql(u8, text, "/")) return self.openSearchPrompt();
if (std.mem.eql(u8, text, "n")) return self.nextSearchMatch();
if (std.mem.eql(u8, text, "N")) return self.previousSearchMatch();
if (std.mem.eql(u8, text, "p")) return self.pasteRegister();
if (std.mem.eql(u8, text, "u")) return self.undoEdit();
if (std.mem.eql(u8, text, "U")) return self.redoEdit();
if (std.mem.eql(u8, text, "0")) return self.applyProtocol("command move_line_start");
if (std.mem.eql(u8, text, "$")) return self.applyProtocol("command move_line_end");
if (std.mem.eql(u8, text, "%")) return self.jumpToMatch(null);
if (std.mem.eql(u8, text, "m")) return self.openPrefix(.match);
if (std.mem.eql(u8, text, "g")) return self.openPrefix(.go);
if (std.mem.eql(u8, text, "j")) return self.repeatProtocol("command move_down", self.takeRepeat());
if (std.mem.eql(u8, text, "k")) return self.repeatProtocol("command move_up", self.takeRepeat());
if (std.mem.eql(u8, text, "h")) return self.repeatProtocol("command move_left", self.takeRepeat());
if (std.mem.eql(u8, text, "l")) return self.repeatProtocol("command move_right", self.takeRepeat());
if (std.mem.eql(u8, text, "w")) return self.repeatProtocol("command move_word_forward", self.takeRepeat());
if (std.mem.eql(u8, text, "b")) return self.repeatProtocol("command move_word_back", self.takeRepeat());
if (std.mem.eql(u8, text, "e")) return self.repeatProtocol("command move_word_end", self.takeRepeat());
self.unknownPrefixOrInput("normal");
},
.key => |key| switch (key) {
.escape => {
self.pending_count = 0;
self.message = "normal";
},
.backspace => try self.applyMutatingProtocol("command delete_backward"),
.arrow_left => try self.repeatProtocol("command move_left", self.takeRepeat()),
.arrow_right => try self.repeatProtocol("command move_right", self.takeRepeat()),
.arrow_up => try self.repeatProtocol("command move_up", self.takeRepeat()),
.arrow_down => try self.repeatProtocol("command move_down", self.takeRepeat()),
.home => try self.applyProtocol("command move_line_start"),
.end => try self.applyProtocol("command move_line_end"),
.page_up => try self.repeatProtocol("command move_up", @max(@as(usize, 1), self.viewport.height - 2)),
.page_down => try self.repeatProtocol("command move_down", @max(@as(usize, 1), self.viewport.height - 2)),
else => self.unknownPrefixOrInput("normal"),
},
.unknown => self.unknownPrefixOrInput("normal"),
}
}
fn applyInsertModeInput(self: *Client, event: input.Event) !void {
switch (event) {
.text => |text| if (std.mem.eql(u8, text, " ")) self.openPrefix(.insert_space) else try self.insertText(text),
.key => |key| switch (key) {
.space => self.openPrefix(.insert_space),
.escape => {
self.mode = .normal;
self.message = "normal";
},
.backspace => try self.applyMutatingProtocol("command delete_backward"),
.arrow_left => try self.applyProtocol("command move_left"),
.arrow_right => try self.applyProtocol("command move_right"),
.arrow_up => try self.applyProtocol("command move_up"),
.arrow_down => try self.applyProtocol("command move_down"),
.home => try self.applyProtocol("command move_line_start"),
.end => try self.applyProtocol("command move_line_end"),
else => {},
},
.unknown => {},
}
}
fn applySelectModeInput(self: *Client, event: input.Event) !void {
switch (event) {
.text => |text| {
if (std.mem.eql(u8, text, "n")) {
self.mode = .normal;
self.message = "normal";
return;
}
if (std.mem.eql(u8, text, "%")) return self.jumpToMatch(null);
if (std.mem.eql(u8, text, "m")) return self.openPrefix(.match);
if (std.mem.eql(u8, text, "g")) return self.openPrefix(.go);
if (text.len == 1) {
if (self.objectRangeForKey(text[0])) |range| {
try self.session.selectRange(range.start, range.end);
self.message = "selected object";
return;
} else |_| {}
}
self.unknownPrefixOrInput("select");
},
.key => |key| switch (key) {
.escape => {
self.mode = .normal;
self.message = "normal";
},
.arrow_left => try self.applyProtocol("command move_left"),
.arrow_right => try self.applyProtocol("command move_right"),
.arrow_up => try self.applyProtocol("command move_up"),
.arrow_down => try self.applyProtocol("command move_down"),
.home => try self.applyProtocol("command move_line_start"),
.end => try self.applyProtocol("command move_line_end"),
else => {},
},
.unknown => self.unknownPrefixOrInput("select"),
}
}
fn applyPanelModeInput(self: *Client, event: input.Event) !void {
switch (event) {
.text => |text| {
if (std.mem.eql(u8, text, "j")) return self.applyProtocol("command list_down");
if (std.mem.eql(u8, text, "k")) return self.applyProtocol("command list_up");
if (std.mem.eql(u8, text, "o")) return self.openActivePanelItem();
if (std.mem.eql(u8, text, "q")) return self.closeActivePanel();
self.unknownPrefixOrInput("panel");
},
.key => |key| switch (key) {
.arrow_down => try self.applyProtocol("command list_down"),
.arrow_up => try self.applyProtocol("command list_up"),
.page_down => try self.repeatProtocol("command list_down", @max(@as(usize, 1), self.viewport.height - 2)),
.page_up => try self.repeatProtocol("command list_up", @max(@as(usize, 1), self.viewport.height - 2)),
.enter => try self.openActivePanelItem(),
.escape => try self.closeActivePanel(),
else => {},
},
.unknown => self.unknownPrefixOrInput("panel"),
}
}
fn applyPrefixInput(self: *Client, event: input.Event) !void {
const active = self.prefix;
self.prefix = .none;
switch (active) {
.none => {},
.insert_space => try self.applyInsertSpaceRail(event),
.match => self.applyMatchRail(event) catch |err| {
self.message = @errorName(err);
},
.go => try self.applyGoRail(event),
.repeat => self.applyKnownRailOrMessage(event, "repeat rail ready"),
.delete => try self.applyDeleteRail(event),
.change => try self.applyChangeRail(event),
.yank => try self.applyYankRail(event),
.replace => try self.applyReplaceRail(event),
}
}
fn applyInsertSpaceRail(self: *Client, event: input.Event) !void {
switch (event) {
.text => |text| {
if (std.mem.eql(u8, text, "n")) {
self.mode = .normal;
self.message = "normal";
return;
}
try self.insertText(" ");
try self.insertText(text);
},
.key => |key| switch (key) {
.space => try self.insertText(" "),
.escape => {
self.mode = .normal;
self.message = "normal";
},
else => try self.insertText(" "),
},
.unknown => try self.insertText(" "),
}
}
fn applyKnownRailOrMessage(self: *Client, event: input.Event, success: []const u8) void {
switch (event) {
.text => |text| if (text.len == 1 and std.mem.indexOfScalar(u8, "msadretpi(){}[]'\"`.", text[0]) != null) {
self.message = success;
self.pending_count = 0;
return;
},
.key => |key| if (key == .escape or key == .backspace) {
self.message = "rail cancelled";
self.pending_count = 0;
return;
},
else => {},
}
self.message = "unknown prefix key";
self.last_rail = .none;
self.pending_count = 0;
}
fn openPrefix(self: *Client, prefix: PrefixRail) void {
self.prefix = prefix;
self.last_rail = prefix;
self.message = null;
}
fn restoreLastRail(self: *Client) void {
if (self.last_rail == .none) {
self.message = "no previous rail";
return;
}
self.prefix = self.last_rail;
self.message = null;
}
fn openFilePickerPanel(self: *Client) !void {
try self.openRepoList("files", false, false);
self.panel_context = .file_picker;
}
fn openListRows(self: *Client, title: []const u8, rows: []const []const u8, context: PanelContext) !void {
if (rows.len == 0) {
self.message = "empty list";
return;
}
try self.session.openListPanel(title, rows);
self.message = null;
self.panel_context = context;
}
fn openActivePanelItem(self: *Client) !void {
const item = self.session.activeListItem() catch |err| {
self.message = @errorName(err);
return;
};
const owned = try self.allocator.dupe(u8, item);
defer self.allocator.free(owned);
switch (self.panel_context) {
.file_picker => try self.openRepoPathFromPanel(owned),
.project_search => try self.openProjectSearchResult(owned),
.language_provider_picker => try self.applyLanguageProviderChoice(owned),
.code_actions => try self.applyCodeActionRow(owned),
.none => self.message = "panel item has no action",
}
}
fn closeActivePanel(self: *Client) !void {
try self.applyProtocol("command list_cancel");
self.panel_context = .none;
}
fn openRepoPathFromPanel(self: *Client, row: []const u8) !void {
const path = if (std.mem.startsWith(u8, row, "file ")) row[5..] else row;
const bytes = self.repo.content(path) catch |err| {
self.message = @errorName(err);
return;
};
try self.session.openFixtureAt(bytes, 0);
try self.setCurrentPath(path);
try self.closeActivePanel();
self.message = path;
}
fn openProjectSearchResult(self: *Client, row: []const u8) !void {
const target = self.repo.searchOffsetFromRow(row) catch |err| {
self.message = @errorName(err);
return;
};
const bytes = self.repo.content(target.path) catch |err| {
self.message = @errorName(err);
return;
};
try self.session.openFixtureAt(bytes, target.offset);
try self.setCurrentPath(target.path);
try self.closeActivePanel();
self.message = row;
}
fn openProjectSearchPrompt(self: *Client) void {
self.project_search_prompt_active = true;
self.project_search_prompt.clearRetainingCapacity();
self.message = null;
self.prefix = .none;
}
fn applyProjectSearchPromptInput(self: *Client, event: input.Event) !void {
switch (event) {
.text => |text| try self.project_search_prompt.appendSlice(self.allocator, text),
.key => |key| switch (key) {
.enter => try self.commitProjectSearchPrompt(),
.escape => {
self.project_search_prompt_active = false;
self.message = "project search cancelled";
},
.backspace => {
if (self.project_search_prompt.items.len > 0) _ = self.project_search_prompt.pop();
},
.space => try self.project_search_prompt.append(self.allocator, ' '),
else => {},
},
.unknown => {},
}
}
fn commitProjectSearchPrompt(self: *Client) !void {
self.project_search_prompt_active = false;
const rows = try self.repo.searchRowsAlloc(self.allocator, self.project_search_prompt.items, false);
defer freeOwnedRows(self.allocator, rows);
if (rows.len == 0) {
self.message = "no project matches";
return;
}
try self.openSearchList(self.project_search_prompt.items, false);
self.panel_context = .project_search;
}
fn showCompactHover(self: *Client) !void {
if (self.hover_rows.items.len == 0) {
self.message = "NoProvider:hover";
return;
}
const card = try lsp_mod.compactHoverCardAlloc(self.allocator, self.hover_rows.items[0], self.viewport.width);
self.setOwnedStatusMessage(card);
}
fn showCompactSignature(self: *Client) !void {
if (self.signature_rows.items.len == 0) {
self.message = "NoProvider:signature";
return;
}
const card = try lsp_mod.compactSignatureCardAlloc(self.allocator, self.signature_rows.items[0]);
self.setOwnedStatusMessage(card);
}
fn openExpandedHover(self: *Client) !void {
if (self.hover_rows.items.len == 0) {
self.message = "NoProvider:hover";
return;
}
const rows = try lsp_mod.expandedHoverRowsAlloc(self.allocator, self.hover_rows.items[0], self.viewport.width);
defer {
for (rows) |row| self.allocator.free(row);
self.allocator.free(rows);
}
try self.openListRows("hover", rows, .none);
}
fn addLanguageEditFixture(self: *Client, payload: []const u8) !void {
var parts = std.mem.splitScalar(u8, payload, '|');
const provider = parts.next() orelse return Error.ProtocolRejected;
const capability_name = parts.next() orelse return Error.ProtocolRejected;
const version_text = parts.next() orelse return Error.ProtocolRejected;
const start_text = parts.next() orelse return Error.ProtocolRejected;
const end_text = parts.next() orelse return Error.ProtocolRejected;
const replacement = parts.rest();
const capability = lsp_mod.providerCapabilityFromName(capability_name) catch return Error.ProtocolRejected;
const version = std.fmt.parseUnsigned(u64, version_text, 10) catch return Error.ProtocolRejected;
const start = std.fmt.parseUnsigned(usize, start_text, 10) catch return Error.ProtocolRejected;
const end = std.fmt.parseUnsigned(usize, end_text, 10) catch return Error.ProtocolRejected;
const row = lsp_mod.editRowAlloc(self.allocator, provider, capability, version, start, end, replacement) catch return Error.ProtocolRejected;
try self.language_edit_rows.append(self.allocator, row);
}
fn setFormatProviderDefault(self: *Client, provider: []const u8) !void {
if (self.format_provider_default) |old| self.allocator.free(old);
self.format_provider_default = if (std.mem.eql(u8, provider, "none")) null else try self.allocator.dupe(u8, provider);
const message = try std.fmt.allocPrint(self.allocator, "format default:{s}", .{self.format_provider_default orelse "none"});
self.setOwnedStatusMessage(message);
}
fn setFormatOnSavePolicy(self: *Client, policy: []const u8) !void {
if (std.mem.eql(u8, policy, "on")) self.format_on_save = true else if (std.mem.eql(u8, policy, "off")) self.format_on_save = false else return Error.ProtocolRejected;
try self.showFormatPolicy();
}
fn showFormatPolicy(self: *Client) !void {
const provider = self.format_provider_default orelse "select";
const message = try std.fmt.allocPrint(self.allocator, "format-on-save:{s} provider:{s} one-shot:save_without_format", .{ if (self.format_on_save) "on" else "off", provider });
self.setOwnedStatusMessage(message);
}
fn saveWithoutFormat(self: *Client) !void {
self.skip_next_save_format = true;
try self.save();
}
fn formatCurrentBuffer(self: *Client) !void {
try self.applyLanguageMutation(.format, null);
}
fn organizeImports(self: *Client) !void {
if (!self.hasLanguageProvider(.organize_imports) and self.hover_rows.items.len != 0) return self.openExpandedHover();
try self.applyLanguageMutation(.organize_imports, null);
}
fn hasLanguageProvider(self: *Client, capability: lsp_mod.ProviderCapability) bool {
for (self.language_edit_rows.items) |row| {
const edit = lsp_mod.parseProviderEditRow(row) catch continue;
if (edit.capability == capability) return true;
}
return false;
}
fn openCodeActions(self: *Client) !void {
const rows = try self.actionRowsForCapability(.code_action);
defer freeOwnedRows(self.allocator, rows);
if (rows.len == 0) {
self.message = "NoProvider:code_action";
return;
}
try self.openListRows("code-actions", rows, .code_actions);
}
fn actionRowsForCapability(self: *Client, capability: lsp_mod.ProviderCapability) ![][]const u8 {
var rows = std.ArrayList([]const u8).empty;
errdefer freeOwnedRows(self.allocator, rows.items);
for (self.language_edit_rows.items) |row| {
const edit = lsp_mod.parseProviderEditRow(row) catch continue;
if (edit.capability != capability) continue;
try rows.append(self.allocator, try lsp_mod.actionPanelRowAlloc(self.allocator, row));
}
return rows.toOwnedSlice(self.allocator);
}
fn applyCodeActionRow(self: *Client, row: []const u8) !void {
const provider = lsp_mod.providerFromActionPanelRow(row) catch return Error.ProtocolRejected;
const capability = lsp_mod.capabilityFromActionPanelRow(row) catch return Error.ProtocolRejected;
try self.applyLanguageMutation(capability, provider);
}
fn applyLanguageProviderChoice(self: *Client, row: []const u8) !void {
const provider = lsp_mod.providerFromActionPanelRow(row) catch return Error.ProtocolRejected;
const capability = self.pending_language_capability orelse return Error.ProtocolRejected;
self.pending_language_capability = null;
try self.applyLanguageMutation(capability, provider);
}
fn applyLanguageMutation(self: *Client, capability: lsp_mod.ProviderCapability, forced_provider: ?[]const u8) !void {
const provider = try self.chooseLanguageProvider(capability, forced_provider);
if (provider == null) return;
try self.applyProviderEdits(capability, provider.?);
}
fn chooseLanguageProvider(self: *Client, capability: lsp_mod.ProviderCapability, forced_provider: ?[]const u8) !?[]const u8 {
if (forced_provider) |provider| return provider;
var providers = std.ArrayList([]const u8).empty;
defer providers.deinit(self.allocator);
for (self.language_edit_rows.items) |row| {
const edit = lsp_mod.parseProviderEditRow(row) catch continue;
if (edit.capability != capability) continue;
var seen = false;
for (providers.items) |provider| {
if (std.mem.eql(u8, provider, edit.provider)) seen = true;
}
if (!seen) try providers.append(self.allocator, edit.provider);
}
if (providers.items.len == 0) {
const message = try std.fmt.allocPrint(self.allocator, "NoProvider:{s}", .{@tagName(capability)});
self.setOwnedStatusMessage(message);
return null;
}
if (capability == .format) {
if (self.format_provider_default) |preferred| {
for (providers.items) |provider| if (std.mem.eql(u8, provider, preferred)) return provider;
}
}
if (providers.items.len == 1) return providers.items[0];
var rows = std.ArrayList([]const u8).empty;
errdefer freeOwnedRows(self.allocator, rows.items);
for (providers.items) |provider| try rows.append(self.allocator, try std.fmt.allocPrint(self.allocator, "action:{s}:provider:{s}:scope:buffer:choose", .{ @tagName(capability), provider }));
const owned = try rows.toOwnedSlice(self.allocator);
defer freeOwnedRows(self.allocator, owned);
self.pending_language_capability = capability;
try self.openListRows("language-providers", owned, .language_provider_picker);
return null;
}
const EditOrder = struct { start: usize, row: []const u8 };
fn applyProviderEdits(self: *Client, capability: lsp_mod.ProviderCapability, provider: []const u8) !void {
const snap = try self.session.snapshot();
var matches = std.ArrayList([]const u8).empty;
defer matches.deinit(self.allocator);
for (self.language_edit_rows.items) |row| {
const edit = lsp_mod.parseProviderEditRow(row) catch {
self.message = "InvalidEdit";
return;
};
if (edit.capability == capability and std.mem.eql(u8, edit.provider, provider)) try matches.append(self.allocator, row);
}
if (matches.items.len == 0) {
const message = try std.fmt.allocPrint(self.allocator, "NoProvider:{s}", .{@tagName(capability)});
self.setOwnedStatusMessage(message);
return;
}
var ordered = std.ArrayList(EditOrder).empty;
defer ordered.deinit(self.allocator);
for (matches.items) |row| {
const edit = lsp_mod.parseProviderEditRow(row) catch {
self.message = "InvalidEdit";
return;
};
if (edit.version != self.document_version) {
self.message = "StaleEdit";
return;
}
if (edit.end > snap.bytes.len) {
self.message = "InvalidEdit";
return;
}
for (ordered.items) |existing| {
const prev = lsp_mod.parseProviderEditRow(existing.row) catch unreachable;
if (!(edit.end <= prev.start or edit.start >= prev.end)) {
self.message = "OverlappingEdit";
return;
}
}
try ordered.append(self.allocator, .{ .start = edit.start, .row = row });
}
std.mem.sort(EditOrder, ordered.items, {}, struct {
fn lessThan(_: void, lhs: EditOrder, rhs: EditOrder) bool {
return lhs.start > rhs.start;
}
}.lessThan);
try self.recordUndo();
self.clearRedo();
for (ordered.items) |item| {
const edit = lsp_mod.parseProviderEditRow(item.row) catch unreachable;
self.session.replaceRange(edit.start, edit.end, edit.replacement) catch |err| {
self.dropLastUndoSnapshot();
self.message = @errorName(err);
return;
};
}
self.noteDocumentChanged();
const message = try std.fmt.allocPrint(self.allocator, "{s}:{s}:applied", .{ @tagName(capability), provider });
self.setOwnedStatusMessage(message);
}
const DiagnosticDirection = enum { next, previous };
fn diagnosticMatchesFilter(self: *const Client, row: []const u8) bool {
const filter = self.diagnostic_filter orelse return true;
const diagnostic = diagnostics_mod.parseRow(row) catch return false;
return std.mem.eql(u8, diagnostic.provider, filter);
}
fn diagnosticPanelRowsAlloc(self: *const Client) ![][]const u8 {
var rows = std.ArrayList([]const u8).empty;
errdefer freeOwnedRows(self.allocator, rows.items);
for (self.diagnostic_rows.items) |row| {
if (!self.diagnosticMatchesFilter(row)) continue;
const panel_row = diagnostics_mod.panelRowAlloc(self.allocator, row, self.document_version) catch try self.allocator.dupe(u8, "diag:invalid");
try rows.append(self.allocator, panel_row);
}
if (rows.items.len == 0) try rows.append(self.allocator, try self.allocator.dupe(u8, "diag:empty"));
return rows.toOwnedSlice(self.allocator);
}
fn openDiagnosticsPanel(self: *Client) !void {
const snap = try self.session.snapshot();
if (snap.active_panel_title) |title| {
if (std.mem.eql(u8, title, "diagnostics")) self.session.closePanel() catch {};
}
const rows = try self.diagnosticPanelRowsAlloc();
defer freeOwnedRows(self.allocator, rows);
try self.session.openListPanel("diagnostics", rows);
self.message = null;
}
fn filteredDiagnosticCount(self: *const Client) usize {
var count: usize = 0;
for (self.diagnostic_rows.items) |row| {
if (self.diagnosticMatchesFilter(row)) count += 1;
}
return count;
}
fn filteredDiagnosticRow(self: *const Client, index: usize) ?[]const u8 {
var seen: usize = 0;
for (self.diagnostic_rows.items) |row| {
if (!self.diagnosticMatchesFilter(row)) continue;
if (seen == index) return row;
seen += 1;
}
return null;
}
fn gotoDiagnostic(self: *Client, direction: DiagnosticDirection) !void {
const count = self.filteredDiagnosticCount();
if (count == 0) {
self.message = "diag:empty";
return;
}
self.diagnostic_index = if (self.diagnostic_selected) switch (direction) {
.next => (self.diagnostic_index + 1) % count,
.previous => if (self.diagnostic_index == 0) count - 1 else self.diagnostic_index - 1,
} else switch (direction) {
.next => 0,
.previous => count - 1,
};
self.diagnostic_selected = true;
const row = self.filteredDiagnosticRow(self.diagnostic_index) orelse return;
const range = self.diagnosticRangeFromRow(row) catch |err| {
self.message = @errorName(err);
return;
};
try self.session.moveToByte(range.start);
try self.session.selectRange(range.start, range.end);
self.session.clearSelection();
try self.session.moveToByte(range.start);
self.session.closePanel() catch {};
self.message = "diag:jumped";
}
fn filterDiagnosticsFromPanel(self: *Client) !void {
const selected = self.session.activeListItem() catch null;
if (selected) |row| {
if (diagnosticProviderFromPanelRow(row)) |provider| {
try self.setDiagnosticFilter(provider);
return;
}
}
if (self.diagnostic_filter) |old| {
self.allocator.free(old);
self.diagnostic_filter = null;
self.message = "diag:filter_all";
} else self.message = "diag:filter_select_source";
try self.openDiagnosticsPanel();
}
fn diagnosticProviderFromPanelRow(row: []const u8) ?[]const u8 {
if (!std.mem.startsWith(u8, row, "diag:")) return null;
var parts = std.mem.splitScalar(u8, row, ':');
_ = parts.next() orelse return null;
const freshness_or_empty = parts.next() orelse return null;
if (std.mem.eql(u8, freshness_or_empty, "empty") or std.mem.eql(u8, freshness_or_empty, "invalid")) return null;
return parts.next();
}
fn diagnosticRangeFromRow(self: *Client, row: []const u8) !ObjectRange {
const diagnostic = try diagnostics_mod.parseRow(row);
const snap = try self.session.snapshot();
if (diagnostic.stale(self.document_version)) return error.StaleDiagnostic;
if (diagnostic.end > snap.bytes.len) return error.InvalidDiagnosticRange;
return .{ .start = diagnostic.start, .end = diagnostic.end };
}
fn currentDiagnosticRange(self: *Client) !ObjectRange {
const count = self.filteredDiagnosticCount();
if (count == 0) return error.NoDiagnostics;
if (self.diagnostic_index >= count) self.diagnostic_index = 0;
const row = self.filteredDiagnosticRow(self.diagnostic_index) orelse return error.NoDiagnostics;
return self.diagnosticRangeFromRow(row);
}
fn selectCurrentDiagnosticRange(self: *Client) !void {
const range = self.currentDiagnosticRange() catch |err| {
self.message = @errorName(err);
return;
};
try self.session.selectRange(range.start, range.end);
self.message = "selected diagnostic";
}
fn noteDocumentChanged(self: *Client) void {
self.document_version += 1;
self.diagnostic_index = 0;
self.diagnostic_selected = false;
}
fn openSearchPrompt(self: *Client) void {
self.search_prompt_active = true;
self.search_prompt.clearRetainingCapacity();
self.message = null;
self.prefix = .none;
}
fn applySearchPromptInput(self: *Client, event: input.Event) !void {
switch (event) {
.text => |text| try self.search_prompt.appendSlice(self.allocator, text),
.key => |key| switch (key) {
.enter => try self.commitSearchPrompt(),
.escape => {
self.search_prompt_active = false;
self.message = "search cancelled";
},
.backspace => {
if (self.search_prompt.items.len > 0) _ = self.search_prompt.pop();
},
.space => try self.search_prompt.append(self.allocator, ' '),
else => {},
},
.unknown => {},
}
}
fn commitSearchPrompt(self: *Client) !void {
self.search_prompt_active = false;
self.allocator.free(self.search_query);
self.search_query = try self.allocator.dupe(u8, self.search_prompt.items);
try self.rebuildSearchMatches();
if (self.search_matches.items.len == 0) {
self.message = "no search matches";
return;
}
self.search_index = 0;
try self.gotoSearchMatch();
}
fn rebuildSearchMatches(self: *Client) !void {
self.search_matches.clearRetainingCapacity();
if (self.search_query.len == 0) return;
const snap = try self.session.snapshot();
var offset: usize = 0;
while (offset <= snap.bytes.len) {
const found = std.mem.indexOf(u8, snap.bytes[offset..], self.search_query) orelse break;
const at = offset + found;
try self.search_matches.append(self.allocator, at);
offset = at + @max(self.search_query.len, 1);
}
}
fn gotoSearchMatch(self: *Client) !void {
if (self.search_matches.items.len == 0) return;
const at = self.search_matches.items[self.search_index];
try self.session.moveToByte(at);
try self.session.selectRange(at, at + self.search_query.len);
}
fn nextSearchMatch(self: *Client) !void {
if (self.search_matches.items.len == 0) {
self.message = "no active search";
return;
}
self.search_index = (self.search_index + 1) % self.search_matches.items.len;
try self.gotoSearchMatch();
}
fn previousSearchMatch(self: *Client) !void {
if (self.search_matches.items.len == 0) {
self.message = "no active search";
return;
}
self.search_index = if (self.search_index == 0) self.search_matches.items.len - 1 else self.search_index - 1;
try self.gotoSearchMatch();
}
fn applyGoRail(self: *Client, event: input.Event) !void {
const text = eventText(event) orelse return self.unknownPrefixOrInput("normal");
if (std.mem.eql(u8, text, "a")) return self.moveParameter(.next);
if (std.mem.eql(u8, text, "A")) return self.moveParameter(.previous);
if (std.mem.eql(u8, text, "e")) return self.gotoDiagnostic(.next);
self.applyKnownRailOrMessage(event, "go rail ready");
}
const ParameterDirection = enum { next, previous };
fn moveParameter(self: *Client, direction: ParameterDirection) !void {
const snap = try self.session.snapshot();
const pair = self.matchRange('(', false) catch {
self.message = "NoParameterContext";
return;
};
var target: ?usize = null;
switch (direction) {
.next => {
var at = snap.cursor_byte;
while (at < pair.end) : (at += 1) {
if (snap.bytes[at] == ',') {
target = at + 1;
break;
}
}
},
.previous => {
var at = @min(snap.cursor_byte, pair.end);
while (at > pair.start) {
at -= 1;
if (snap.bytes[at] == ',') {
var prev = at;
while (prev > pair.start and snap.bytes[prev - 1] != ',') prev -= 1;
target = prev;
break;
}
}
},
}
if (target) |byte| {
var trimmed = byte;
while (trimmed < pair.end and std.ascii.isWhitespace(snap.bytes[trimmed])) trimmed += 1;
try self.session.moveToByte(trimmed);
} else self.message = "NoParameterTarget";
}
fn applyMatchRail(self: *Client, event: input.Event) !void {
const text = eventText(event) orelse return self.unknownPrefixOrInput("normal");
if (std.mem.eql(u8, text, "m")) return self.jumpToMatch(null);
if (std.mem.eql(u8, text, "s")) {
const range = try self.matchRange(null, false);
try self.session.selectRange(range.start, range.end);
self.message = "selected inside pair";
return;
}
if (std.mem.eql(u8, text, "a")) {
const range = try self.matchRange(null, true);
try self.session.selectRange(range.start, range.end);
self.message = "selected around pair";
return;
}
if (text.len == 1 and isPairSelector(text[0])) {
if (self.effectiveMode() == .select) {
const range = try self.matchRange(text[0], true);
try self.session.selectRange(range.start, range.end);
} else {
try self.jumpToMatch(text[0]);
}
return;
}
self.unknownPrefixOrInput("normal");
}
fn applyDeleteRail(self: *Client, event: input.Event) !void {
const text = eventText(event) orelse return self.unknownPrefixOrInput("normal");
if (std.mem.eql(u8, text, "d")) {
try self.yankCurrentLine(true);
try self.applyMutatingProtocol("command delete_line");
return;
}
if (std.mem.eql(u8, text, "h")) return self.applyMutatingProtocol("command delete_backward");
if (std.mem.eql(u8, text, "l")) return self.applyMutatingProtocol("command delete_forward");
if (text.len == 1) {
if (self.objectRangeForKey(text[0])) |range| return self.deleteRange(range) else |_| {}
}
self.unknownPrefixOrInput("normal");
}
fn applyChangeRail(self: *Client, event: input.Event) !void {
const text = eventText(event) orelse return self.unknownPrefixOrInput("normal");
if (std.mem.eql(u8, text, "c")) {
try self.yankCurrentLine(false);
try self.applyMutatingProtocol("command change_line");
self.mode = .insert;
self.message = "insert";
return;
}
if (std.mem.eql(u8, text, "h")) {
try self.applyMutatingProtocol("command delete_backward");
self.mode = .insert;
self.message = "insert";
return;
}
if (std.mem.eql(u8, text, "l")) {
try self.applyMutatingProtocol("command delete_forward");
self.mode = .insert;
self.message = "insert";
return;
}
if (text.len == 1) {
if (self.objectRangeForKey(text[0])) |range| {
try self.changeRange(range);
return;
} else |_| {}
}
self.unknownPrefixOrInput("normal");
}
fn applyYankRail(self: *Client, event: input.Event) !void {
const text = eventText(event) orelse return self.unknownPrefixOrInput("normal");
if (std.mem.eql(u8, text, "y")) {
try self.yankCurrentLine(true);
self.message = "yanked line";
return;
}
if (text.len == 1) {
if (self.objectRangeForKey(text[0])) |range| {
try self.yankRange(range);
self.message = "yanked object";
return;
} else |_| {}
}
self.unknownPrefixOrInput("normal");
}
fn applyReplaceRail(self: *Client, event: input.Event) !void {
const text = eventText(event) orelse return self.unknownPrefixOrInput("normal");
const command = try std.fmt.allocPrint(self.allocator, "command replace_char {s}", .{text});
defer self.allocator.free(command);
try self.applyMutatingProtocol(command);
}
fn eventText(event: input.Event) ?[]const u8 {
return switch (event) {
.text => |text| text,
.key => |key| switch (key) {
.space => " ",
else => null,
},
.unknown => null,
};
}
fn deleteRange(self: *Client, range: ObjectRange) !void {
try self.yankRange(range);
try self.recordUndo();
self.clearRedo();
self.session.replaceRange(range.start, range.end, "") catch |err| {
self.dropLastUndoSnapshot();
return err;
};
self.noteDocumentChanged();
}
fn changeRange(self: *Client, range: ObjectRange) !void {
try self.yankRange(range);
try self.recordUndo();
self.clearRedo();
self.session.replaceRange(range.start, range.end, "") catch |err| {
self.dropLastUndoSnapshot();
return err;
};
self.noteDocumentChanged();
self.mode = .insert;
self.message = "insert";
}
fn yankRange(self: *Client, range: ObjectRange) !void {
const snap = try self.session.snapshot();
if (range.start > range.end or range.end > snap.bytes.len) return error.SelectionOutOfBounds;
const copy = try self.allocator.dupe(u8, snap.bytes[range.start..range.end]);
if (self.yank_bytes) |old| self.allocator.free(old);
self.yank_bytes = copy;
}
fn pasteRegister(self: *Client) !void {
const bytes = self.yank_bytes orelse {
self.message = "nothing yanked";
return;
};
try self.recordUndo();
self.clearRedo();
self.session.dispatch(.{ .insert = bytes }) catch |err| {
self.dropLastUndoSnapshot();
return err;
};
self.noteDocumentChanged();
}
fn yankCurrentLine(self: *Client, include_newline: bool) !void {
const snap = try self.session.snapshot();
var start = snap.cursor_byte;
while (start > 0 and snap.bytes[start - 1] != '\n') start -= 1;
var end = snap.cursor_byte;
while (end < snap.bytes.len and snap.bytes[end] != '\n') end += 1;
if (include_newline and end < snap.bytes.len and snap.bytes[end] == '\n') end += 1;
const copy = try self.allocator.dupe(u8, snap.bytes[start..end]);
if (self.yank_bytes) |old| self.allocator.free(old);
self.yank_bytes = copy;
}
fn undoEdit(self: *Client) !void {
const previous = self.undo_stack.pop() orelse {
self.message = "nothing to undo";
return;
};
const current = try self.takeCurrentSnapshot();
try self.redo_stack.append(self.allocator, current);
try self.restoreSnapshot(previous);
self.allocator.free(previous.bytes);
self.message = "undo";
}
fn redoEdit(self: *Client) !void {
const next = self.redo_stack.pop() orelse {
self.message = "nothing to redo";
return;
};
const current = try self.takeCurrentSnapshot();
try self.undo_stack.append(self.allocator, current);
try self.restoreSnapshot(next);
self.allocator.free(next.bytes);
self.message = "redo";
}
fn takeCurrentSnapshot(self: *Client) !EditSnapshot {
const snap = try self.session.snapshot();
return .{ .bytes = try self.allocator.dupe(u8, snap.bytes), .cursor_byte = snap.cursor_byte };
}
fn objectRangeForKey(self: *Client, key: u8) !ObjectRange {
return switch (key) {
'w' => try self.wordRange(),
'l' => try self.lineRange(true),
'i' => try self.indentRange(),
'p' => try self.parameterRange(),
'f' => try self.enclosingFormRange(),
'd' => self.currentDiagnosticRange() catch try self.lineRange(false),
else => error.UnsupportedObject,
};
}
fn wordRange(self: *Client) !ObjectRange {
const snap = try self.session.snapshot();
var start = snap.cursor_byte;
while (start > 0 and !isObjectSeparator(snap.bytes[previousBoundaryLocal(snap.bytes, start)])) start = previousBoundaryLocal(snap.bytes, start);
var end = snap.cursor_byte;
while (end < snap.bytes.len and !isObjectSeparator(snap.bytes[end])) end = nextBoundaryLocal(snap.bytes, end);
return .{ .start = start, .end = end };
}
fn lineRange(self: *Client, include_newline: bool) !ObjectRange {
const snap = try self.session.snapshot();
var start = snap.cursor_byte;
while (start > 0 and snap.bytes[start - 1] != '\n') start -= 1;
var end = snap.cursor_byte;
while (end < snap.bytes.len and snap.bytes[end] != '\n') end += 1;
if (include_newline and end < snap.bytes.len) end += 1;
return .{ .start = start, .end = end };
}
fn indentRange(self: *Client) !ObjectRange {
const snap = try self.session.snapshot();
const current = try self.lineRange(false);
const indent = lineIndent(snap.bytes[current.start..current.end]);
var start = current.start;
while (start > 0) {
const prev_end = start - 1;
var prev_start = prev_end;
while (prev_start > 0 and snap.bytes[prev_start - 1] != '\n') prev_start -= 1;
if (lineContentLen(snap.bytes[prev_start..prev_end]) != 0 and lineIndent(snap.bytes[prev_start..prev_end]) < indent) break;
start = prev_start;
}
var end = current.end;
while (end < snap.bytes.len) {
const next_start = if (end < snap.bytes.len and snap.bytes[end] == '\n') end + 1 else end;
if (next_start >= snap.bytes.len) break;
var next_end = next_start;
while (next_end < snap.bytes.len and snap.bytes[next_end] != '\n') next_end += 1;
if (lineContentLen(snap.bytes[next_start..next_end]) != 0 and lineIndent(snap.bytes[next_start..next_end]) < indent) break;
end = next_end;
}
return .{ .start = start, .end = end };
}
fn parameterRange(self: *Client) !ObjectRange {
const around = try self.matchRange('(', false);
const snap = try self.session.snapshot();
var start = around.start;
var end = around.end;
var at = around.start;
while (at < around.end) : (at += 1) {
if (snap.bytes[at] == ',' and at < snap.cursor_byte) start = at + 1;
if (snap.bytes[at] == ',' and at >= snap.cursor_byte) {
end = at;
break;
}
}
return trimRange(snap.bytes, .{ .start = start, .end = end });
}
fn enclosingFormRange(self: *Client) !ObjectRange {
return self.matchRange('{', true) catch self.matchRange('(', true);
}
fn jumpToMatch(self: *Client, selector: ?u8) !void {
const pair = try self.matchPair(selector);
const snap = try self.session.snapshot();
const target = if (snap.cursor_byte <= pair.open) pair.close else pair.open;
try self.session.moveToByte(target);
self.message = "matched pair";
}
fn matchRange(self: *Client, selector: ?u8, around: bool) !ObjectRange {
const pair = try self.matchPair(selector);
return if (around) .{ .start = pair.open, .end = pair.close + 1 } else .{ .start = pair.open + 1, .end = pair.close };
}
fn matchPair(self: *Client, selector: ?u8) !PairRange {
const snap = try self.session.snapshot();
if (snap.bytes.len == 0) return error.NoMatch;
if (selector) |sel| return findPairForSelector(snap.bytes, snap.cursor_byte, sel) orelse error.NoMatch;
if (findPairAtOrNear(snap.bytes, snap.cursor_byte)) |pair| return pair;
return error.NoMatch;
}
fn insertText(self: *Client, text: []const u8) !void {
try self.recordUndo();
self.clearRedo();
self.session.dispatch(.{ .insert = text }) catch |err| {
self.dropLastUndoSnapshot();
return err;
};
self.noteDocumentChanged();
self.message = null;
}
fn applyMutatingProtocolCommand(self: *Client, line: []const u8) !void {
try self.recordUndo();
self.clearRedo();
self.applyProtocolCommand(line) catch |err| {
self.dropLastUndoSnapshot();
return err;
};
self.noteDocumentChanged();
}
fn applyMutatingProtocol(self: *Client, line: []const u8) !void {
try self.recordUndo();
self.clearRedo();
self.applyProtocol(line) catch |err| {
self.dropLastUndoSnapshot();
return err;
};
self.noteDocumentChanged();
}
fn repeatProtocol(self: *Client, line: []const u8, repeat: usize) !void {
var i: usize = 0;
while (i < repeat) : (i += 1) try self.applyProtocol(line);
}
fn repeatMutatingProtocol(self: *Client, line: []const u8, repeat: usize) !void {
var i: usize = 0;
while (i < repeat) : (i += 1) try self.applyMutatingProtocol(line);
}
fn recordUndo(self: *Client) !void {
const snap = try self.session.snapshot();
const bytes = try self.allocator.dupe(u8, snap.bytes);
errdefer self.allocator.free(bytes);
try self.undo_stack.append(self.allocator, .{
.bytes = bytes,
.cursor_byte = snap.cursor_byte,
});
}
fn dropLastUndoSnapshot(self: *Client) void {
if (self.undo_stack.pop()) |snap| self.allocator.free(snap.bytes);
}
fn restoreSnapshot(self: *Client, snap: EditSnapshot) !void {
try self.session.openFixtureAt(snap.bytes, snap.cursor_byte);
}
fn freeSnapshotStack(self: *Client, stack: *std.ArrayList(EditSnapshot)) void {
for (stack.items) |snap| self.allocator.free(snap.bytes);
stack.deinit(self.allocator);
}
fn clearRedo(self: *Client) void {
self.freeSnapshotStack(&self.redo_stack);
self.redo_stack = .empty;
}
fn unknownPrefixOrInput(self: *Client, mode: []const u8) void {
self.pending_count = 0;
self.message = if (std.mem.eql(u8, mode, "normal"))
"unknown normal key"
else if (std.mem.eql(u8, mode, "select"))
"unknown select key"
else
"unknown panel key";
}
fn applyLeaderAction(self: *Client, action: leader_mod.Action) !void {
switch (action) {
.none => {},
.save => try self.save(),
.quit => self.quit = true,
.open => |path| {
const line = try std.fmt.allocPrint(self.allocator, "open {s}", .{path});
defer self.allocator.free(line);
try self.applyProtocol(line);
},
.symbol => |symbol| try self.applyProtocol(symbol_mod.protocolCommand(symbol)),
.file_picker => try self.openFilePickerPanel(),
.search_file => self.openSearchPrompt(),
.search_project => self.openProjectSearchPrompt(),
.hover => try self.showCompactHover(),
.signature => try self.showCompactSignature(),
.expand_hover => try self.openExpandedHover(),
.language_format => try self.formatCurrentBuffer(),
.language_format_policy => try self.showFormatPolicy(),
.language_organize_imports => try self.organizeImports(),
.language_code_actions => try self.openCodeActions(),
.diagnostics_open => try self.openDiagnosticsPanel(),
.diagnostics_next => try self.gotoDiagnostic(.next),
.diagnostics_previous => try self.gotoDiagnostic(.previous),
.diagnostics_filter => try self.filterDiagnosticsFromPanel(),
.job_lint_file => try self.openJobProfile(.lint_file),
.job_lint_project => try self.openJobProfile(.lint_project),
.job_build => try self.openJobProfile(.build),
.job_test => try self.openJobProfile(.tests),
.job_check => try self.openJobProfile(.check),
.job_cancel => try self.openCancelledJob(),
.job_jump => try self.openSelectedJobLocation(self.job_cwd orelse "."),
.job_yank => try self.yankSelectedJobLine(),
.repeat_rail => self.openPrefix(.repeat),
.restore_last => self.restoreLastRail(),
.not_built => {},
}
}
fn applyProtocolCommand(self: *Client, line: []const u8) !void {
const command = try std.fmt.allocPrint(self.allocator, "command {s}", .{line});
defer self.allocator.free(command);
try self.applyProtocol(command);
}
fn applyProtocol(self: *Client, line: []const u8) !void {
const response = try protocol.handleLine(self.allocator, &self.session, line);
defer self.allocator.free(response);
if (std.mem.startsWith(u8, response, "err ")) {
self.message = protocolErrorMessage(response);
return Error.ProtocolRejected;
}
self.message = null;
}
fn protocolErrorMessage(response: []const u8) []const u8 {
if (std.mem.indexOf(u8, response, "invalid panel title") != null) return "error: invalid panel title";
if (std.mem.indexOf(u8, response, "no panel open") != null) return "error: no panel open";
if (std.mem.indexOf(u8, response, "invalid list") != null) return "error: invalid list";
if (std.mem.indexOf(u8, response, "active panel is not list") != null) return "error: active panel is not list";
return "error: command failed";
}
fn resize(self: *Client, payload: []const u8) !void {
const x = std.mem.indexOfScalar(u8, payload, 'x') orelse return Error.InvalidResize;
const width = std.fmt.parseUnsigned(usize, payload[0..x], 10) catch return Error.InvalidResize;
const height = std.fmt.parseUnsigned(usize, payload[x + 1 ..], 10) catch return Error.InvalidResize;
const viewport = Viewport{ .width = width, .height = height };
try viewport.validate();
self.viewport = viewport;
}
fn save(self: *Client) !void {
if (self.format_on_save and !self.skip_next_save_format and self.hasLanguageProvider(.format)) {
const before_format_version = self.document_version;
try self.applyLanguageMutation(.format, null);
if (self.document_version == before_format_version) return;
}
self.skip_next_save_format = false;
const snap = try self.session.snapshot();
if (snap.bytes.len > diagnostics_mod.max_file_bytes) {
self.message = "diagnostic:save_failed:file_too_large";
return Error.ProtocolRejected;
}
const copy = try self.allocator.dupe(u8, snap.bytes);
if (self.saved_bytes) |old| self.allocator.free(old);
self.saved_bytes = copy;
self.message = "saved";
}
fn countClippedSources(self: *const Client, allocator: std.mem.Allocator) !usize {
const snap = try self.session.snapshot();
var clipped: usize = 0;
if (snap.active_panel_title == null) {
var line_iter = std.mem.splitScalar(u8, snap.bytes, '\n');
while (line_iter.next()) |line| {
if (session_mod.cellWidth(line) > self.viewport.width) clipped += 1;
}
if (self.message) |message| {
if (session_mod.cellWidth(message) > self.viewport.width) clipped += 1;
}
return clipped;
}
const path = try self.session.panelPathAlloc(allocator);
defer allocator.free(path);
const header = try std.fmt.allocPrint(allocator, "panel {s}", .{path});
defer allocator.free(header);
if (session_mod.cellWidth(header) > self.viewport.width) clipped += 1;
const remaining_rows = self.viewport.height - 1;
const rows = self.session.activeListRowsAlloc(allocator, remaining_rows) catch null;
if (rows) |list_rows| {
defer {
for (list_rows) |row| allocator.free(row);
allocator.free(list_rows);
}
for (list_rows) |row| {
if (session_mod.cellWidth(row) > self.viewport.width) clipped += 1;
}
} else if (snap.active_panel_title) |title| {
const detail = try std.fmt.allocPrint(allocator, "{s}: no content yet", .{title});
defer allocator.free(detail);
if (session_mod.cellWidth(detail) > self.viewport.width) clipped += 1;
}
const status = if (self.message) |message|
try std.fmt.allocPrint(allocator, "{s}", .{message})
else
try std.fmt.allocPrint(allocator, "panel {d}/{d} x close", .{ snap.active_panel_index.? + 1, snap.panel_depth });
defer allocator.free(status);
if (session_mod.cellWidth(status) > self.viewport.width) clipped += 1;
return clipped;
}
};
const ansi_reset = "\x1b[0m";
const ansi_gutter = "\x1b[38;2;88;96;112m";
const ansi_virtual = "\x1b[38;2;64;70;86m";
const ansi_text = "\x1b[38;2;214;222;235m";
const ansi_current_line = "\x1b[48;2;26;31;43m";
const ansi_cursor = "\x1b[38;2;18;22;30;48;2;245;197;92m";
const ansi_status = "\x1b[38;2;18;22;30;48;2;126;231;135m";
fn appendEditorLine(
allocator: std.mem.Allocator,
out: *std.ArrayList(u8),
line: []const u8,
line_no: usize,
gutter_digits: usize,
content_width: usize,
is_cursor_line: bool,
cursor_col: usize,
) !void {
try appendLineNumber(allocator, out, line_no, gutter_digits);
if (content_width == 0) {
try out.append(allocator, '\n');
return;
}
if (is_cursor_line) try out.appendSlice(allocator, ansi_current_line);
try out.appendSlice(allocator, ansi_text);
try appendEditorCells(allocator, out, line, content_width, is_cursor_line, cursor_col);
try out.appendSlice(allocator, ansi_reset);
try out.append(allocator, '\n');
}
fn appendLineNumber(allocator: std.mem.Allocator, out: *std.ArrayList(u8), line_no: usize, gutter_digits: usize) !void {
const text = try std.fmt.allocPrint(allocator, "{d}", .{line_no});
defer allocator.free(text);
try out.appendSlice(allocator, ansi_gutter);
var pad: usize = text.len;
while (pad < gutter_digits) : (pad += 1) try out.append(allocator, ' ');
try out.appendSlice(allocator, text);
try out.appendSlice(allocator, "│");
try out.appendSlice(allocator, ansi_reset);
try out.append(allocator, ' ');
}
fn appendVirtualLine(allocator: std.mem.Allocator, out: *std.ArrayList(u8), gutter_digits: usize, content_width: usize) !void {
_ = content_width;
try out.appendSlice(allocator, ansi_gutter);
var pad: usize = 0;
while (pad < gutter_digits) : (pad += 1) try out.append(allocator, ' ');
try out.appendSlice(allocator, "│");
try out.appendSlice(allocator, ansi_virtual);
try out.appendSlice(allocator, " ·");
try out.appendSlice(allocator, ansi_reset);
try out.append(allocator, '\n');
}
fn appendEditorCells(
allocator: std.mem.Allocator,
out: *std.ArrayList(u8),
bytes: []const u8,
max_cells: usize,
is_cursor_line: bool,
cursor_col: usize,
) !void {
_ = cursor_col;
var remaining = max_cells;
if (is_cursor_line and remaining > 0) {
try out.appendSlice(allocator, ansi_cursor);
try out.appendSlice(allocator, "▌");
try out.appendSlice(allocator, ansi_reset);
try out.appendSlice(allocator, ansi_current_line);
try out.appendSlice(allocator, ansi_text);
remaining -= 1;
}
var i: usize = 0;
var col: usize = 0;
while (i < bytes.len and col < remaining) {
const len = std.unicode.utf8ByteSequenceLength(bytes[i]) catch 1;
const end = @min(bytes.len, i + len);
const width = @max(@as(usize, 1), session_mod.cellWidth(bytes[i..end]));
if (col + width > remaining) break;
try out.appendSlice(allocator, bytes[i..end]);
col += width;
i = end;
}
}
fn appendStatusLine(allocator: std.mem.Allocator, out: *std.ArrayList(u8), status: []const u8, width: usize) !void {
try out.appendSlice(allocator, ansi_status);
try appendVisibleCells(allocator, out, status, width);
try out.appendSlice(allocator, ansi_reset);
}
fn appendVisibleCells(allocator: std.mem.Allocator, out: *std.ArrayList(u8), bytes: []const u8, max_cells: usize) !void {
var i: usize = 0;
while (i < bytes.len) {
const len = std.unicode.utf8ByteSequenceLength(bytes[i]) catch 1;
const end = @min(bytes.len, i + len);
const next = bytes[0..end];
if (session_mod.cellWidth(next) > max_cells) break;
try out.appendSlice(allocator, bytes[i..end]);
i = end;
}
}
fn countDocumentLines(bytes: []const u8) usize {
var lines: usize = 1;
for (bytes) |byte| {
if (byte == '\n') lines += 1;
}
return lines;
}
fn decimalDigits(value: usize) usize {
var digits: usize = 1;
var n = value;
while (n >= 10) : (digits += 1) n /= 10;
return digits;
}
fn visibleCellWidth(bytes: []const u8) usize {
var i: usize = 0;
var cells: usize = 0;
while (i < bytes.len) {
if (bytes[i] == 0x1b and i + 1 < bytes.len and bytes[i + 1] == '[') {
i += 2;
while (i < bytes.len and bytes[i] != 'm') : (i += 1) {}
if (i < bytes.len) i += 1;
continue;
}
const len = std.unicode.utf8ByteSequenceLength(bytes[i]) catch 1;
const end = @min(bytes.len, i + len);
cells += session_mod.cellWidth(bytes[i..end]);
i = end;
}
return cells;
}
fn lineIndexAt(bytes: []const u8, cursor_byte: usize) usize {
var line: usize = 0;
for (bytes[0..@min(cursor_byte, bytes.len)]) |byte| {
if (byte == '\n') line += 1;
}
return line;
}
fn columnAt(bytes: []const u8, cursor_byte: usize) usize {
const prefix = bytes[0..@min(cursor_byte, bytes.len)];
const line_start = if (std.mem.lastIndexOfScalar(u8, prefix, '\n')) |idx| idx + 1 else 0;
return session_mod.cellWidth(prefix[line_start..]);
}
fn diagnoseFrame(viewport: Viewport, frame: []const u8) RenderDiagnostics {
var diagnostics = RenderDiagnostics{
.viewport_width = viewport.width,
.viewport_height = viewport.height,
.frame_bytes = frame.len,
.frame_lines = 0,
.max_line_cells = 0,
.clipped_sources = 0,
};
var lines = std.mem.splitScalar(u8, frame, '\n');
while (lines.next()) |line| {
diagnostics.frame_lines += 1;
diagnostics.max_line_cells = @max(diagnostics.max_line_cells, visibleCellWidth(line));
}
return diagnostics;
}
fn renderWarningAlloc(allocator: std.mem.Allocator, diagnostics: RenderDiagnostics) ![]u8 {
if (diagnostics.frame_lines != diagnostics.viewport_height) {
return std.fmt.allocPrint(
allocator,
"render warning: expected {d} lines, rendered {d}",
.{ diagnostics.viewport_height, diagnostics.frame_lines },
);
}
if (diagnostics.max_line_cells > diagnostics.viewport_width) {
return std.fmt.allocPrint(
allocator,
"render warning: line width {d} exceeds viewport {d}",
.{ diagnostics.max_line_cells, diagnostics.viewport_width },
);
}
if (diagnostics.clipped_sources > 0) {
return std.fmt.allocPrint(
allocator,
"render warning: clipped {d} source line(s) to fit {d} columns",
.{ diagnostics.clipped_sources, diagnostics.viewport_width },
);
}
return std.fmt.allocPrint(
allocator,
"render ok: {d} lines, {d} bytes, max {d}/{d} cells",
.{ diagnostics.frame_lines, diagnostics.frame_bytes, diagnostics.max_line_cells, diagnostics.viewport_width },
);
}
fn assertLinesFit(frame: []const u8, width: usize) !void {
var lines = std.mem.splitScalar(u8, frame, '\n');
while (lines.next()) |line| {
try std.testing.expect(visibleCellWidth(line) <= width);
}
}
fn rowsContain(rows: []const []const u8, needle: []const u8) bool {
for (rows) |row| {
if (std.mem.indexOf(u8, row, needle) != null) return true;
}
return false;
}
fn freeOwnedRows(allocator: std.mem.Allocator, rows: []const []const u8) void {
for (rows) |row| allocator.free(row);
allocator.free(rows);
}
fn splitCwdAndCommand(cwd_and_command: []const u8) ?struct { cwd: []const u8, command: []const u8 } {
const first_space = std.mem.indexOfScalar(u8, cwd_and_command, ' ') orelse return null;
const cwd = cwd_and_command[0..first_space];
const command = std.mem.trim(u8, cwd_and_command[first_space + 1 ..], " ");
if (cwd.len == 0 or command.len == 0) return null;
return .{ .cwd = cwd, .command = command };
}
fn parseLspSyncArgs(args: []const u8) ?struct { cwd: []const u8, uri: []const u8, language_id: []const u8, command: []const u8 } {
const first = std.mem.indexOfScalar(u8, args, ' ') orelse return null;
const cwd = args[0..first];
const rest = std.mem.trim(u8, args[first + 1 ..], " ");
const second = std.mem.indexOfScalar(u8, rest, ' ') orelse return null;
const uri = rest[0..second];
const rest2 = std.mem.trim(u8, rest[second + 1 ..], " ");
const third = std.mem.indexOfScalar(u8, rest2, ' ') orelse return null;
const language_id = rest2[0..third];
const command = std.mem.trim(u8, rest2[third + 1 ..], " ");
if (cwd.len == 0 or uri.len == 0 or language_id.len == 0 or command.len == 0) return null;
return .{ .cwd = cwd, .uri = uri, .language_id = language_id, .command = command };
}
test "regular: scripted narrow terminal trace edits saves exits and replays saved bytes" {
const trace =
\\open abc
\\right
\\insert é
\\save
\\quit
\\
;
const result = try runTrace(std.testing.allocator, .{ .width = 12, .height = 4 }, trace);
defer result.deinit(std.testing.allocator);
try std.testing.expect(result.quit);
try std.testing.expect(std.mem.indexOf(u8, result.frame, "aébc") != null);
try assertLinesFit(result.frame, 12);
try std.testing.expectEqualStrings("aébc", result.saved_bytes.?);
const recording =
\\protocol open abc
\\protocol command move_right
\\input insert é
\\save aébc
\\
;
const replay_result = try replay.replayText(std.testing.allocator, recording);
defer replay_result.deinit(std.testing.allocator);
switch (replay_result) {
.ok => {},
.diverged => return error.ExpectedReplayOk,
}
}
test "regular: backspace deletes whole UTF-8 codepoint through terminal client" {
var client = try Client.init(std.testing.allocator, .{ .width = 10, .height = 3 });
defer client.deinit();
try client.handleTraceLine("open aéb");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleTraceLine("backspace");
try client.handleTraceLine("save");
try std.testing.expectEqualStrings("ab", try client.saved());
}
test "regular: resize changes render width without changing buffer bytes" {
var client = try Client.init(std.testing.allocator, .{ .width = 8, .height = 3 });
defer client.deinit();
try client.handleTraceLine("open abcdefghijk");
try client.handleTraceLine("resize 5x3");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try assertLinesFit(frame, 5);
try client.handleTraceLine("save");
try std.testing.expectEqualStrings("abcdefghijk", try client.saved());
}
test "adversarial: tiny or malformed resize is rejected" {
var client = try Client.init(std.testing.allocator, .{ .width = 4, .height = 3 });
defer client.deinit();
try client.handleTraceLine("open abc");
try std.testing.expectError(Error.ViewportTooSmall, client.handleTraceLine("resize 0x3"));
try std.testing.expectError(Error.InvalidResize, client.handleTraceLine("resize phone"));
}
test "adversarial: invalid UTF-8 insertion is rejected and previous bytes can still save" {
var client = try Client.init(std.testing.allocator, .{ .width = 10, .height = 3 });
defer client.deinit();
try client.handleTraceLine("open safe");
const bad = [_]u8{ 'i', 'n', 's', 'e', 'r', 't', ' ', 0xc3, 0x28 };
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine(&bad));
try client.handleTraceLine("save");
try std.testing.expectEqualStrings("safe", try client.saved());
}
test "adversarial: quit prevents further edits" {
var client = try Client.init(std.testing.allocator, .{ .width = 10, .height = 3 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("quit");
try std.testing.expectError(Error.ClientQuit, client.handleTraceLine("insert x"));
}
test "regular: leader rail is visible in terminal render and dispatches save" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("key space");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "leader: w save") != null);
try client.handleTraceLine("key w");
try std.testing.expectEqualStrings("abc", try client.saved());
}
test "regular: leader rail dispatches quit" {
var client = try Client.init(std.testing.allocator, .{ .width = 40, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("key space");
try client.handleTraceLine("key q");
try std.testing.expect(client.quit);
try std.testing.expectError(Error.ClientQuit, client.handleTraceLine("insert x"));
}
test "regular: leader open prompt opens typed UTF-8 payload" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open old");
try client.handleTraceLine("key space");
try client.handleTraceLine("key o");
try client.handleTraceLine("type café.zig");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "café.zig") != null);
try client.handleTraceLine("key enter");
try client.handleTraceLine("key space");
try client.handleTraceLine("key w");
try std.testing.expectEqualStrings("café.zig", try client.saved());
}
test "regular: leader search rail opens file search and panel-close recovers as not-built" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("key space");
try client.handleTraceLine("key s");
try client.handleTraceLine("key f");
const search_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(search_frame);
try std.testing.expect(std.mem.indexOf(u8, search_frame, "search: type query") != null);
try client.handleTraceLine("key escape");
try client.handleTraceLine("key space");
try client.handleTraceLine("key x");
const close_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(close_frame);
try std.testing.expect(std.mem.indexOf(u8, close_frame, "panel close is not built") != null);
}
test "adversarial: unknown leader input recovers without saving or quitting" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("key space");
try client.handleTraceLine("key ?");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "unknown leader key") != null);
try std.testing.expect(!client.quit);
try std.testing.expectError(Error.NothingSaved, client.saved());
}
fn expectSymbolTrace(symbol_key: []const u8, expected_bytes: []const u8, expected_cursor_byte: usize) !void {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open base");
try client.handleTraceLine("key space");
try client.handleTraceLine("key p");
const rail = try client.render(std.testing.allocator);
defer std.testing.allocator.free(rail);
try std.testing.expect(std.mem.indexOf(u8, rail, "symbols:") != null);
const line = try std.fmt.allocPrint(std.testing.allocator, "key {s}", .{symbol_key});
defer std.testing.allocator.free(line);
try client.handleTraceLine(line);
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings(expected_bytes, snap.bytes);
try std.testing.expectEqual(expected_cursor_byte, snap.cursor_byte);
}
test "regular: symbol rail inserts paired braces brackets parens and quotes with cursor inside" {
try expectSymbolTrace("p", "()base", 1);
try expectSymbolTrace("b", "[]base", 1);
try expectSymbolTrace("c", "{}base", 1);
try expectSymbolTrace("q", "\"\"base", 1);
try expectSymbolTrace("e", "''base", 1);
try expectSymbolTrace("t", "``base", 1);
}
test "regular: symbol rail inserts slash pipe and underscore as single symbols" {
try expectSymbolTrace("s", "/base", 1);
try expectSymbolTrace("v", "|base", 1);
try expectSymbolTrace("u", "_base", 1);
}
test "adversarial: unknown symbol key does not mutate the buffer" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open base");
try client.handleTraceLine("key space");
try client.handleTraceLine("key p");
try client.handleTraceLine("key ?");
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("base", snap.bytes);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "unknown symbol key") != null);
}
test "regular: narrow terminal renders active panel instead of editor and returns cleanly" {
var client = try Client.init(std.testing.allocator, .{ .width = 20, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open editor-text");
try client.handleTraceLine("panel_open files");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "panel [files]") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "editor-text") == null);
try assertLinesFit(frame, 20);
try client.handleTraceLine("panel_close");
const editor_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(editor_frame);
try std.testing.expect(std.mem.indexOf(u8, editor_frame, "editor-text") != null);
try std.testing.expect(std.mem.indexOf(u8, editor_frame, "panel [files]") == null);
try assertLinesFit(editor_frame, 20);
}
test "regular: nested panel breadcrumbs render on narrow terminal without overflow" {
var client = try Client.init(std.testing.allocator, .{ .width = 18, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("panel_open files");
try client.handleTraceLine("panel_open diagnostics");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "panel files>") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "[diagnostics]") == null);
try assertLinesFit(frame, 18);
try client.handleTraceLine("panel_prev");
const previous_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(previous_frame);
try std.testing.expect(std.mem.indexOf(u8, previous_frame, "panel [files]") != null);
try assertLinesFit(previous_frame, 18);
}
test "adversarial: invalid panel title and empty close recover without changing editor render" {
var client = try Client.init(std.testing.allocator, .{ .width = 16, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("panel_open bad title"));
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("panel_close"));
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "abc") != null);
try assertLinesFit(frame, 16);
}
test "regular: list panel filters moves selects and renders rows" {
var client = try Client.init(std.testing.allocator, .{ .width = 32, .height = 5 });
defer client.deinit();
try client.handleTraceLine("list_open files src/main.zig|src/panel.zig|README.md");
try client.handleTraceLine("list_filter src");
try client.handleTraceLine("list_down");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "panel [files]") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "> src/panel.zig") != null);
try assertLinesFit(frame, 32);
try client.handleTraceLine("list_select");
const summary = try client.session.panelSummaryAlloc(std.testing.allocator);
defer std.testing.allocator.free(summary);
try std.testing.expectEqualStrings("list:filter=src,cursor=1,visible=2,selected=src/panel.zig", summary);
}
test "regular: list cancel returns to previous editor surface" {
var client = try Client.init(std.testing.allocator, .{ .width = 24, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("list_open files a.zig|b.zig");
try client.handleTraceLine("list_cancel");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "abc") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "panel") == null);
}
test "adversarial: list no-match state and invalid actions recover" {
var client = try Client.init(std.testing.allocator, .{ .width = 24, .height = 4 });
defer client.deinit();
try client.handleTraceLine("list_open files a.zig|b.zig");
try client.handleTraceLine("list_filter none");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "no matches") != null);
try assertLinesFit(frame, 24);
try client.handleTraceLine("list_cancel");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("list_down"));
}
test "regular: save status appears near editor status line" {
var client = try Client.init(std.testing.allocator, .{ .width = 20, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("key space");
try client.handleTraceLine("key w");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "saved") != null);
try assertLinesFit(frame, 20);
}
test "regular: empty generic panel shows local empty state" {
var client = try Client.init(std.testing.allocator, .{ .width = 22, .height = 4 });
defer client.deinit();
try client.handleTraceLine("panel_open help");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "help: no content yet") != null);
try assertLinesFit(frame, 22);
}
test "adversarial: protocol errors render recoverable local message" {
var client = try Client.init(std.testing.allocator, .{ .width = 24, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("panel_open bad title"));
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "error: invalid panel") != null);
try assertLinesFit(frame, 24);
}
test "adversarial: long feedback messages are clipped to viewport width" {
var client = try Client.init(std.testing.allocator, .{ .width = 16, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("message this-message-is-way-too-long-for-the-phone-width");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try assertLinesFit(frame, 16);
try std.testing.expect(std.mem.indexOf(u8, frame, "this-message-is-") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "phone-width") == null);
}
test "regular: render diagnostics report ok for representative narrow editor frame" {
var client = try Client.init(std.testing.allocator, .{ .width = 32, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open fn main() {}");
try client.handleTraceLine("key space");
try client.handleTraceLine("key p");
try client.handleTraceLine("key c");
try client.handleTraceLine("type x");
const result = try client.renderWithDiagnostics(std.testing.allocator);
defer result.deinit(std.testing.allocator);
try std.testing.expectEqual(@as(usize, 5), result.diagnostics.frame_lines);
try std.testing.expect(result.diagnostics.frame_bytes <= 32 * 5 * 4);
try std.testing.expect(result.diagnostics.max_line_cells <= 32);
try std.testing.expectEqual(@as(usize, 0), result.diagnostics.clipped_sources);
try std.testing.expect(std.mem.indexOf(u8, result.warning, "render ok") != null);
}
test "regular: render diagnostics report ok for representative list panel frame" {
var client = try Client.init(std.testing.allocator, .{ .width = 36, .height = 5 });
defer client.deinit();
try client.handleTraceLine("list_open files src/main.zig|src/panel.zig|README.md");
try client.handleTraceLine("list_filter src");
try client.handleTraceLine("list_down");
const result = try client.renderWithDiagnostics(std.testing.allocator);
defer result.deinit(std.testing.allocator);
try std.testing.expectEqual(@as(usize, 5), result.diagnostics.frame_lines);
try std.testing.expect(result.diagnostics.frame_bytes <= 36 * 5 * 4);
try std.testing.expect(result.diagnostics.max_line_cells <= 36);
try std.testing.expectEqual(@as(usize, 0), result.diagnostics.clipped_sources);
try std.testing.expect(std.mem.indexOf(u8, result.warning, "render ok") != null);
}
test "adversarial: render diagnostics name clipped editor sources" {
var client = try Client.init(std.testing.allocator, .{ .width = 12, .height = 4 });
defer client.deinit();
try client.handleTraceLine("open this-line-is-far-too-long-for-phone");
const result = try client.renderWithDiagnostics(std.testing.allocator);
defer result.deinit(std.testing.allocator);
try std.testing.expectEqual(@as(usize, 4), result.diagnostics.frame_lines);
try std.testing.expect(result.diagnostics.max_line_cells <= 12);
try std.testing.expect(result.diagnostics.clipped_sources >= 1);
try std.testing.expect(std.mem.indexOf(u8, result.warning, "clipped") != null);
try std.testing.expect(std.mem.indexOf(u8, result.warning, "12 columns") != null);
}
test "adversarial: render diagnostics name clipped panel sources" {
var client = try Client.init(std.testing.allocator, .{ .width = 14, .height = 4 });
defer client.deinit();
try client.handleTraceLine("list_open files src/very-long-mobile-render-file-name.zig|b.zig");
const result = try client.renderWithDiagnostics(std.testing.allocator);
defer result.deinit(std.testing.allocator);
try std.testing.expectEqual(@as(usize, 4), result.diagnostics.frame_lines);
try std.testing.expect(result.diagnostics.max_line_cells <= 14);
try std.testing.expect(result.diagnostics.clipped_sources >= 1);
try std.testing.expect(std.mem.indexOf(u8, result.warning, "clipped") != null);
}
test "regular: file picker respects gitignore by default and opens selected file" {
var client = try Client.init(std.testing.allocator, .{ .width = 40, .height = 6 });
defer client.deinit();
try client.handleTraceLine("repo_gitignore zig-out/");
try client.handleTraceLine("repo_gitignore *.o");
try client.handleTraceLine("repo_file src/main.zig=pubfnmain");
try client.handleTraceLine("repo_file zig-out/bin/mim=binary");
try client.handleTraceLine("repo_file build.o=object");
try client.handleTraceLine("file_picker");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "src/main.zig") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "zig-out") == null);
try std.testing.expect(std.mem.indexOf(u8, frame, "build.o") == null);
}
try client.handleTraceLine("file_open_selected");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "pubfnmain") != null);
}
}
test "regular: file picker include ignored toggle exposes ignored files" {
var client = try Client.init(std.testing.allocator, .{ .width = 40, .height = 6 });
defer client.deinit();
try client.handleTraceLine("repo_gitignore zig-out/");
try client.handleTraceLine("repo_file src/main.zig=main");
try client.handleTraceLine("repo_file zig-out/bin/mim=binary");
try client.handleTraceLine("file_picker all");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "src/main.zig") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "zig-out/bin/mim") != null);
}
test "regular: file tree uses the same panel primitive and include ignored boundary" {
var client = try Client.init(std.testing.allocator, .{ .width = 40, .height = 6 });
defer client.deinit();
try client.handleTraceLine("repo_gitignore tmp/");
try client.handleTraceLine("repo_file src/lib.zig=lib");
try client.handleTraceLine("repo_file tmp/log.txt=log");
try client.handleTraceLine("file_tree");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "src/lib.zig") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "tmp/log") == null);
}
try client.handleTraceLine("panel_close");
try client.handleTraceLine("file_tree all");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "tmp/log.txt") != null);
}
}
test "adversarial: invalid repo paths and missing selections fail without corrupting editor" {
var client = try Client.init(std.testing.allocator, .{ .width = 32, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open safe");
try std.testing.expectError(repo_mod.Error.InvalidPath, client.handleTraceLine("repo_file ../secret=x"));
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("file_open_selected"));
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "safe") != null);
}
test "regular: project text search lists matches filters results and jumps to match" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer client.deinit();
try client.handleTraceLine("repo_file src/main.zig=abc_needle");
try client.handleTraceLine("repo_file src/lib.zig=needle_lib");
try client.handleTraceLine("search_text needle");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "src/main.zig:1:5") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "src/lib.zig:1:1") != null);
}
try client.handleTraceLine("list_filter lib");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "src/lib.zig:1:1") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "src/main.zig") == null);
}
try client.handleTraceLine("search_open_selected");
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("needle_lib", snap.bytes);
try std.testing.expectEqual(@as(usize, 0), snap.cursor_byte);
}
test "regular: project text search respects ignored files unless include ignored is explicit" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 5 });
defer client.deinit();
try client.handleTraceLine("repo_gitignore zig-out/");
try client.handleTraceLine("repo_file src/main.zig=needle");
try client.handleTraceLine("repo_file zig-out/log.txt=needle");
try client.handleTraceLine("search_text needle");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "src/main.zig") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "zig-out") == null);
}
try client.handleTraceLine("panel_close");
try client.handleTraceLine("search_text all needle");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "zig-out/log.txt") != null);
}
}
test "adversarial: project text search failures do not corrupt current buffer" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open safe");
try client.handleTraceLine("repo_file src/main.zig=needle");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("search_text two words"));
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("search_open_selected"));
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
}
fn makeTuiGitFixture(allocator: std.mem.Allocator) !struct { tmp: std.testing.TmpDir, cwd: []u8 } {
var tmp = std.testing.tmpDir(.{});
errdefer tmp.cleanup();
var src = try tmp.dir.createDirPathOpen(std.testing.io, "src", .{});
src.close(std.testing.io);
try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "src/main.zig", .data = "const old = 1;\n" });
const cwd = try std.fmt.allocPrint(allocator, ".zig-cache/tmp/{s}", .{&tmp.sub_path});
errdefer allocator.free(cwd);
try runGitTuiTest(allocator, cwd, &.{ "init", "--quiet" });
try runGitTuiTest(allocator, cwd, &.{ "add", "src/main.zig" });
try runGitTuiTest(allocator, cwd, &.{ "-c", "user.email=test@example.invalid", "-c", "user.name=Test", "commit", "--quiet", "-m", "init" });
try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "src/main.zig", .data = "const new = 2;\n" });
return .{ .tmp = tmp, .cwd = cwd };
}
fn runGitTuiTest(allocator: std.mem.Allocator, cwd: []const u8, args: []const []const u8) !void {
var argv = try allocator.alloc([]const u8, args.len + 3);
defer allocator.free(argv);
argv[0] = "git";
argv[1] = "-C";
argv[2] = cwd;
@memcpy(argv[3..], args);
const result = try std.process.run(allocator, std.testing.io, .{
.argv = argv,
.stdout_limit = .limited(64 * 1024),
.stderr_limit = .limited(64 * 1024),
});
defer allocator.free(result.stdout);
defer allocator.free(result.stderr);
try std.testing.expect(switch (result.term) {
.exited => |code| code == 0,
else => false,
});
}
test "regular: git status panel opens changed file into editor" {
var fixture = try makeTuiGitFixture(std.testing.allocator);
defer {
std.testing.allocator.free(fixture.cwd);
fixture.tmp.cleanup();
}
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 64, .height = 6 }, std.testing.io);
defer client.deinit();
const status = try std.fmt.allocPrint(std.testing.allocator, "git_status {s}", .{fixture.cwd});
defer std.testing.allocator.free(status);
try client.handleTraceLine(status);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "git-status") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "modified:src/main.zig") != null);
}
const open_changed = try std.fmt.allocPrint(std.testing.allocator, "git_open_changed_selected {s}", .{fixture.cwd});
defer std.testing.allocator.free(open_changed);
try client.handleTraceLine(open_changed);
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("const new = 2;\n", snap.bytes);
}
test "regular: git diff panel renders hunks for selected changed file" {
var fixture = try makeTuiGitFixture(std.testing.allocator);
defer {
std.testing.allocator.free(fixture.cwd);
fixture.tmp.cleanup();
}
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 72, .height = 7 }, std.testing.io);
defer client.deinit();
const status = try std.fmt.allocPrint(std.testing.allocator, "git_status {s}", .{fixture.cwd});
defer std.testing.allocator.free(status);
try client.handleTraceLine(status);
const diff = try std.fmt.allocPrint(std.testing.allocator, "git_diff_selected {s}", .{fixture.cwd});
defer std.testing.allocator.free(diff);
try client.handleTraceLine(diff);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "git-diff") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "hunk:@@") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "add:const_new_=_2;") != null);
}
test "adversarial: git status errors are visible in panel" {
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 64, .height = 5 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("git_status /definitely/not/a/mim/repo");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "git_error:") != null);
}
fn makeTuiJobFixture(allocator: std.mem.Allocator) !struct { tmp: std.testing.TmpDir, cwd: []u8 } {
var tmp = std.testing.tmpDir(.{});
errdefer tmp.cleanup();
var src = try tmp.dir.createDirPathOpen(std.testing.io, "src", .{});
src.close(std.testing.io);
try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "src/main.zig", .data = "one\nabcdTARGET\n" });
try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "fail.sh", .data = "printf 'src/main.zig:2:5:error:bad\\n'\nexit 1\n" });
const cwd = try std.fmt.allocPrint(allocator, ".zig-cache/tmp/{s}", .{&tmp.sub_path});
errdefer allocator.free(cwd);
return .{ .tmp = tmp, .cwd = cwd };
}
test "regular: job panel captures failing command output and jumps to file line" {
var fixture = try makeTuiJobFixture(std.testing.allocator);
defer {
std.testing.allocator.free(fixture.cwd);
fixture.tmp.cleanup();
}
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 72, .height = 7 }, std.testing.io);
defer client.deinit();
const run = try std.fmt.allocPrint(std.testing.allocator, "job_run {s} sh fail.sh", .{fixture.cwd});
defer std.testing.allocator.free(run);
try client.handleTraceLine(run);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "job-output") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "job:status:exit_1") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "stdout:src/main.zig:2:5:error:bad") != null);
}
try client.handleTraceLine("list_filter src/main.zig");
const open = try std.fmt.allocPrint(std.testing.allocator, "job_open_selected {s}", .{fixture.cwd});
defer std.testing.allocator.free(open);
try client.handleTraceLine(open);
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("one\nabcdTARGET\n", snap.bytes);
try std.testing.expectEqual(@as(usize, 8), snap.cursor_byte);
}
test "regular: job status and cancel expose honest foreground state rows" {
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 56, .height = 5 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("job_status");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "job_status:idle") != null);
}
try client.handleTraceLine("job_cancel");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "job_cancel:no_running_job") != null);
}
}
test "adversarial: bad job command is visible and failed job open does not corrupt buffer" {
var fixture = try makeTuiJobFixture(std.testing.allocator);
defer {
std.testing.allocator.free(fixture.cwd);
fixture.tmp.cleanup();
}
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 72, .height = 6 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("open safe");
const run = try std.fmt.allocPrint(std.testing.allocator, "job_run {s} definitely-not-a-mim-command", .{fixture.cwd});
defer std.testing.allocator.free(run);
try client.handleTraceLine(run);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "job:status:spawn_error_") != null);
const open = try std.fmt.allocPrint(std.testing.allocator, "job_open_selected {s}", .{fixture.cwd});
defer std.testing.allocator.free(open);
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine(open));
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
}
test "regular: terminal escape hatch runs shell command exits and returns editor" {
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 72, .height = 6 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("open safe_editor");
try client.handleTraceLine("terminal_run . printf terminal_ok");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "terminal-output") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "terminal:status:exit_0") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "stdout:terminal_ok") != null);
}
try client.handleTraceLine("terminal_exit");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "terminal-output") == null);
try std.testing.expect(std.mem.indexOf(u8, frame, "safe_editor") != null);
}
test "regular: terminal status and cancel are honest foreground lifecycle rows" {
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 64, .height = 5 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("terminal_status");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "terminal-status") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "terminal_status:idle") != null);
}
try client.handleTraceLine("terminal_cancel");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "terminal_cancel:no_running_terminal") != null);
}
}
test "adversarial: terminal command rejection does not corrupt editor" {
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 72, .height = 5 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("open safe");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("terminal_run . "));
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
try client.handleTraceLine("terminal_run . definitely-not-a-mim-command");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "terminal:status:exit_127") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "stderr:") != null);
}
test "regular: syntax spans panel renders zig highlight classes" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 7 });
defer client.deinit();
try client.handleTraceLine("open pub const answer = 42; // ok");
try client.handleTraceLine("syntax_spans zig");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "syntax-spans") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "syntax:zig:keyword:0:3:pub") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "syntax:zig:keyword:4:9:const") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "syntax:zig:number:") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "syntax:zig:comment:") != null);
}
test "regular: syntax text fallback renders no spans row" {
var client = try Client.init(std.testing.allocator, .{ .width = 72, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open pub_const_plain_text");
try client.handleTraceLine("syntax_spans text");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "syntax:text:fallback:no_spans") != null);
}
test "adversarial: unsupported syntax language is rejected without changing buffer" {
var client = try Client.init(std.testing.allocator, .{ .width = 72, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open safe");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("syntax_spans python"));
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
}
fn makeTuiLspFixture(allocator: std.mem.Allocator) !struct { tmp: std.testing.TmpDir, cwd: []u8 } {
var tmp = std.testing.tmpDir(.{});
errdefer tmp.cleanup();
const cwd = try std.fmt.allocPrint(allocator, ".zig-cache/tmp/{s}", .{&tmp.sub_path});
errdefer allocator.free(cwd);
return .{ .tmp = tmp, .cwd = cwd };
}
test "regular: lsp sync panel sends current buffer to fake server" {
var fixture = try makeTuiLspFixture(std.testing.allocator);
defer {
std.testing.allocator.free(fixture.cwd);
fixture.tmp.cleanup();
}
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 72, .height = 9 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("open pub const x = 1;");
const sync = try std.fmt.allocPrint(std.testing.allocator, "lsp_sync {s} file:///tmp/main.zig zig sh -c cat>observed.lsp", .{fixture.cwd});
defer std.testing.allocator.free(sync);
try client.handleTraceLine(sync);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-sync") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:sent:initialize") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:sent:textDocument/didOpen") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:sent:textDocument/didChange") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:sent:textDocument/didSave") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:status:exit_0") != null);
}
const observed = try fixture.tmp.dir.readFileAlloc(std.testing.io, "observed.lsp", std.testing.allocator, .limited(64 * 1024));
defer std.testing.allocator.free(observed);
try std.testing.expect(std.mem.indexOf(u8, observed, "pub const x = 1;") != null);
try std.testing.expect(std.mem.indexOf(u8, observed, "textDocument/didOpen") != null);
}
test "adversarial: lsp sync rejection does not corrupt current buffer" {
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 72, .height = 5 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("open safe");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_sync ."));
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_sync . bad uri zig sh -c cat"));
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
}
test "regular: lsp diagnostics panel renders rows and jumps to diagnostic" {
var client = try Client.init(std.testing.allocator, .{ .width = 96, .height = 7 });
defer client.deinit();
try client.handleTraceLine("open one\\nabcdTARGET");
const payload =
\\{"jsonrpc":"2.0","method":"textDocument/publishDiagnostics","params":{"uri":"file:///tmp/main.zig","diagnostics":[{"range":{"start":{"line":0,"character":4},"end":{"line":1,"character":5}},"severity":1,"message":"expected semicolon"}]}}
;
const command = try std.fmt.allocPrint(std.testing.allocator, "lsp_diagnostics {s}", .{payload});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-diagnostics") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:diagnostics:count_1") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:diag:error:1:5:file_///tmp/main.zig:expected_semicolon") != null);
}
try client.handleTraceLine("list_down");
try client.handleTraceLine("lsp_diagnostics_open_selected");
const snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 4), snap.cursor_byte);
}
test "adversarial: malformed diagnostics and unselected summary row do not corrupt buffer" {
var client = try Client.init(std.testing.allocator, .{ .width = 72, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open safe");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_diagnostics not-json"));
const payload =
\\{"jsonrpc":"2.0","method":"textDocument/publishDiagnostics","params":{"uri":"file:///tmp/main.zig","diagnostics":[{"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":1}},"severity":2,"message":"warn"}]}}
;
const command = try std.fmt.allocPrint(std.testing.allocator, "lsp_diagnostics {s}", .{payload});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_diagnostics_open_selected"));
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
}
test "regular: lsp definition panel selects and jumps current buffer" {
var client = try Client.init(std.testing.allocator, .{ .width = 96, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open one abcTARGET");
const payload =
\\{"jsonrpc":"2.0","id":2,"result":{"uri":"file:///tmp/main.zig","range":{"start":{"line":0,"character":4},"end":{"line":0,"character":7}}}}
;
const command = try std.fmt.allocPrint(std.testing.allocator, "lsp_definition {s}", .{payload});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-definition") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:nav:definition:1:5:file_///tmp/main.zig:location") != null);
}
try client.handleTraceLine("lsp_navigation_open_selected");
const snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 4), snap.cursor_byte);
}
test "regular: lsp references document symbols and workspace symbols render shared panels" {
var client = try Client.init(std.testing.allocator, .{ .width = 112, .height = 7 });
defer client.deinit();
try client.handleTraceLine("open symbol body");
const references_payload =
\\{"jsonrpc":"2.0","id":3,"result":[{"uri":"file:///tmp/main.zig","range":{"start":{"line":0,"character":0},"end":{"line":0,"character":3}}},{"uri":"file:///tmp/lib.zig","range":{"start":{"line":0,"character":7},"end":{"line":0,"character":11}}}]}
;
const references_command = try std.fmt.allocPrint(std.testing.allocator, "lsp_references {s}", .{references_payload});
defer std.testing.allocator.free(references_command);
try client.handleTraceLine(references_command);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-references") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:nav:references:1:1:file_///tmp/main.zig:location") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:nav:references:1:8:file_///tmp/lib.zig:location") != null);
}
const document_payload =
\\{"jsonrpc":"2.0","id":4,"result":[{"name":"main","kind":12,"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":6}},"selectionRange":{"start":{"line":0,"character":0},"end":{"line":0,"character":4}}}]}
;
const document_command = try std.fmt.allocPrint(std.testing.allocator, "lsp_document_symbols {s}", .{document_payload});
defer std.testing.allocator.free(document_command);
try client.handleTraceLine(document_command);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-document-symbols") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:symbol:document:kind_12:1:1:current:main") != null);
}
const workspace_payload =
\\{"jsonrpc":"2.0","id":5,"result":[{"name":"helper","kind":12,"location":{"uri":"file:///tmp/lib.zig","range":{"start":{"line":0,"character":7},"end":{"line":0,"character":11}}}}]}
;
const workspace_command = try std.fmt.allocPrint(std.testing.allocator, "lsp_workspace_symbols {s}", .{workspace_payload});
defer std.testing.allocator.free(workspace_command);
try client.handleTraceLine(workspace_command);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-workspace-symbols") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:symbol:workspace:kind_12:1:8:file_///tmp/lib.zig:helper") != null);
}
}
test "adversarial: lsp navigation failures do not corrupt buffer" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open safe");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_definition not-json"));
const none_payload =
\\{"jsonrpc":"2.0","id":2,"result":null}
;
const command = try std.fmt.allocPrint(std.testing.allocator, "lsp_definition {s}", .{none_payload});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_navigation_open_selected"));
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
}
test "regular: lsp rename preview applies selected edit after confirmation" {
var client = try Client.init(std.testing.allocator, .{ .width = 112, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open pub old = old;");
const payload =
\\{"jsonrpc":"2.0","id":6,"result":{"changes":{"file:///tmp/main.zig":[{"range":{"start":{"line":0,"character":4},"end":{"line":0,"character":7}},"newText":"renamed"}]}}}
;
const command = try std.fmt.allocPrint(std.testing.allocator, "lsp_rename {s}", .{payload});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-edit-preview") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:edit:rename:1:5:1:8:72656e616d6564") != null);
}
try client.handleTraceLine("lsp_edit_apply_selected");
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("pub renamed = old;", snap.bytes);
try std.testing.expectEqual(@as(usize, 11), snap.cursor_byte);
}
test "regular: lsp code action preview applies selected workspace edit" {
var client = try Client.init(std.testing.allocator, .{ .width = 112, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open var x = 1;");
const payload =
\\{"jsonrpc":"2.0","id":7,"result":[{"title":"replace with const","kind":"quickfix","edit":{"changes":{"file:///tmp/main.zig":[{"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":3}},"newText":"const"}]}}}]}
;
const command = try std.fmt.allocPrint(std.testing.allocator, "lsp_code_actions {s}", .{payload});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-code-actions") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "replace_with_const") != null);
}
try client.handleTraceLine("lsp_edit_apply_selected");
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("const x = 1;", snap.bytes);
}
test "adversarial: lsp edit failures do not corrupt current buffer" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open safe");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_rename not-json"));
const command_only_payload =
\\{"jsonrpc":"2.0","id":7,"result":[{"title":"command only","command":{"title":"noop","command":"noop"}}]}
;
const command = try std.fmt.allocPrint(std.testing.allocator, "lsp_code_actions {s}", .{command_only_payload});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_edit_apply_selected"));
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
}
test "regular: lsp hover wraps inside narrow viewport" {
var client = try Client.init(std.testing.allocator, .{ .width = 32, .height = 7 });
defer client.deinit();
const payload =
\\{"jsonrpc":"2.0","id":8,"result":{"contents":{"kind":"markdown","value":"pub fn add(lhs: i32, rhs: i32) i32"}}}
;
const command = try std.fmt.allocPrint(std.testing.allocator, "lsp_hover {s}", .{payload});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-hover") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:hover:") != null);
try assertLinesFit(frame, 32);
}
test "regular: lsp signature shows active parameter in shared panel" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 7 });
defer client.deinit();
const payload =
\\{"jsonrpc":"2.0","id":9,"result":{"activeSignature":0,"activeParameter":1,"signatures":[{"label":"add(lhs: i32, rhs: i32)","parameters":[{"label":"lhs: i32"},{"label":"rhs: i32"}]}]}}
;
const command = try std.fmt.allocPrint(std.testing.allocator, "lsp_signature {s}", .{payload});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp-signature") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:signature:active_2") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:signature:param_2:active") != null);
}
test "regular: lsp parameter movement updates cursor and reports active parameter" {
var client = try Client.init(std.testing.allocator, .{ .width = 72, .height = 6 });
defer client.deinit();
try client.session.openFixtureAt("add(alpha, beta, gamma)", 5);
try client.handleTraceLine("lsp_param_next");
var snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 11), snap.cursor_byte);
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:param:active_2:11") != null);
}
try client.handleTraceLine("lsp_param_previous");
snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 4), snap.cursor_byte);
}
test "adversarial: malformed hover signature and non-call parameter movement are safe" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open safe");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_hover not-json"));
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("lsp_signature not-json"));
try client.handleTraceLine("lsp_param_next");
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "lsp:param:outside_call") != null);
}
fn makeTuiPiFixture(allocator: std.mem.Allocator) !struct { tmp: std.testing.TmpDir, script: []u8 } {
var tmp = std.testing.tmpDir(.{});
errdefer tmp.cleanup();
try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "fake-pi.sh", .data = "case \"$1\" in *context:v1*) echo pi_ok;; *) echo missing; exit 2;; esac\n" });
const script = try std.fmt.allocPrint(allocator, ".zig-cache/tmp/{s}/fake-pi.sh", .{&tmp.sub_path});
errdefer allocator.free(script);
return .{ .tmp = tmp, .script = script };
}
test "regular: pi bridge sends context to fake pi and renders output panel" {
var fixture = try makeTuiPiFixture(std.testing.allocator);
defer {
std.testing.allocator.free(fixture.script);
fixture.tmp.cleanup();
}
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 80, .height = 7 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("open working buffer");
const command = try std.fmt.allocPrint(std.testing.allocator, "pi_run sh {s}", .{fixture.script});
defer std.testing.allocator.free(command);
try client.handleTraceLine(command);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "pi-output") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "pi:context:bytes_") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "pi:status:exit_0") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "stdout:pi_ok") != null);
}
test "adversarial: missing pi command is visible and invalid command preserves buffer" {
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 80, .height = 6 }, std.testing.io);
defer client.deinit();
try client.handleTraceLine("open safe");
try std.testing.expectError(Error.ProtocolRejected, client.handleTraceLine("pi_run "));
try client.handleTraceLine("pi_run definitely-not-a-mim-pi");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "pi:status:spawn_error_") != null);
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("safe", snap.bytes);
}
test "regular: modal input exposes normal insert select prompt and panel modes" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open abc");
try std.testing.expectEqualStrings("normal", client.modeName());
try client.handleInput("i");
try std.testing.expectEqualStrings("insert", client.modeName());
try client.handleInput("x");
const inserted = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(inserted);
try std.testing.expectEqualStrings("xabc", inserted);
try client.handleInput(" ");
try std.testing.expectEqualStrings("insert_space", client.pendingRailName());
try client.handleInput("n");
try std.testing.expectEqualStrings("normal", client.modeName());
try client.handleInput("s");
try std.testing.expectEqualStrings("select", client.modeName());
try client.handleInput("n");
try std.testing.expectEqualStrings("normal", client.modeName());
try client.handleInput(" ");
try client.handleInput("o");
try std.testing.expectEqualStrings("prompt", client.modeName());
var panel_client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 8 });
defer panel_client.deinit();
try panel_client.handleTraceLine("panel_open files");
try std.testing.expectEqualStrings("panel", panel_client.modeName());
}
test "regular: modal rails expose match go repeat and unknown recovery" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleInput("m");
try std.testing.expectEqualStrings("match", client.pendingRailName());
const match_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(match_frame);
try std.testing.expect(std.mem.indexOf(u8, match_frame, "match:") != null);
try client.handleInput("z");
try std.testing.expectEqualStrings("none", client.pendingRailName());
const unknown_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(unknown_frame);
try std.testing.expect(std.mem.indexOf(u8, unknown_frame, "unknown normal key") != null);
try client.handleInput("g");
try std.testing.expectEqualStrings("go", client.pendingRailName());
try client.handleInput("d");
try std.testing.expectEqualStrings("none", client.pendingRailName());
try client.handleInput(" ");
try client.handleInput(" ");
try std.testing.expectEqualStrings("go", client.pendingRailName());
try client.handleInput("d");
try client.handleInput(" ");
try client.handleInput("r");
try std.testing.expectEqualStrings("repeat", client.pendingRailName());
try client.handleInput(".");
try std.testing.expectEqualStrings("none", client.pendingRailName());
}
test "regular: counts are pending visible and cleared by one movement" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open abcd");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleInput("2");
try std.testing.expectEqual(@as(usize, 2), client.pendingCount());
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "count pending") != null);
try client.handleInput("h");
try std.testing.expectEqual(@as(usize, 0), client.pendingCount());
try client.handleInput("i");
try client.handleInput("X");
const bytes = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(bytes);
try std.testing.expectEqualStrings("Xabcd", bytes);
}
test "regular: insert pending space commits literal space or returns normal" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open ");
try client.handleInput("i");
try client.handleInput("a");
try client.handleInput(" ");
try client.handleInput("b");
try client.handleInput(" ");
try client.handleInput(" ");
try client.handleInput("c");
const bytes = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(bytes);
try std.testing.expectEqualStrings("a b c", bytes);
try client.handleInput(" ");
try client.handleInput("n");
try std.testing.expectEqualStrings("normal", client.modeName());
}
test "regular: normal core editing delete yank paste undo redo" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open abc\ndef");
try client.handleInput("d");
try client.handleInput("d");
const after_delete = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_delete);
try std.testing.expectEqualStrings("def", after_delete);
try client.handleInput("p");
const after_paste = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_paste);
try std.testing.expectEqualStrings("abc\ndef", after_paste);
try client.handleInput("u");
const after_undo = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_undo);
try std.testing.expectEqualStrings("def", after_undo);
try client.handleInput("U");
const after_redo = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_redo);
try std.testing.expectEqualStrings("abc\ndef", after_redo);
}
test "regular: normal change replace open lines and movement enter insert" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open abc\ndef");
try client.handleInput("r");
try client.handleInput("Z");
const after_replace = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_replace);
try std.testing.expectEqualStrings("Zbc\ndef", after_replace);
try client.handleInput("c");
try client.handleInput("c");
try std.testing.expectEqualStrings("insert", client.modeName());
try client.handleInput("X");
try client.handleInput(" ");
try client.handleInput("n");
const after_change = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_change);
try std.testing.expectEqualStrings("X\ndef", after_change);
try client.handleInput("o");
try client.handleInput("Y");
try client.handleInput(" ");
try client.handleInput("n");
const after_open = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_open);
try std.testing.expectEqualStrings("X\nY\ndef", after_open);
try client.handleInput("0");
try client.handleInput("l");
try client.handleInput("k");
try client.handleInput("w");
try client.handleInput("e");
try client.handleInput("b");
}
test "adversarial: replace rejects invalid utf8 and undo preserves content" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open safe");
const bad = [_]u8{ 0xc3, 0x28 };
try client.handleInput("r");
try client.handleInput(&bad);
const after_bad_replace = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_bad_replace);
try std.testing.expectEqualStrings("safe", after_bad_replace);
try client.handleInput("i");
try client.handleInput("!");
try client.handleInput(" ");
try client.handleInput("n");
try client.handleInput("u");
const after_undo = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_undo);
try std.testing.expectEqualStrings("safe", after_undo);
}
fn isObjectSeparator(byte: u8) bool {
return std.ascii.isWhitespace(byte) or std.mem.indexOfScalar(u8, "(){}[]<>.,;:+-*/=\"'`", byte) != null;
}
fn previousBoundaryLocal(bytes: []const u8, cursor: usize) usize {
return session_mod.boundaryAtOrBefore(bytes, if (cursor == 0) 0 else cursor - 1);
}
fn nextBoundaryLocal(bytes: []const u8, cursor: usize) usize {
var at = cursor + 1;
while (at < bytes.len and (bytes[at] & 0b1100_0000) == 0b1000_0000) at += 1;
return @min(at, bytes.len);
}
fn lineIndent(bytes: []const u8) usize {
var count: usize = 0;
while (count < bytes.len and (bytes[count] == ' ' or bytes[count] == '\t')) count += 1;
return count;
}
fn lineContentLen(bytes: []const u8) usize {
for (bytes) |byte| if (!std.ascii.isWhitespace(byte)) return bytes.len;
return 0;
}
fn trimRange(bytes: []const u8, range: ObjectRange) ObjectRange {
var start = range.start;
var end = range.end;
while (start < end and std.ascii.isWhitespace(bytes[start])) start += 1;
while (end > start and std.ascii.isWhitespace(bytes[end - 1])) end -= 1;
return .{ .start = start, .end = end };
}
fn isPairSelector(byte: u8) bool {
return std.mem.indexOfScalar(u8, "({[\"'`", byte) != null;
}
fn pairChars(selector: u8) struct { open: u8, close: u8, quote: bool } {
return switch (selector) {
'(' => .{ .open = '(', .close = ')', .quote = false },
'{' => .{ .open = '{', .close = '}', .quote = false },
'[' => .{ .open = '[', .close = ']', .quote = false },
'\"' => .{ .open = '\"', .close = '\"', .quote = true },
'\'' => .{ .open = '\'', .close = '\'', .quote = true },
'`' => .{ .open = '`', .close = '`', .quote = true },
else => .{ .open = '(', .close = ')', .quote = false },
};
}
fn findPairForSelector(bytes: []const u8, cursor: usize, selector: u8) ?PairRange {
const chars = pairChars(selector);
if (chars.quote) return findQuotePair(bytes, cursor, chars.open);
var depth: usize = 0;
var open: ?usize = null;
var i: usize = @min(cursor, bytes.len);
while (i > 0) {
i -= 1;
if (bytes[i] == chars.close) depth += 1 else if (bytes[i] == chars.open) {
if (depth == 0) {
open = i;
break;
}
depth -= 1;
}
}
const found_open = open orelse return null;
depth = 0;
i = found_open;
while (i < bytes.len) : (i += 1) {
if (bytes[i] == chars.open) depth += 1 else if (bytes[i] == chars.close) {
depth -= 1;
if (depth == 0) return .{ .open = found_open, .close = i };
}
}
return null;
}
fn findQuotePair(bytes: []const u8, cursor: usize, quote: u8) ?PairRange {
var open: ?usize = null;
var i: usize = 0;
while (i < bytes.len) : (i += 1) {
if (bytes[i] != quote or (i > 0 and bytes[i - 1] == '\\')) continue;
if (open == null) open = i else {
const start = open.?;
if (cursor >= start and cursor <= i) return .{ .open = start, .close = i };
open = null;
}
}
return null;
}
fn findPairAtOrNear(bytes: []const u8, cursor: usize) ?PairRange {
const selectors = "({[\"'`";
if (cursor < bytes.len and isPairSelector(bytes[cursor])) {
if (findPairForSelector(bytes, cursor + 1, bytes[cursor])) |pair| return pair;
}
if (cursor > 0 and isPairSelector(bytes[cursor - 1])) {
if (findPairForSelector(bytes, cursor, bytes[cursor - 1])) |pair| return pair;
}
for (selectors) |selector| {
if (findPairForSelector(bytes, cursor, selector)) |pair| return pair;
}
return null;
}
test "regular: match rail jumps and selects delimiter pairs" {
var client = try Client.init(std.testing.allocator, .{ .width = 60, .height = 10 });
defer client.deinit();
try client.handleTraceLine("open fn main() { call(one, two); }");
try client.handleInput("w");
try client.handleInput("w");
try client.handleInput("w");
try client.handleInput("m");
try client.handleInput("(");
var snap = try client.session.snapshot();
try std.testing.expect(snap.cursor_byte > 7);
try client.handleInput("m");
try client.handleInput("s");
snap = try client.session.snapshot();
try std.testing.expect(snap.selection != null);
try std.testing.expectEqualStrings("one, two", snap.bytes[snap.selection.?.anchor..snap.selection.?.cursor]);
try client.handleInput("m");
try client.handleInput("a");
snap = try client.session.snapshot();
try std.testing.expectEqualStrings("(one, two)", snap.bytes[snap.selection.?.anchor..snap.selection.?.cursor]);
}
test "regular: select mode object grammar selects word line indent parameter and form" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 12 });
defer client.deinit();
try client.handleTraceLine("open fn main() {\n alpha(beta, gamma);\n next();\n}\n");
try client.handleInput("j");
try client.handleInput("w");
try client.handleInput("s");
try client.handleInput("w");
var snap = try client.session.snapshot();
try std.testing.expectEqualStrings("alpha", snap.bytes[snap.selection.?.anchor..snap.selection.?.cursor]);
try client.handleInput("n");
try client.handleInput("s");
try client.handleInput("l");
snap = try client.session.snapshot();
try std.testing.expectEqualStrings(" alpha(beta, gamma);\n", snap.bytes[snap.selection.?.anchor..snap.selection.?.cursor]);
try client.handleInput("n");
try client.handleInput("s");
try client.handleInput("i");
snap = try client.session.snapshot();
try std.testing.expectEqualStrings(" alpha(beta, gamma);\n next();", snap.bytes[snap.selection.?.anchor..snap.selection.?.cursor]);
var param_client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 12 });
defer param_client.deinit();
try param_client.handleTraceLine("open call(beta, gamma)");
try param_client.handleTraceLine("right");
try param_client.handleTraceLine("right");
try param_client.handleTraceLine("right");
try param_client.handleTraceLine("right");
try param_client.handleTraceLine("right");
try param_client.handleTraceLine("right");
try param_client.handleInput("s");
try param_client.handleInput("p");
var param_snap = try param_client.session.snapshot();
try std.testing.expectEqualStrings("beta", param_snap.bytes[param_snap.selection.?.anchor..param_snap.selection.?.cursor]);
var form_client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 12 });
defer form_client.deinit();
try form_client.handleTraceLine("open { alpha(); }");
try form_client.handleTraceLine("right");
try form_client.handleTraceLine("right");
try form_client.handleInput("s");
try form_client.handleInput("f");
var form_snap = try form_client.session.snapshot();
try std.testing.expect(std.mem.startsWith(u8, form_snap.bytes[form_snap.selection.?.anchor..form_snap.selection.?.cursor], "{"));
}
test "regular: delete change yank compose with shared object ranges" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 10 });
defer client.deinit();
try client.handleTraceLine("open alpha beta\n one\n two\nend");
try client.handleInput("d");
try client.handleInput("w");
const after_delete_word = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(after_delete_word);
try std.testing.expectEqualStrings(" beta\n one\n two\nend", after_delete_word);
try client.handleInput("p");
const pasted = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(pasted);
try std.testing.expectEqualStrings("alpha beta\n one\n two\nend", pasted);
try client.handleInput("j");
try client.handleInput("c");
try client.handleInput("i");
try client.handleInput("X");
try client.handleInput(" ");
try client.handleInput("n");
const changed = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(changed);
try std.testing.expectEqualStrings("alpha beta\nX\nend", changed);
}
test "adversarial: unmatched delimiter reports without corrupting buffer" {
var client = try Client.init(std.testing.allocator, .{ .width = 60, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open call(one");
try client.handleInput("m");
try client.handleInput("(");
const bytes = try client.snapshotBytesAlloc(std.testing.allocator);
defer std.testing.allocator.free(bytes);
try std.testing.expectEqualStrings("call(one", bytes);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "unknown normal key") != null or std.mem.indexOf(u8, frame, "NoMatch") != null);
}
test "regular: quote matching ignores escaped quote" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open say(\"a\\\"b\")");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleInput("m");
try client.handleInput("\"");
const snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 4), snap.cursor_byte);
}
test "regular: slash search selects first match and navigates wrap" {
var client = try Client.init(std.testing.allocator, .{ .width = 60, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open alpha beta alpha");
try client.handleInput("/");
try std.testing.expectEqualStrings("prompt", client.modeName());
try client.handleInput("a");
try client.handleInput("l");
try client.handleInput("p");
try client.handleInput("h");
try client.handleInput("a");
try client.handleInput("\n");
var snap = try client.session.snapshot();
try std.testing.expect(snap.selection != null);
try std.testing.expectEqual(@as(usize, 0), snap.selection.?.anchor);
try std.testing.expectEqualStrings("alpha", snap.bytes[snap.selection.?.anchor..snap.selection.?.cursor]);
try client.handleInput("n");
snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 11), snap.selection.?.anchor);
try client.handleInput("n");
snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 0), snap.selection.?.anchor);
try client.handleInput("N");
snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 11), snap.selection.?.anchor);
}
test "regular: space s f opens current-file search prompt without losing save path" {
var client = try Client.init(std.testing.allocator, .{ .width = 60, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open one two one");
try client.handleInput(" ");
try client.handleInput("s");
try client.handleInput("f");
try std.testing.expectEqualStrings("prompt", client.modeName());
try client.handleInput("t");
try client.handleInput("w");
try client.handleInput("o");
try client.handleInput("\n");
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("two", snap.bytes[snap.selection.?.anchor..snap.selection.?.cursor]);
}
test "adversarial: search no match cancel utf8 and long line remain safe" {
var client = try Client.init(std.testing.allocator, .{ .width = 30, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open short élan veryveryveryverylongline élan");
try client.handleInput("/");
try client.handleInput("z");
try client.handleInput("\n");
const no_match_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(no_match_frame);
try std.testing.expect(std.mem.indexOf(u8, no_match_frame, "no search matches") != null);
try client.handleInput("/");
try client.handleInput("x");
try client.handleInput("\x1b");
const cancel_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(cancel_frame);
try std.testing.expect(std.mem.indexOf(u8, cancel_frame, "search cancelled") != null);
try client.handleInput("/");
try client.handleInput("é");
try client.handleInput("l");
try client.handleInput("a");
try client.handleInput("n");
try client.handleInput("\n");
var snap = try client.session.snapshot();
try std.testing.expectEqualStrings("élan", snap.bytes[snap.selection.?.anchor..snap.selection.?.cursor]);
try client.handleInput("n");
snap = try client.session.snapshot();
try std.testing.expect(snap.cursor_byte > 20);
}
test "regular: file picker panel opens selected repo file" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 10 });
defer client.deinit();
try client.handleTraceLine("repo_file src/main.zig=const main = 1;");
try client.handleTraceLine("repo_file src/lib.zig=const lib = 2;");
try client.handleInput(" ");
try client.handleInput("f");
var snap = try client.session.snapshot();
try std.testing.expect(snap.active_panel_title != null);
try client.handleInput("o");
snap = try client.session.snapshot();
try std.testing.expectEqualStrings("const main = 1;", snap.bytes);
try std.testing.expect(snap.active_panel_title == null);
}
test "regular: project search panel opens selected result at match" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 10 });
defer client.deinit();
try client.handleTraceLine("repo_file src/main.zig=alpha\nneedle here\n");
try client.handleTraceLine("repo_file src/lib.zig=other\n");
try client.handleInput(" ");
try client.handleInput("s");
try client.handleInput("p");
try std.testing.expectEqualStrings("prompt", client.modeName());
try client.handleInput("n");
try client.handleInput("e");
try client.handleInput("e");
try client.handleInput("d");
try client.handleInput("l");
try client.handleInput("e");
try client.handleInput("\n");
var snap = try client.session.snapshot();
try std.testing.expect(snap.active_panel_title != null);
try client.handleInput("o");
snap = try client.session.snapshot();
try std.testing.expectEqualStrings("alpha\nneedle here\n", snap.bytes);
try std.testing.expect(snap.cursor_byte >= 6);
}
test "adversarial: file and project panels handle ignored empty missing and close" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 10 });
defer client.deinit();
try client.handleTraceLine("repo_file src/main.zig=visible");
try client.handleInput(" ");
try client.handleInput("f");
const picker_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(picker_frame);
try std.testing.expect(std.mem.indexOf(u8, picker_frame, "src/main.zig") != null);
try client.handleInput("q");
const snap = try client.session.snapshot();
try std.testing.expect(snap.active_panel_title == null);
try client.handleInput(" ");
try client.handleInput("s");
try client.handleInput("p");
try client.handleInput("missing");
try client.handleInput("\n");
const no_match_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(no_match_frame);
try std.testing.expect(std.mem.indexOf(u8, no_match_frame, "no project matches") != null);
}
test "regular: language rail shows compact hover signature and expandable hover" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 8 });
defer client.deinit();
try client.handleTraceLine("lsp_hover_fixture zls|add(lhs, rhs)|Very long documentation that should be compact first and expanded only on request.");
try client.handleTraceLine("lsp_signature_fixture zls|add(lhs: i32, rhs: i32) active=rhs");
try client.handleInput(" ");
try client.handleInput("l");
try client.handleInput("h");
const hover_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(hover_frame);
try std.testing.expect(std.mem.indexOf(u8, hover_frame, "[zls] add(lhs, rhs)") != null);
try assertLinesFit(hover_frame, 48);
try client.handleInput(" ");
try client.handleInput("l");
try client.handleInput("s");
const signature_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(signature_frame);
try std.testing.expect(std.mem.indexOf(u8, signature_frame, "[zls] add(lhs: i32, rhs: i32) active=rhs") != null);
try client.handleInput(" ");
try client.handleInput("l");
try client.handleInput("o");
const expanded_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(expanded_frame);
try std.testing.expect(std.mem.indexOf(u8, expanded_frame, "hover_provider:zls") != null);
try std.testing.expect(std.mem.indexOf(u8, expanded_frame, "Very_long_documentation") != null);
}
test "adversarial: missing hover and signature providers are visible" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 6 });
defer client.deinit();
try client.handleInput(" ");
try client.handleInput("l");
try client.handleInput("h");
const hover_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(hover_frame);
try std.testing.expect(std.mem.indexOf(u8, hover_frame, "NoProvider:hover") != null);
try client.handleInput(" ");
try client.handleInput("l");
try client.handleInput("s");
const signature_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(signature_frame);
try std.testing.expect(std.mem.indexOf(u8, signature_frame, "NoProvider:signature") != null);
}
test "regular: go rail parameter movement uses keymap paths" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open call(alpha, beta, gamma)");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleTraceLine("right");
try client.handleInput("g");
try client.handleInput("a");
var snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 12), snap.cursor_byte);
try client.handleInput("g");
try client.handleInput("A");
snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 5), snap.cursor_byte);
}
test "regular: diagnostics panel preserves providers filters and navigates" {
var client = try Client.init(std.testing.allocator, .{ .width = 72, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open abcdef\nsecond");
try client.handleTraceLine("diagnostic_fixture zls|1|main.zig|1|3|error|bad_token");
try client.handleTraceLine("diagnostic_fixture lint|1|main.zig|1|3|warning|style_duplicate");
try client.handleTraceLine("diagnostic_fixture zls|1|main.zig|8|13|info|second_line");
try client.handleInput(" ");
try client.handleInput("d");
const panel_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(panel_frame);
try std.testing.expect(std.mem.indexOf(u8, panel_frame, "diag:fresh:zls:error:1-3:main.zig:bad_token") != null);
try std.testing.expect(std.mem.indexOf(u8, panel_frame, "diag:fresh:lint:warning:1-3:main.zig:style_duplicate") != null);
try client.handleInput("f");
const filtered_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(filtered_frame);
try std.testing.expect(std.mem.indexOf(u8, filtered_frame, "diag:fresh:zls:error:1-3") != null);
try std.testing.expect(std.mem.indexOf(u8, filtered_frame, "lint:warning") == null);
try client.handleInput(" ");
try client.handleInput("d");
try client.handleInput("n");
var snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 1), snap.cursor_byte);
try client.handleInput(" ");
try client.handleInput("d");
try client.handleInput("n");
snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 8), snap.cursor_byte);
}
test "regular: go rail jumps to first diagnostic" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open abcdef");
try client.handleTraceLine("diagnostic_fixture zls|1|main.zig|2|5|error|range");
try client.handleInput("g");
try client.handleInput("e");
const snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 2), snap.cursor_byte);
}
test "regular: select diagnostic object range with s d" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open abcdef");
try client.handleTraceLine("diagnostic_fixture zls|1|main.zig|2|5|error|range");
try client.handleInput("s");
try client.handleInput("d");
const snap = try client.session.snapshot();
try std.testing.expect(snap.selection != null);
try std.testing.expectEqual(@as(usize, 2), snap.selection.?.anchor);
try std.testing.expectEqual(@as(usize, 5), snap.selection.?.cursor);
}
test "adversarial: diagnostics stale empty duplicate and invalid ranges are safe" {
var empty_client = try Client.init(std.testing.allocator, .{ .width = 72, .height = 8 });
defer empty_client.deinit();
try empty_client.handleTraceLine("open abcdef");
try empty_client.handleInput(" ");
try empty_client.handleInput("d");
const empty_frame = try empty_client.render(std.testing.allocator);
defer std.testing.allocator.free(empty_frame);
try std.testing.expect(std.mem.indexOf(u8, empty_frame, "diag:empty") != null);
var client = try Client.init(std.testing.allocator, .{ .width = 72, .height = 8 });
defer client.deinit();
try client.handleTraceLine("open abcdef");
try client.handleTraceLine("diagnostic_fixture zls|1|main.zig|1|3|error|first");
try client.handleTraceLine("diagnostic_fixture lint|1|main.zig|1|3|warning|same_range_other_provider");
try client.handleTraceLine("diagnostic_fixture zls|1|main.zig|20|25|hint|invalid_range");
try client.handleInput("i");
try client.handleInput("X");
try client.handleTraceLine("key escape");
try client.handleInput(" ");
try client.handleInput("d");
const stale_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(stale_frame);
try std.testing.expect(std.mem.indexOf(u8, stale_frame, "diag:stale:zls:error:1-3") != null);
try std.testing.expect(std.mem.indexOf(u8, stale_frame, "diag:stale:lint:warning:1-3") != null);
try client.handleTraceLine("diagnostic_filter all");
try client.handleInput("n");
const invalid_nav_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(invalid_nav_frame);
try std.testing.expect(std.mem.indexOf(u8, invalid_nav_frame, "StaleDiagnostic") != null or std.mem.indexOf(u8, invalid_nav_frame, "InvalidDiagnosticRange") != null);
}
test "regular: diagnostic row model sanitizes and parses" {
const row = try diagnostics_mod.rowAlloc(std.testing.allocator, "zls", 3, "main.zig", 1, 4, .err, "bad: token");
defer std.testing.allocator.free(row);
try std.testing.expect(std.mem.indexOf(u8, row, "invalid") != null);
const parsed = try diagnostics_mod.parseRow(row);
try std.testing.expectEqual(@as(u64, 3), parsed.version);
try std.testing.expectEqual(diagnostics_mod.Severity.err, parsed.severity);
const panel = try diagnostics_mod.panelRowAlloc(std.testing.allocator, row, 4);
defer std.testing.allocator.free(panel);
try std.testing.expect(std.mem.indexOf(u8, panel, "diag:stale:zls:error:1-4") != null);
}
test "regular: job profiles produce source-patched command rows" {
const argv = try job_mod.argvForProfileAlloc(std.testing.allocator, .lint_file, "src/main.zig");
defer job_mod.freeArgv(std.testing.allocator, argv);
try std.testing.expectEqualStrings("zig", argv[0]);
try std.testing.expectEqualStrings("fmt", argv[1]);
try std.testing.expectEqualStrings("--check", argv[2]);
try std.testing.expectEqualStrings("src/main.zig", argv[3]);
const build_argv = try job_mod.argvForProfileAlloc(std.testing.allocator, .build, null);
defer job_mod.freeArgv(std.testing.allocator, build_argv);
try std.testing.expectEqualStrings("zig", build_argv[0]);
try std.testing.expectEqualStrings("build", build_argv[1]);
const test_argv = try job_mod.argvForProfileAlloc(std.testing.allocator, .tests, null);
defer job_mod.freeArgv(std.testing.allocator, test_argv);
try std.testing.expectEqualStrings("test", test_argv[2]);
const check_argv = try job_mod.argvForProfileAlloc(std.testing.allocator, .check, null);
defer job_mod.freeArgv(std.testing.allocator, check_argv);
try std.testing.expectEqualStrings("v1-smoke", check_argv[2]);
const missing = try job_mod.profileRowsAlloc(std.testing.allocator, std.testing.io, ".", .lint_file, null);
defer freeOwnedRows(std.testing.allocator, missing);
try std.testing.expectEqualStrings("job:profile:lint_file:scope:file:provider:zig-fmt", missing[0]);
try std.testing.expectEqualStrings("job:status:missing_current_file", missing[1]);
const cancel = try job_mod.cancelRowsAlloc(std.testing.allocator, .build);
defer freeOwnedRows(std.testing.allocator, cancel);
try std.testing.expectEqualStrings("job:status:cancelled:user", cancel[1]);
const timeout = try job_mod.timeoutRowsAlloc(std.testing.allocator, .tests);
defer freeOwnedRows(std.testing.allocator, timeout);
try std.testing.expectEqualStrings("job:status:timeout:recoverable", timeout[1]);
const missing_tool = try job_mod.missingToolRowsAlloc(std.testing.allocator, .check, "missing-zig");
defer freeOwnedRows(std.testing.allocator, missing_tool);
try std.testing.expectEqualStrings("job:status:missing_tool:missing-zig:no_install_attempted", missing_tool[1]);
}
test "regular: Space t rail runs distinct lint scopes and replaces job panel" {
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 88, .height = 7 }, std.testing.io);
defer client.deinit();
try client.handleInput(" ");
try client.handleInput("t");
try client.handleInput("l");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "job:profile:lint_file:scope:file:provider:zig-fmt") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "job:status:missing_current_file") != null);
}
try client.handleTraceLine("current_file src/main.zig");
try client.handleInput(" ");
try client.handleInput("t");
try client.handleInput("L");
const snap = try client.session.snapshot();
try std.testing.expectEqual(@as(usize, 1), snap.panel_depth);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "job:spawned:profile:lint_project:scope:project:provider:zig-fmt") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "lint_file") == null);
}
test "regular: Space t cancel yanks and timeout missing-tool rows are visible" {
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 88, .height = 6 }, std.testing.io);
defer client.deinit();
try client.handleInput(" ");
try client.handleInput("t");
try client.handleInput("x");
try client.handleInput(" ");
try client.handleInput("t");
try client.handleInput("y");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "yanked job line") != null);
}
try client.handleTraceLine("job_timeout test");
{
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "job:status:timeout:recoverable") != null);
}
try client.handleTraceLine("job_missing_tool build missing-zig");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "job:status:missing_tool:missing-zig:no_install_attempted") != null);
}
test "regular: Space t jump opens selected diagnostic row and does not mix output" {
var fixture = try makeTuiJobFixture(std.testing.allocator);
defer {
std.testing.allocator.free(fixture.cwd);
fixture.tmp.cleanup();
}
var client = try Client.initWithIo(std.testing.allocator, .{ .width = 88, .height = 7 }, std.testing.io);
defer client.deinit();
const run = try std.fmt.allocPrint(std.testing.allocator, "job_run {s} sh fail.sh", .{fixture.cwd});
defer std.testing.allocator.free(run);
try client.handleTraceLine(run);
try client.handleTraceLine("list_filter src/main.zig");
try client.handleInput(" ");
try client.handleInput("t");
try client.handleInput("j");
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("one\nabcdTARGET\n", snap.bytes);
try std.testing.expectEqual(@as(usize, 8), snap.cursor_byte);
}
test "regular: language format applies provider edit and undo restores" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open dirty");
try client.handleTraceLine("language_edit zls|format|1|0|5|clean");
try client.handleInput(" ");
try client.handleInput("l");
try client.handleInput("f");
var snap = try client.session.snapshot();
try std.testing.expectEqualStrings("clean", snap.bytes);
try client.handleInput("u");
snap = try client.session.snapshot();
try std.testing.expectEqualStrings("dirty", snap.bytes);
}
test "regular: format on save and one-shot save without format" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("language_default_format zls");
try client.handleTraceLine("language_edit zls|format|1|0|3|ABC");
try client.handleTraceLine("save");
try std.testing.expectEqualStrings("ABC", try client.saved());
var ambiguous = try Client.init(std.testing.allocator, .{ .width = 80, .height = 6 });
defer ambiguous.deinit();
try ambiguous.handleTraceLine("open abc");
try ambiguous.handleTraceLine("language_edit zls|format|1|0|3|ZLS");
try ambiguous.handleTraceLine("language_edit prettier|format|1|0|3|PRETTY");
try ambiguous.handleTraceLine("save");
try std.testing.expectError(Error.NothingSaved, ambiguous.saved());
const ambiguous_frame = try ambiguous.render(std.testing.allocator);
defer std.testing.allocator.free(ambiguous_frame);
try std.testing.expect(std.mem.indexOf(u8, ambiguous_frame, "action:format:provider:zls") != null);
var skip = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer skip.deinit();
try skip.handleTraceLine("open abc");
try skip.handleTraceLine("language_default_format zls");
try skip.handleTraceLine("language_edit zls|format|1|0|3|ABC");
try skip.handleTraceLine("save_without_format");
try std.testing.expectEqualStrings("abc", try skip.saved());
}
test "regular: provider picker applies selected formatter" {
var client = try Client.init(std.testing.allocator, .{ .width = 80, .height = 7 });
defer client.deinit();
try client.handleTraceLine("open abc");
try client.handleTraceLine("language_edit zls|format|1|0|3|ZLS");
try client.handleTraceLine("language_edit prettier|format|1|0|3|PRETTY");
try client.handleInput(" ");
try client.handleInput("l");
try client.handleInput("f");
const picker_frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(picker_frame);
try std.testing.expect(std.mem.indexOf(u8, picker_frame, "action:format:provider:zls") != null);
try std.testing.expect(std.mem.indexOf(u8, picker_frame, "action:format:provider:prettier") != null);
try client.handleTraceLine("list_filter prettier");
try client.handleTraceLine("key enter");
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("PRETTY", snap.bytes);
}
test "regular: organize imports and code action show source before mutation" {
var client = try Client.init(std.testing.allocator, .{ .width = 88, .height = 7 });
defer client.deinit();
try client.handleTraceLine("open imports\nbody");
try client.handleTraceLine("language_edit zls|organize_imports|1|0|7|sorted");
try client.handleInput(" ");
try client.handleInput("l");
try client.handleInput("o");
var snap = try client.session.snapshot();
try std.testing.expectEqualStrings("sorted\nbody", snap.bytes);
var action = try Client.init(std.testing.allocator, .{ .width = 88, .height = 7 });
defer action.deinit();
try action.handleTraceLine("open abcdef");
try action.handleTraceLine("language_edit zls|code_action|1|1|4|XYZ");
try action.handleInput(" ");
try action.handleInput("l");
try action.handleInput("a");
const frame = try action.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "action:code_action:provider:zls:scope:1-4") != null);
try action.handleTraceLine("key enter");
snap = try action.session.snapshot();
try std.testing.expectEqualStrings("aXYZef", snap.bytes);
}
test "adversarial: language mutations report missing stale and overlapping providers" {
var missing = try Client.init(std.testing.allocator, .{ .width = 80, .height = 6 });
defer missing.deinit();
try missing.handleTraceLine("open abc");
try missing.handleInput(" ");
try missing.handleInput("l");
try missing.handleInput("f");
const missing_frame = try missing.render(std.testing.allocator);
defer std.testing.allocator.free(missing_frame);
try std.testing.expect(std.mem.indexOf(u8, missing_frame, "NoProvider:format") != null);
var stale = try Client.init(std.testing.allocator, .{ .width = 80, .height = 6 });
defer stale.deinit();
try stale.handleTraceLine("open abc");
try stale.handleTraceLine("language_edit zls|format|0|0|3|ABC");
try stale.handleInput(" ");
try stale.handleInput("l");
try stale.handleInput("f");
const stale_frame = try stale.render(std.testing.allocator);
defer std.testing.allocator.free(stale_frame);
try std.testing.expect(std.mem.indexOf(u8, stale_frame, "StaleEdit") != null);
var overlap = try Client.init(std.testing.allocator, .{ .width = 80, .height = 6 });
defer overlap.deinit();
try overlap.handleTraceLine("open abcdef");
try overlap.handleTraceLine("language_edit zls|format|1|0|3|AAA");
try overlap.handleTraceLine("language_edit zls|format|1|2|5|BBB");
try overlap.handleInput(" ");
try overlap.handleInput("l");
try overlap.handleInput("f");
const overlap_frame = try overlap.render(std.testing.allocator);
defer std.testing.allocator.free(overlap_frame);
try std.testing.expect(std.mem.indexOf(u8, overlap_frame, "OverlappingEdit") != null);
}
test "regular: provider edit rows parse source scope and replacement" {
const row = try lsp_mod.editRowAlloc(std.testing.allocator, "zls", .code_action, 7, 2, 5, "XYZ");
defer std.testing.allocator.free(row);
const edit = try lsp_mod.parseProviderEditRow(row);
try std.testing.expectEqualStrings("zls", edit.provider);
try std.testing.expectEqual(lsp_mod.ProviderCapability.code_action, edit.capability);
try std.testing.expectEqual(@as(u64, 7), edit.version);
try std.testing.expectEqualStrings("XYZ", edit.replacement);
const action_row = try lsp_mod.actionPanelRowAlloc(std.testing.allocator, row);
defer std.testing.allocator.free(action_row);
try std.testing.expectEqualStrings("zls", try lsp_mod.providerFromActionPanelRow(action_row));
}
test "regular: physical arrows home end page and escape match editor movement" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 5 });
defer client.deinit();
try client.handleTraceLine("open one\ntwo\nthree\nfour\nfive");
var snap = try client.session.snapshot();
const start = snap.cursor_byte;
try client.handleTraceLine("key page_down");
snap = try client.session.snapshot();
try std.testing.expect(snap.cursor_byte > start);
try client.handleTraceLine("key home");
snap = try client.session.snapshot();
const line_start = snap.cursor_byte;
try client.handleTraceLine("key end");
snap = try client.session.snapshot();
try std.testing.expect(snap.cursor_byte >= line_start);
try client.handleTraceLine("key page_up");
snap = try client.session.snapshot();
try std.testing.expect(snap.cursor_byte <= line_start);
try client.handleInput("i");
try client.handleInput("x");
try client.handleTraceLine("key escape");
try client.handleInput("u");
snap = try client.session.snapshot();
try std.testing.expect(std.mem.indexOf(u8, snap.bytes, "onxe") == null);
}
test "regular: physical digit count matches repeated arrow movement" {
var physical = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer physical.deinit();
try physical.handleTraceLine("open a\nb\nc\nd");
try physical.handleInput("3");
try physical.handleTraceLine("key down");
const physical_snap = try physical.session.snapshot();
var repeated = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer repeated.deinit();
try repeated.handleTraceLine("open a\nb\nc\nd");
try repeated.handleTraceLine("key down");
try repeated.handleTraceLine("key down");
try repeated.handleTraceLine("key down");
const repeated_snap = try repeated.session.snapshot();
try std.testing.expectEqual(repeated_snap.cursor_byte, physical_snap.cursor_byte);
}
test "regular: physical percent and mobile match rail jump to same pair" {
var physical = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer physical.deinit();
try physical.handleTraceLine("open (abc)");
try physical.handleInput("%");
var snap = try physical.session.snapshot();
try std.testing.expectEqual(@as(usize, 4), snap.cursor_byte);
var mobile = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer mobile.deinit();
try mobile.handleTraceLine("open (abc)");
try mobile.handleInput("m");
try mobile.handleInput("m");
snap = try mobile.session.snapshot();
try std.testing.expectEqual(@as(usize, 4), snap.cursor_byte);
}
test "regular: insert/select modes accept arrows while Space n remains mobile escape" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open ab\ncd");
try client.handleInput("i");
try client.handleTraceLine("key end");
try client.handleInput("X");
try client.handleInput(" ");
try client.handleInput("n");
var snap = try client.session.snapshot();
try std.testing.expectEqualStrings("abX\ncd", snap.bytes);
try client.handleInput("s");
try client.handleTraceLine("key up");
try client.handleTraceLine("key home");
try client.handleInput("n");
snap = try client.session.snapshot();
try std.testing.expect(snap.selection != null or snap.cursor_byte == 0);
}
test "regular: panels accept physical page keys and enter without breaking arrows" {
var client = try Client.init(std.testing.allocator, .{ .width = 64, .height = 4 });
defer client.deinit();
try client.handleTraceLine("list_open files a.zig|b.zig|c.zig|d.zig|e.zig");
try client.handleTraceLine("key page_down");
const after_down = try client.session.activeListItem();
try std.testing.expect(!std.mem.eql(u8, after_down, "a.zig"));
try client.handleTraceLine("key up");
const after_up = try client.session.activeListItem();
try std.testing.expect(!std.mem.eql(u8, after_down, after_up));
}
test "adversarial: unknown physical key names stay rejected and leader help stays narrow" {
var client = try Client.init(std.testing.allocator, .{ .width = 72, .height = 5 });
defer client.deinit();
try std.testing.expectError(Error.UnknownTraceEvent, client.handleTraceLine("key f1"));
try client.handleInput(" ");
try std.testing.expect(std.mem.indexOf(u8, client.leader.status(), "digits/%/Esc ok") != null);
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try assertLinesFit(frame, 72);
}
test "regular: editor render has colorscheme gutter cursor and status chrome" {
var client = try Client.init(std.testing.allocator, .{ .width = 40, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open alpha\nbeta");
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, "\x1b[38;2;") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, " 1│") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, " 2│") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "▌") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "\x1b[38;2;18;22;30;48;2;126;231;135m") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "^\n") == null);
try assertLinesFit(frame, 40);
}
test "regular: empty editor still shows first line gutter and cursor marker" {
var client = try Client.init(std.testing.allocator, .{ .width = 24, .height = 5 });
defer client.deinit();
const frame = try client.render(std.testing.allocator);
defer std.testing.allocator.free(frame);
try std.testing.expect(std.mem.indexOf(u8, frame, " 1│") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, "▌") != null);
try std.testing.expect(std.mem.indexOf(u8, frame, " ·") != null);
try assertLinesFit(frame, 24);
}
test "regular: local launcher insert mode lets ordinary text with spaces insert" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open ");
client.enterInsertMode();
for ("what is up") |byte| {
const key_bytes = [_]u8{byte};
try client.handleInput(&key_bytes);
}
const snap = try client.session.snapshot();
try std.testing.expectEqualStrings("what is up", snap.bytes);
}
test "regular: normal mode Space leader still works after insert escape" {
var client = try Client.init(std.testing.allocator, .{ .width = 48, .height = 6 });
defer client.deinit();
try client.handleTraceLine("open ");
client.enterInsertMode();
for ("abc") |byte| {
const key_bytes = [_]u8{byte};
try client.handleInput(&key_bytes);
}
try client.handleTraceLine("key escape");
try client.handleInput(" ");
try client.handleInput("w");
try std.testing.expectEqualStrings("abc", try client.saved());
}
Reference in New Issue View Git Blame Copy Permalink