AnyEvent-MCP

 view release on metacpan or  search on metacpan

t/c16_vim_auth.t  view on Meta::CPAN


my $wire = "";
my $vim_call;
for (1 .. 100) {
   IO::Select->new ($valid)->can_read (0.3)
      or next;
   my $n = sysread $valid, my $fragment, 8192;
   last unless $n;
   $wire .= $fragment;
   $vim_call = eval { JSON::XS::decode_json $wire };
   last if $vim_call;
}
ok $vim_call && $vim_call->[1][0] eq "call"
   && $vim_call->[1][2] eq "read_lines",
   "read-lines delegates disjoint ranges to the private Vim RPC";
if ($vim_call) {
   $valid->autoflush (1);
   print {$valid} JSON::XS::encode_json ([0, [
      reply => $vim_call->[1][1], 1, {
         changedtick => 7,
         ranges => [
            { range => "727,728", start => 727, end => 728, lines => ["function alpha () {", "   return a;"] },
            { range => "985,986", start => 985, end => 986, lines => ["function beta () {", "   return b;"] },
         ],
      },
   ]]) or die "send mock Vim RPC reply: $!";
}
IO::Select->new ($out)->can_read (30) or die "read-lines MCP reply timeout";
my $lines_reply = JSON::XS::decode_json (scalar <$out>);
my $blocks = $lines_reply->{result}{content} || [];
is @{$blocks}, 5, "Vim returns initial metadata plus two text entries per requested range";
is_deeply [map $_->{type}, @$blocks], [("text") x 5],
   "all Vim metadata and source blocks remain MCP text entries";
is_deeply JSON::XS::decode_json ($blocks->[0]{text}), {
   changedtick => 7,
   ranges => [
      { range => "727,728", start => 727, end => 728 },
      { range => "985,986", start => 985, end => 986 },
   ],
}, "Vim changedtick and resolved range metadata remain available";
is_deeply [map $_->{text}, @{$blocks}[1..4]], [
   "[range=727,728]",
   "function alpha () {\n   return a;\n",
   "[range=985,986]",
   "function beta () {\n   return b;\n",
], "each Vim range has visible standalone metadata and unchanged newline-terminated source";


sub send_tool {
   my ($id, $name, $args) = @_;
   print {$in} JSON::XS::encode_json ({
      jsonrpc => "2.0", id => $id, method => "tools/call",
      params => { name => $name, arguments => $args },
   }), "\n" or die "send tool request: $!";
}

my %vim_parser;

sub vim_call {
   my $socket = $_[0] || $valid;
   my $parser = $vim_parser{fileno $socket} ||= JSON::XS->new->utf8;
   for (1 .. 120) {
      my $packet = $parser->incr_parse;
      return $packet if $packet;
      next unless IO::Select->new ($socket)->can_read (0.25);
      my $n = sysread $socket, my $fragment, 8192;
      last unless $n;
      $parser->incr_parse ($fragment); # void context: leave complete packets for the next iteration
   }
   die "private Vim message timeout\n";
}

sub vim_reply {
   my ($call, $success, $result, $socket) = @_;
   $socket ||= $valid;
   print {$socket} JSON::XS::encode_json ([0, [
      reply => $call->[1][1], $success, $result,
   ]]) or die "send Vim RPC reply: $!";
}

sub mcp_reply {
   IO::Select->new ($out)->can_read (30) or die "MCP reply timeout\n";
   JSON::XS::decode_json (scalar <$out>)
}

send_tool 184, "read-lines", {
   target => "secondary-vim", buffer => 1, ranges => ["40,41", "8"], linenums => JSON::XS::true,
};
my $numbered_call = vim_call;
vim_reply $numbered_call, 1, {
   changedtick => 7,
   ranges => [
      { range => "40,41", start => 40, end => 41, lines => ["", "second"] },
      { range => "8", start => 8, end => 8, lines => ["first"] },
   ],
};
my $numbered_reply = mcp_reply;
is_deeply [map $_->{text}, @{$numbered_reply->{result}{content}}[1..4]], [
   "[range=40,41]", "40:\n41:second\n", "[range=8,8]", "8:first\n",
], "Vim linenums prefixes absolute numbers for disjoint ranges and empty lines";

my $other = vim_connect ("secondary", "parallel-vim");
$other->autoflush (1);
my $other_visible;
for (1 .. 1000) {
   $other_visible = grep $_ eq "parallel-vim", @{target_names ()};
   last if $other_visible;
   Time::HiRes::sleep (0.03);
}
ok $other_visible, "second mock editor connected for parallel state collection";

sub permission_params {
   my ($name, $args, $state, $answer) = @_;
   +{
      name => $name, arguments => $args,
      _meta => {
         "io.modelcontextprotocol/protocolVersion" => "2026-07-28",
         "io.modelcontextprotocol/clientCapabilities" => { elicitation => { form => {} } },
      },
      (defined $state ? (
         requestState => $state, inputResponses => { permission => $answer },



( run in 1.527 second using v1.01-cache-2.11-cpan-234fa220139 )