{"owner":"ThePrimeagen","repo":"99","hasSkills":true,"totalSkillsCount":6,"totalTokensCount":10027,"categories":["anthropic-skill","root-instruction"],"hasMcp":false,"mcpConfig":null,"found":[".agents/skills/vim.treesitter/SKILL.md",".agents/skills/vim/SKILL.md",".agents/skills/vim.diagnostics/SKILL.md","scratch/custom_rules/vim/SKILL.md",".agents/skills/vim.lsp/SKILL.md","AGENTS.md"],"skills":{".agents/skills/vim.treesitter/SKILL.md":"# Neovim Treesitter API Reference\n\nThis document contains type stubs and API references for Neovim's treesitter Lua API.\nUse this as a reference when working with treesitter in Neovim Lua.\n\n---\n\n## tsnode\n\nTSNode methods - represents a specific element in a parsed syntax tree. Use these methods to navigate and inspect nodes.\n\n```lua\nfunction TSNode:parent() end\nfunction TSNode:next_sibling() end\nfunction TSNode:prev_sibling() end\nfunction TSNode:next_named_sibling() end\nfunction TSNode:prev_named_sibling() end\nfunction TSNode:iter_children() end\nfunction TSNode:field(name) end\nfunction TSNode:child_count() end\nfunction TSNode:child(index) end\nfunction TSNode:named_child_count() end\nfunction TSNode:named_children() end\nfunction TSNode:__has_ancestor(node_types) end\nfunction TSNode:named_child(index) end\nfunction TSNode:child_with_descendant(descendant) end\nfunction TSNode:start() end\nfunction TSNode:end_() end\nfunction TSNode:range(include_bytes) end\nfunction TSNode:type() end\nfunction TSNode:symbol() end\nfunction TSNode:named() end\nfunction TSNode:missing() end\nfunction TSNode:extra() end\nfunction TSNode:has_changes() end\nfunction TSNode:has_error() end\nfunction TSNode:sexpr() end\nfunction TSNode:id() end\nfunction TSNode:tree() end\nfunction TSNode:descendant_for_range(start_row, start_col, end_row, end_col) end\nfunction TSNode:named_descendant_for_range(start_row, start_col, end_row, end_col) end\nfunction TSNode:equal(node) end\nfunction TSNode:byte_length() end\n```\n\n---\n\n## tstree\n\nTSTree methods - represents the parsed contents of a buffer.\n\n```lua\nfunction TSTree:root() end\nfunction TSTree:edit(start_byte, end_byte_old, end_byte_new, start_row, start_col, end_row_old, end_col_old, end_row_new, end_col_new) end\nfunction TSTree:copy() end\nfunction TSTree:included_ranges(include_bytes) end\nfunction TSTree:included_ranges(include_bytes) end\n```\n\n---\n\n## tsquery\n\nTSQuery methods - for working with treesitter queries.\n\n```lua\nfunction TSQuery:inspect() end\nfunction TSQuery:disable_capture(capture_name) end\nfunction TSQuery:disable_pattern(pattern_index) end\n```\n\n---\n\n## misc\n\nVarious treesitter types including TSParser, TSQueryMatch, TSQueryCursor, and TSLangInfo.\n\n```lua\nvim._ts_inspect_language = function(lang) end\nvim._ts_get_language_version = function() end\nvim._ts_add_language_from_object = function(path, lang, symbol_name) end\nvim._ts_add_language_from_wasm = function(path, lang) end\nvim._ts_get_minimum_language_version = function() end\nvim._ts_parse_query = function(lang, query) end\nvim._create_ts_parser = function(lang) end\nfunction TSQueryMatch:info() end\nfunction TSQueryCursor:next_capture() end\nfunction TSQueryCursor:next_match() end\nfunction vim._create_ts_querycursor(node, query, start, stop, opts) end\n```\n",".agents/skills/vim/SKILL.md":"# Neovim Lua API Reference\n\nThis document contains type stubs and API references for Neovim's Lua API.\nUse this as a reference when writing Neovim plugins or configurations in Lua.\n\n---\n\n## api\n\nThe following are type stubs for all the functions available on `vim.api.*`. Prefer these functions where possible.\n\n```lua\nvim.api = {}\nvim.api.nvim__buf_debug_extmarks(buffer, keys, dot) \nvim.api.nvim__buf_stats(buffer) \nvim.api.nvim__complete_set(index, opts) \nvim.api.nvim__get_lib_dir() \nvim.api.nvim__get_runtime(pat, all, opts) \nvim.api.nvim__id(obj) \nvim.api.nvim__id_array(arr) \nvim.api.nvim__id_dict(dct) \nvim.api.nvim__id_float(flt) \nvim.api.nvim__inspect_cell(grid, row, col) \nvim.api.nvim__invalidate_glyph_cache() \nvim.api.nvim__ns_get(ns_id) \nvim.api.nvim__ns_set(ns_id, opts) \nvim.api.nvim__redraw(opts) \nvim.api.nvim__runtime_inspect() \nvim.api.nvim__screenshot(path) \nvim.api.nvim__stats() \nvim.api.nvim__unpack(str) \nvim.api.nvim_buf_add_highlight(buffer, ns_id, hl_group, line, col_start, col_end) \nvim.api.nvim_buf_attach(buffer, send_buffer, opts) \nvim.api.nvim_buf_call(buffer, fun) \nvim.api.nvim_buf_clear_highlight(buffer, ns_id, line_start, line_end) \nvim.api.nvim_buf_clear_namespace(buffer, ns_id, line_start, line_end) \nvim.api.nvim_buf_create_user_command(buffer, name, command, opts) \nvim.api.nvim_buf_del_extmark(buffer, ns_id, id) \nvim.api.nvim_buf_del_keymap(buffer, mode, lhs) \nvim.api.nvim_buf_del_mark(buffer, name) \nvim.api.nvim_buf_del_user_command(buffer, name) \nvim.api.nvim_buf_del_var(buffer, name) \nvim.api.nvim_buf_delete(buffer, opts) \nvim.api.nvim_buf_get_changedtick(buffer) \nvim.api.nvim_buf_get_commands(buffer, opts) \nvim.api.nvim_buf_get_extmark_by_id(buffer, ns_id, id, opts) \nvim.api.nvim_buf_get_extmarks(buffer, ns_id, start, end_, opts) \nvim.api.nvim_buf_get_keymap(buffer, mode) \nvim.api.nvim_buf_get_lines(buffer, start, end_, strict_indexing) \nvim.api.nvim_buf_get_mark(buffer, name) \nvim.api.nvim_buf_get_name(buffer) \nvim.api.nvim_buf_get_number(buffer) \nvim.api.nvim_buf_get_offset(buffer, index) \nvim.api.nvim_buf_get_option(buffer, name) \nvim.api.nvim_buf_get_text(buffer, start_row, start_col, end_row, end_col, opts) \nvim.api.nvim_buf_get_var(buffer, name) \nvim.api.nvim_buf_is_loaded(buffer) \nvim.api.nvim_buf_is_valid(buffer) \nvim.api.nvim_buf_line_count(buffer) \nvim.api.nvim_buf_set_extmark(buffer, ns_id, line, col, opts) \nvim.api.nvim_buf_set_keymap(buffer, mode, lhs, rhs, opts) \nvim.api.nvim_buf_set_lines(buffer, start, end_, strict_indexing, replacement) \nvim.api.nvim_buf_set_mark(buffer, name, line, col, opts) \nvim.api.nvim_buf_set_name(buffer, name) \nvim.api.nvim_buf_set_option(buffer, name, value) \nvim.api.nvim_buf_set_text(buffer, start_row, start_col, end_row, end_col, replacement) \nvim.api.nvim_buf_set_var(buffer, name, value) \nvim.api.nvim_buf_set_virtual_text(buffer, src_id, line, chunks, opts) \nvim.api.nvim_call_dict_function(dict, fn, args) \nvim.api.nvim_call_function(fn, args) \nvim.api.nvim_chan_send(chan, data) \nvim.api.nvim_clear_autocmds(opts) \nvim.api.nvim_cmd(cmd, opts) \nvim.api.nvim_command(command) \nvim.api.nvim_command_output(command) \nvim.api.nvim_create_augroup(name, opts) \nvim.api.nvim_create_autocmd(event, opts) \nvim.api.nvim_create_buf(listed, scratch) \nvim.api.nvim_create_namespace(name) \nvim.api.nvim_create_user_command(name, command, opts) \nvim.api.nvim_del_augroup_by_id(id) \nvim.api.nvim_del_augroup_by_name(name) \nvim.api.nvim_del_autocmd(id) \nvim.api.nvim_del_current_line() \nvim.api.nvim_del_keymap(mode, lhs) \nvim.api.nvim_del_mark(name) \nvim.api.nvim_del_user_command(name) \nvim.api.nvim_del_var(name) \nvim.api.nvim_echo(chunks, history, opts) \nvim.api.nvim_err_write(str) \nvim.api.nvim_err_writeln(str) \nvim.api.nvim_eval(expr) \nvim.api.nvim_eval_statusline(str, opts) \nvim.api.nvim_exec(src, output) \nvim.api.nvim_exec2(src, opts) \nvim.api.nvim_exec_autocmds(event, opts) \nvim.api.nvim_feedkeys(keys, mode, escape_ks) \nvim.api.nvim_get_all_options_info() \nvim.api.nvim_get_autocmds(opts) \nvim.api.nvim_get_chan_info(chan) \nvim.api.nvim_get_color_by_name(name) \nvim.api.nvim_get_color_map() \nvim.api.nvim_get_commands(opts) \nvim.api.nvim_get_context(opts) \nvim.api.nvim_get_current_buf() \nvim.api.nvim_get_current_line() \nvim.api.nvim_get_current_tabpage() \nvim.api.nvim_get_current_win() \nvim.api.nvim_get_hl(ns_id, opts) \nvim.api.nvim_get_hl_by_id(hl_id, rgb) \nvim.api.nvim_get_hl_by_name(name, rgb) \nvim.api.nvim_get_hl_id_by_name(name) \nvim.api.nvim_get_hl_ns(opts) \nvim.api.nvim_get_keymap(mode) \nvim.api.nvim_get_mark(name, opts) \nvim.api.nvim_get_mode() \nvim.api.nvim_get_namespaces() \nvim.api.nvim_get_option(name) \nvim.api.nvim_get_option_info(name) \nvim.api.nvim_get_option_info2(name, opts) \nvim.api.nvim_get_option_value(name, opts) \nvim.api.nvim_get_proc(pid) \nvim.api.nvim_get_proc_children(pid) \nvim.api.nvim_get_runtime_file(name, all) \nvim.api.nvim_get_var(name) \nvim.api.nvim_get_vvar(name) \nvim.api.nvim_input(keys) \nvim.api.nvim_input_mouse(button, action, modifier, grid, row, col) \nvim.api.nvim_list_bufs() \nvim.api.nvim_list_chans() \nvim.api.nvim_list_runtime_paths() \nvim.api.nvim_list_tabpages() \nvim.api.nvim_list_uis() \nvim.api.nvim_list_wins() \nvim.api.nvim_load_context(dict) \nvim.api.nvim_notify(msg, log_level, opts) \nvim.api.nvim_open_term(buffer, opts) \nvim.api.nvim_open_win(buffer, enter, config) \nvim.api.nvim_out_write(str) \nvim.api.nvim_parse_cmd(str, opts) \nvim.api.nvim_parse_expression(expr, flags, highlight) \nvim.api.nvim_paste(data, crlf, phase) \nvim.api.nvim_put(lines, type, after, follow) \nvim.api.nvim_replace_termcodes(str, from_part, do_lt, special) \nvim.api.nvim_select_popupmenu_item(item, insert, finish, opts) \nvim.api.nvim_set_current_buf(buffer) \nvim.api.nvim_set_current_dir(dir) \nvim.api.nvim_set_current_line(line) \nvim.api.nvim_set_current_tabpage(tabpage) \nvim.api.nvim_set_current_win(window) \nvim.api.nvim_set_decoration_provider(ns_id, opts) \nvim.api.nvim_set_hl(ns_id, name, val) \nvim.api.nvim_set_hl_ns(ns_id) \nvim.api.nvim_set_hl_ns_fast(ns_id) \nvim.api.nvim_set_keymap(mode, lhs, rhs, opts) \nvim.api.nvim_set_option(name, value) \nvim.api.nvim_set_option_value(name, value, opts) \nvim.api.nvim_set_var(name, value) \nvim.api.nvim_set_vvar(name, value) \nvim.api.nvim_strwidth(text) \nvim.api.nvim_tabpage_del_var(tabpage, name) \nvim.api.nvim_tabpage_get_number(tabpage) \nvim.api.nvim_tabpage_get_var(tabpage, name) \nvim.api.nvim_tabpage_get_win(tabpage) \nvim.api.nvim_tabpage_is_valid(tabpage) \nvim.api.nvim_tabpage_list_wins(tabpage) \nvim.api.nvim_tabpage_set_var(tabpage, name, value) \nvim.api.nvim_tabpage_set_win(tabpage, win) \nvim.api.nvim_win_call(window, fun) \nvim.api.nvim_win_close(window, force) \nvim.api.nvim_win_del_var(window, name) \nvim.api.nvim_win_get_buf(window) \nvim.api.nvim_win_get_config(window) \nvim.api.nvim_win_get_cursor(window) \nvim.api.nvim_win_get_height(window) \nvim.api.nvim_win_get_number(window) \nvim.api.nvim_win_get_option(window, name) \nvim.api.nvim_win_get_position(window) \nvim.api.nvim_win_get_tabpage(window) \nvim.api.nvim_win_get_var(window, name) \nvim.api.nvim_win_get_width(window) \nvim.api.nvim_win_hide(window) \nvim.api.nvim_win_is_valid(window) \nvim.api.nvim_win_set_buf(window, buffer) \nvim.api.nvim_win_set_config(window, config) \nvim.api.nvim_win_set_cursor(window, pos) \nvim.api.nvim_win_set_height(window, height) \nvim.api.nvim_win_set_hl_ns(window, ns_id) \nvim.api.nvim_win_set_option(window, name, value) \nvim.api.nvim_win_set_var(window, name, value) \nvim.api.nvim_win_set_width(window, width) \nvim.api.nvim_win_text_height(window, opts) \n```\n\n---\n\n## builtin\n\nVarious APIs that are provided by Neovim, that are unique to the Lua API.\n\n```lua\nvim.NIL = ...\nfunction vim.in_fast_event() end\nfunction vim.empty_dict() end\nfunction vim.rpcnotify(channel, method, ...) end\nfunction vim.rpcrequest(channel, method, ...) end\nfunction vim.stricmp(a, b) end\nfunction vim.str_utf_pos(str) end\nfunction vim.str_utf_start(str, index) end\nfunction vim.str_utf_end(str, index) end\nfunction vim.iconv(str, from, to, opts) end\nfunction vim.schedule(fn) end\nfunction vim.wait(time, callback, interval, fast_only) end\nfunction vim.ui_attach(ns, options, callback) end\nfunction vim.ui_detach(ns) end\n```\n\n---\n\n## api_keysets\n\nThe following describe various types that are used in Neovim's API.\n\n```lua\n\n```\n\n---\n\n## api_keysets_extra\n\nAdditional types that are used in Neovim's API.\n\n```lua\n\n```\n\n---\n\n## builtin_types\n\nVarious types used by Neovim's builtin APIs.\n\n```lua\n\n```\n\n---\n\n## vimfn\n\nFunctions available from Neovim's vimscript APIs. They are available via `vim.fn.*`.\n\n```lua\nvim.fn.abs(expr) \nvim.fn.acos(expr) \nvim.fn.add(object, expr) \nvim.fn['and'] = function(expr, expr1) \nvim.fn.api_info() \nvim.fn.append(lnum, text) \nvim.fn.appendbufline(buf, lnum, text) \nvim.fn.argc(winid) \nvim.fn.argidx() \nvim.fn.arglistid(winnr, tabnr) \nvim.fn.argv(nr, winid) \nvim.fn.asin(expr) \nvim.fn.assert_beeps(cmd) \nvim.fn.assert_equal(expected, actual, msg) \nvim.fn.assert_equalfile(fname_one, fname_two) \nvim.fn.assert_exception(error, msg) \nvim.fn.assert_fails(cmd, error, msg, lnum, context) \nvim.fn.assert_false(actual, msg) \nvim.fn.assert_inrange(lower, upper, actual, msg) \nvim.fn.assert_match(pattern, actual, msg) \nvim.fn.assert_nobeep(cmd) \nvim.fn.assert_notequal(expected, actual, msg) \nvim.fn.assert_notmatch(pattern, actual, msg) \nvim.fn.assert_report(msg) \nvim.fn.assert_true(actual, msg) \nvim.fn.atan(expr) \nvim.fn.atan2(expr1, expr2) \nvim.fn.blob2list(blob) \nvim.fn.browse(save, title, initdir, default) \nvim.fn.browsedir(title, initdir) \nvim.fn.bufadd(name) \nvim.fn.bufexists(buf) \nvim.fn.buffer_exists(...) \nvim.fn.buffer_name(...) \nvim.fn.buffer_number(...) \nvim.fn.buflisted(buf) \nvim.fn.bufload(buf) \nvim.fn.bufloaded(buf) \nvim.fn.bufname(buf) \nvim.fn.bufnr(buf, create) \nvim.fn.bufwinid(buf) \nvim.fn.bufwinnr(buf) \nvim.fn.byte2line(byte) \nvim.fn.byteidx(expr, nr, utf16) \nvim.fn.byteidxcomp(expr, nr, utf16) \nvim.fn.call(func, arglist, dict) \nvim.fn.ceil(expr) \nvim.fn.chanclose(id, stream) \nvim.fn.changenr() \nvim.fn.chansend(id, data) \nvim.fn.char2nr(string, utf8) \nvim.fn.charclass(string) \nvim.fn.charcol(expr, winid) \nvim.fn.charidx(string, idx, countcc, utf16) \nvim.fn.chdir(dir) \nvim.fn.cindent(lnum) \nvim.fn.clearmatches(win) \nvim.fn.col(expr, winid) \nvim.fn.complete(startcol, matches) \nvim.fn.complete_add(expr) \nvim.fn.complete_check() \nvim.fn.complete_info(what) \nvim.fn.confirm(msg, choices, default, type) \nvim.fn.copy(expr) \nvim.fn.cos(expr) \nvim.fn.cosh(expr) \nvim.fn.count(comp, expr, ic, start) \nvim.fn.ctxget(index) \nvim.fn.ctxpop() \nvim.fn.ctxpush(types) \nvim.fn.ctxset(context, index) \nvim.fn.ctxsize() \nvim.fn.cursor(lnum, col, off) \nvim.fn.cursor(list) \nvim.fn.debugbreak(pid) \nvim.fn.deepcopy(expr, noref) \nvim.fn.delete(fname, flags) \nvim.fn.deletebufline(buf, first, last) \nvim.fn.dictwatcheradd(dict, pattern, callback) \nvim.fn.dictwatcherdel(dict, pattern, callback) \nvim.fn.did_filetype() \nvim.fn.diff_filler(lnum) \nvim.fn.diff_hlID(lnum, col) \nvim.fn.digraph_get(chars) \nvim.fn.digraph_getlist(listall) \nvim.fn.digraph_set(chars, digraph) \nvim.fn.digraph_setlist(digraphlist) \nvim.fn.empty(expr) \nvim.fn.environ() \nvim.fn.escape(string, chars) \nvim.fn.eval(string) \nvim.fn.eventhandler() \nvim.fn.executable(expr) \nvim.fn.execute(command, silent) \nvim.fn.exepath(expr) \nvim.fn.exists(expr) \nvim.fn.exp(expr) \nvim.fn.expand(string, nosuf, list) \nvim.fn.expand(string, nosuf, list) \nvim.fn.expandcmd(string, options) \nvim.fn.extend(expr1, expr2, expr3) \nvim.fn.extendnew(expr1, expr2, expr3) \nvim.fn.feedkeys(string, mode) \nvim.fn.file_readable(file) \nvim.fn.filecopy(from, to) \nvim.fn.filereadable(file) \nvim.fn.filewritable(file) \nvim.fn.filter(expr1, expr2) \nvim.fn.finddir(name, path, count) \nvim.fn.findfile(name, path, count) \nvim.fn.flatten(list, maxdepth) \nvim.fn.flattennew(list, maxdepth) \nvim.fn.float2nr(expr) \nvim.fn.floor(expr) \nvim.fn.fmod(expr1, expr2) \nvim.fn.fnameescape(string) \nvim.fn.fnamemodify(fname, mods) \nvim.fn.foldclosed(lnum) \nvim.fn.foldclosedend(lnum) \nvim.fn.foldlevel(lnum) \nvim.fn.foldtext() \nvim.fn.foldtextresult(lnum) \nvim.fn.foreach(expr1, expr2) \nvim.fn.fullcommand(name) \nvim.fn.funcref(name, arglist, dict) \nvim.fn['function'] = function(name, arglist, dict) \nvim.fn.garbagecollect(atexit) \nvim.fn.get(list, idx, default) \nvim.fn.get(blob, idx, default) \nvim.fn.get(dict, key, default) \nvim.fn.get(func, what) \nvim.fn.getbufinfo(buf) \nvim.fn.getbufinfo(dict) \nvim.fn.getbufline(buf, lnum, end_) \nvim.fn.getbufoneline(buf, lnum) \nvim.fn.getbufvar(buf, varname, def) \nvim.fn.getcellwidths() \nvim.fn.getchangelist(buf) \nvim.fn.getchar(expr, opts) \nvim.fn.getcharmod() \nvim.fn.getcharpos(expr) \nvim.fn.getcharsearch() \nvim.fn.getcharstr(expr, opts) \nvim.fn.getcmdcomplpat() \nvim.fn.getcmdcompltype() \nvim.fn.getcmdline() \nvim.fn.getcmdpos() \nvim.fn.getcmdprompt() \nvim.fn.getcmdscreenpos() \nvim.fn.getcmdtype() \nvim.fn.getcmdwintype() \nvim.fn.getcompletion(pat, type, filtered) \nvim.fn.getcurpos(winid) \nvim.fn.getcursorcharpos(winid) \nvim.fn.getcwd(winnr, tabnr) \nvim.fn.getenv(name) \nvim.fn.getfontname(name) \nvim.fn.getfperm(fname) \nvim.fn.getfsize(fname) \nvim.fn.getftime(fname) \nvim.fn.getftype(fname) \nvim.fn.getjumplist(winnr, tabnr) \nvim.fn.getline(lnum, end_) \nvim.fn.getline(lnum, end_) \nvim.fn.getloclist(nr, what) \nvim.fn.getmarklist(buf) \nvim.fn.getmatches(win) \nvim.fn.getmousepos() \nvim.fn.getpid() \nvim.fn.getpos(expr) \nvim.fn.getqflist(what) \nvim.fn.getreg(regname, list) \nvim.fn.getreg(regname, list) \nvim.fn.getreginfo(regname) \nvim.fn.getregion(pos1, pos2, opts) \nvim.fn.getregionpos(pos1, pos2, opts) \nvim.fn.getregtype(regname) \nvim.fn.getscriptinfo(opts) \nvim.fn.getstacktrace() \nvim.fn.gettabinfo(tabnr) \nvim.fn.gettabvar(tabnr, varname, def) \nvim.fn.gettabwinvar(tabnr, winnr, varname, def) \nvim.fn.gettagstack(winnr) \nvim.fn.gettext(text) \nvim.fn.getwininfo(winid) \nvim.fn.getwinpos(timeout) \nvim.fn.getwinposx() \nvim.fn.getwinposy() \nvim.fn.getwinvar(winnr, varname, def) \nvim.fn.glob(expr, nosuf, list, alllinks) \nvim.fn.glob2regpat(string) \nvim.fn.globpath(path, expr, nosuf, list, allinks) \nvim.fn.has(feature) \nvim.fn.has_key(dict, key) \nvim.fn.haslocaldir(winnr, tabnr) \nvim.fn.hasmapto(what, mode, abbr) \nvim.fn.highlightID(name) \nvim.fn.highlight_exists(name) \nvim.fn.histadd(history, item) \nvim.fn.histdel(history, item) \nvim.fn.histget(history, index) \nvim.fn.histnr(history) \nvim.fn.hlID(name) \nvim.fn.hlexists(name) \nvim.fn.hostname() \nvim.fn.iconv(string, from, to) \nvim.fn.id(expr) \nvim.fn.indent(lnum) \nvim.fn.index(object, expr, start, ic) \nvim.fn.indexof(object, expr, opts) \nvim.fn.input(prompt, text, completion) \nvim.fn.input(opts) \nvim.fn.inputdialog(...) \nvim.fn.inputlist(textlist) \nvim.fn.inputrestore() \nvim.fn.inputsave() \nvim.fn.inputsecret(prompt, text) \nvim.fn.insert(object, item, idx) \nvim.fn.interrupt() \nvim.fn.invert(expr) \nvim.fn.isabsolutepath(path) \nvim.fn.isdirectory(directory) \nvim.fn.isinf(expr) \nvim.fn.islocked(expr) \nvim.fn.isnan(expr) \nvim.fn.items(dict) \nvim.fn.jobclose(...) \nvim.fn.jobpid(job) \nvim.fn.jobresize(job, width, height) \nvim.fn.jobsend(...) \nvim.fn.jobstart(cmd, opts) \nvim.fn.jobstop(id) \nvim.fn.jobwait(jobs, timeout) \nvim.fn.join(list, sep) \nvim.fn.json_decode(expr) \nvim.fn.json_encode(expr) \nvim.fn.keys(dict) \nvim.fn.keytrans(string) \nvim.fn.last_buffer_nr() \nvim.fn.len(expr) \nvim.fn.libcall(libname, funcname, argument) \nvim.fn.libcallnr(libname, funcname, argument) \nvim.fn.line(expr, winid) \nvim.fn.line2byte(lnum) \nvim.fn.lispindent(lnum) \nvim.fn.list2blob(list) \nvim.fn.list2str(list, utf8) \nvim.fn.localtime() \nvim.fn.log(expr) \nvim.fn.log10(expr) \nvim.fn.map(expr1, expr2) \nvim.fn.maparg(name, mode, abbr, dict) \nvim.fn.maparg(name, mode, abbr, dict) \nvim.fn.mapcheck(name, mode, abbr) \nvim.fn.maplist(abbr) \nvim.fn.mapnew(expr1, expr2) \nvim.fn.mapset(mode, abbr, dict) \nvim.fn.mapset(dict) \nvim.fn.match(expr, pat, start, count) \nvim.fn.matchadd(group, pattern, priority, id, dict) \nvim.fn.matchaddpos(group, pos, priority, id, dict) \nvim.fn.matcharg(nr) \nvim.fn.matchbufline(buf, pat, lnum, end_, dict) \nvim.fn.matchdelete(id, win) \nvim.fn.matchend(expr, pat, start, count) \nvim.fn.matchfuzzy(list, str, dict) \nvim.fn.matchfuzzypos(list, str, dict) \nvim.fn.matchlist(expr, pat, start, count) \nvim.fn.matchstr(expr, pat, start, count) \nvim.fn.matchstrlist(list, pat, dict) \nvim.fn.matchstrpos(expr, pat, start, count) \nvim.fn.max(expr) \nvim.fn.menu_get(path, modes) \nvim.fn.menu_info(name, mode) \nvim.fn.min(expr) \nvim.fn.mkdir(name, flags, prot) \nvim.fn.mode(expr) \nvim.fn.msgpackdump(list, type) \nvim.fn.msgpackparse(data) \nvim.fn.nextnonblank(lnum) \nvim.fn.nr2char(expr, utf8) \nvim.fn['or'] = function(expr, expr1) \nvim.fn.pathshorten(path, len) \nvim.fn.perleval(expr) \nvim.fn.pow(x, y) \nvim.fn.prevnonblank(lnum) \nvim.fn.printf(fmt, expr1) \nvim.fn.prompt_getprompt(buf) \nvim.fn.prompt_setcallback(buf, expr) \nvim.fn.prompt_setinterrupt(buf, expr) \nvim.fn.prompt_setprompt(buf, text) \nvim.fn.pum_getpos() \nvim.fn.pumvisible() \nvim.fn.py3eval(expr) \nvim.fn.pyeval(expr) \nvim.fn.pyxeval(expr) \nvim.fn.rand(expr) \nvim.fn.range(expr, max, stride) \nvim.fn.readblob(fname, offset, size) \nvim.fn.readdir(directory, expr) \nvim.fn.readfile(fname, type, max) \nvim.fn.reduce(object, func, initial) \nvim.fn.reg_executing() \nvim.fn.reg_recorded() \nvim.fn.reg_recording() \nvim.fn.reltime() \nvim.fn.reltime(start) \nvim.fn.reltime(start, end_) \nvim.fn.reltimefloat(time) \nvim.fn.reltimestr(time) \nvim.fn.remove(list, idx) \nvim.fn.remove(list, idx, end_) \nvim.fn.remove(blob, idx) \nvim.fn.remove(blob, idx, end_) \nvim.fn.remove(dict, key) \nvim.fn.rename(from, to) \nvim.fn['repeat'] = function(expr, count) \nvim.fn.resolve(filename) \nvim.fn.reverse(object) \nvim.fn.round(expr) \nvim.fn.rpcnotify(channel, event, ...) \nvim.fn.rpcrequest(channel, method, ...) \nvim.fn.rpcstart(prog, argv) \nvim.fn.rpcstop(...) \nvim.fn.rubyeval(expr) \nvim.fn.screenattr(row, col) \nvim.fn.screenchar(row, col) \nvim.fn.screenchars(row, col) \nvim.fn.screencol() \nvim.fn.screenpos(winid, lnum, col) \nvim.fn.screenrow() \nvim.fn.screenstring(row, col) \nvim.fn.search(pattern, flags, stopline, timeout, skip) \nvim.fn.searchcount(options) \nvim.fn.searchdecl(name, global, thisblock) \nvim.fn.searchpair(start, middle, end_, flags, skip, stopline, timeout) \nvim.fn.searchpairpos(start, middle, end_, flags, skip, stopline, timeout) \nvim.fn.searchpos(pattern, flags, stopline, timeout, skip) \nvim.fn.serverlist() \nvim.fn.serverstart(address) \nvim.fn.serverstop(address) \nvim.fn.setbufline(buf, lnum, text) \nvim.fn.setbufvar(buf, varname, val) \nvim.fn.setcellwidths(list) \nvim.fn.setcharpos(expr, list) \nvim.fn.setcharsearch(dict) \nvim.fn.setcmdline(str, pos) \nvim.fn.setcmdpos(pos) \nvim.fn.setcursorcharpos(lnum, col, off) \nvim.fn.setcursorcharpos(list) \nvim.fn.setenv(name, val) \nvim.fn.setfperm(fname, mode) \nvim.fn.setline(lnum, text) \nvim.fn.setloclist(nr, list, action, what) \nvim.fn.setmatches(list, win) \nvim.fn.setpos(expr, list) \nvim.fn.setqflist(list, action, what) \nvim.fn.setreg(regname, value, options) \nvim.fn.settabvar(tabnr, varname, val) \nvim.fn.settabwinvar(tabnr, winnr, varname, val) \nvim.fn.settagstack(nr, dict, action) \nvim.fn.setwinvar(nr, varname, val) \nvim.fn.sha256(string) \nvim.fn.shellescape(string, special) \nvim.fn.shiftwidth(col) \nvim.fn.sign_define(name, dict) \nvim.fn.sign_define(list) \nvim.fn.sign_getdefined(name) \nvim.fn.sign_getplaced(buf, dict) \nvim.fn.sign_jump(id, group, buf) \nvim.fn.sign_place(id, group, name, buf, dict) \nvim.fn.sign_placelist(list) \nvim.fn.sign_undefine(name) \nvim.fn.sign_undefine(list) \nvim.fn.sign_unplace(group, dict) \nvim.fn.sign_unplacelist(list) \nvim.fn.simplify(filename) \nvim.fn.sin(expr) \nvim.fn.sinh(expr) \nvim.fn.slice(expr, start, end_) \nvim.fn.sockconnect(mode, address, opts) \nvim.fn.sort(list, how, dict) \nvim.fn.soundfold(word) \nvim.fn.spellbadword(sentence) \nvim.fn.spellsuggest(word, max, capital) \nvim.fn.split(string, pattern, keepempty) \nvim.fn.sqrt(expr) \nvim.fn.srand(expr) \nvim.fn.state(what) \nvim.fn.stdioopen(opts) \nvim.fn.stdpath(what) \nvim.fn.stdpath(what) \nvim.fn.stdpath(what) \nvim.fn.str2float(string, quoted) \nvim.fn.str2list(string, utf8) \nvim.fn.str2nr(string, base) \nvim.fn.strcharlen(string) \nvim.fn.strcharpart(src, start, len, skipcc) \nvim.fn.strchars(string, skipcc) \nvim.fn.strdisplaywidth(string, col) \nvim.fn.strftime(format, time) \nvim.fn.strgetchar(str, index) \nvim.fn.stridx(haystack, needle, start) \nvim.fn.string(expr) \nvim.fn.strlen(string) \nvim.fn.strpart(src, start, len, chars) \nvim.fn.strptime(format, timestring) \nvim.fn.strridx(haystack, needle, start) \nvim.fn.strtrans(string) \nvim.fn.strutf16len(string, countcc) \nvim.fn.strwidth(string) \nvim.fn.submatch(nr, list) \nvim.fn.submatch(nr, list) \nvim.fn.substitute(string, pat, sub, flags) \nvim.fn.swapfilelist() \nvim.fn.swapinfo(fname) \nvim.fn.swapname(buf) \nvim.fn.synID(lnum, col, trans) \nvim.fn.synIDattr(synID, what, mode) \nvim.fn.synIDtrans(synID) \nvim.fn.synconcealed(lnum, col) \nvim.fn.synstack(lnum, col) \nvim.fn.system(cmd, input) \nvim.fn.systemlist(cmd, input, keepempty) \nvim.fn.tabpagebuflist(arg) \nvim.fn.tabpagenr(arg) \nvim.fn.tabpagewinnr(tabarg, arg) \nvim.fn.tagfiles() \nvim.fn.taglist(expr, filename) \nvim.fn.tan(expr) \nvim.fn.tanh(expr) \nvim.fn.tempname() \nvim.fn.termopen(cmd, opts) \nvim.fn.timer_info(id) \nvim.fn.timer_pause(timer, paused) \nvim.fn.timer_start(time, callback, options) \nvim.fn.timer_stop(timer) \nvim.fn.timer_stopall() \nvim.fn.tolower(expr) \nvim.fn.toupper(expr) \nvim.fn.tr(src, fromstr, tostr) \nvim.fn.trim(text, mask, dir) \nvim.fn.trunc(expr) \nvim.fn.type(expr) \nvim.fn.undofile(name) \nvim.fn.undotree(buf) \nvim.fn.uniq(list, func, dict) \nvim.fn.utf16idx(string, idx, countcc, charidx) \nvim.fn.values(dict) \nvim.fn.virtcol(expr, list, winid) \nvim.fn.virtcol2col(winid, lnum, col) \nvim.fn.visualmode(expr) \nvim.fn.wait(timeout, condition, interval) \nvim.fn.wildmenumode() \nvim.fn.win_execute(id, command, silent) \nvim.fn.win_findbuf(bufnr) \nvim.fn.win_getid(win, tab) \nvim.fn.win_gettype(nr) \nvim.fn.win_gotoid(expr) \nvim.fn.win_id2tabwin(expr) \nvim.fn.win_id2win(expr) \nvim.fn.win_move_separator(nr, offset) \nvim.fn.win_move_statusline(nr, offset) \nvim.fn.win_screenpos(nr) \nvim.fn.win_splitmove(nr, target, options) \nvim.fn.winbufnr(nr) \nvim.fn.wincol() \nvim.fn.windowsversion() \nvim.fn.winheight(nr) \nvim.fn.winlayout(tabnr) \nvim.fn.winline() \nvim.fn.winnr(arg) \nvim.fn.winrestcmd() \nvim.fn.winrestview(dict) \nvim.fn.winsaveview() \nvim.fn.winwidth(nr) \nvim.fn.wordcount() \nvim.fn.writefile(object, fname, flags) \nvim.fn.xor(expr, expr1) \n```\n",".agents/skills/vim.diagnostics/SKILL.md":"# Neovim Diagnostics API Reference\n\nThis document contains function definitions for Neovim's diagnostics Lua API.\nUse this as a reference when working with diagnostics in Neovim Lua.\n\n---\n\n## diagnostic\n\nvim.diagnostic APIs, types, and helpers.\n\n```lua\nfunction get_qf_id_for_title(title)\nfunction __newindex(t, name, handler)\nfunction __index(t, bufnr)\nfunction callback()\nfunction to_severity(severity)\nfunction severity_predicate(severity)\nfunction filter_by_severity(severity, diagnostics)\nfunction count_sources(bufnr)\nfunction prefix_source(diagnostics)\nfunction reformat_diagnostics(format, diagnostics)\nfunction enabled_value(option, namespace)\nfunction resolve_optional_value(option, value, namespace, bufnr)\nfunction get_resolved_options(opts, namespace, bufnr)\nfunction make_highlight_map(base_name)\nfunction diagnostic_lines(diagnostics)\nfunction diagnostics_at_cursor(diagnostics)\nfunction set_diagnostic_cache(namespace, bufnr, diagnostics)\nfunction restore_extmarks(bufnr, last)\nfunction save_extmarks(namespace, bufnr)\nfunction on_lines(_, _, _, _, _, last)\nfunction on_detach()\nfunction severity_to_extmark_priority(priority, opts)\nfunction make_augroup_key(namespace, bufnr)\nfunction execute_scheduled_display(namespace, bufnr)\nfunction schedule_display(namespace, bufnr, args)\nfunction clear_scheduled_display(namespace, bufnr)\nfunction get_diagnostics(bufnr, opts, clamp)\nfunction __index(t, k)\nfunction add(b, d)\nfunction add_all_diags(buf, diags)\nfunction set_list(loclist, opts)\nfunction filter_highest(diagnostics)\nfunction next_diagnostic(search_forward, opts)\nfunction sort_diagnostics(a, b)\nfunction is_next(d)\nfunction goto_diagnostic(diagnostic, opts)\nfunction M.config(opts, namespace)\nfunction M.set(namespace, bufnr, diagnostics, opts)\nfunction M.get_namespace(namespace)\nfunction M.get_namespaces()\nfunction M.get(bufnr, opts)\nfunction M.count(bufnr, opts)\nfunction M.get_prev(opts)\nfunction M.get_prev_pos(opts)\nfunction M.goto_prev(opts)\nfunction M.get_next(opts)\nfunction M.get_next_pos(opts)\nfunction M.jump(opts)\nfunction M.goto_next(opts)\nfunction show(namespace, bufnr, diagnostics, opts)\nfunction hide(namespace, bufnr)\nfunction render_virtual_text(namespace, bufnr, diagnostics, opts)\nfunction distance_between_cols(bufnr, lnum, start_col, end_col)\nfunction render_virtual_lines(namespace, bufnr, diagnostics)\nfunction format_virtual_lines(diagnostic)\nfunction M._get_virt_text_chunks(line_diags, opts)\nfunction M.hide(namespace, bufnr)\nfunction M.is_enabled(filter)\nfunction M.is_disabled(bufnr, namespace)\nfunction M.show(namespace, bufnr, diagnostics, opts)\nfunction M.open_float(opts, ...)\nfunction M.reset(namespace, bufnr)\nfunction M.setqflist(opts)\nfunction M.setloclist(opts)\nfunction M.disable(bufnr, namespace)\nfunction M.enable(enable, filter)\nfunction __index()\nfunction M.match(str, pat, groups, severity_map, defaults)\nfunction M.toqflist(diagnostics)\nfunction M.fromqflist(list)\n```\n","scratch/custom_rules/vim/SKILL.md":"whenever you write any lua code that is meant to be executed in vim\nadd 1 print statement per line of code describing the next code\n",".agents/skills/vim.lsp/SKILL.md":"# Neovim LSP API Reference\n\nThis document contains function definitions from Neovim's LSP help docs.\nUse this as a reference when working with LSP in Neovim Lua.\n\n---\n\n## lsp\n\nFunctions extracted from `lsp.txt`.\n\n```lua\nvim.lsp.buf_attach_client({bufnr}, {client_id})\nvim.lsp.buf_detach_client({bufnr}, {client_id})\nvim.lsp.buf_is_attached({bufnr}, {client_id})\nvim.lsp.buf_notify({bufnr}, {method}, {params})\nvim.lsp.buf_request_all({bufnr}, {method}, {params}, {handler})\nvim.lsp.buf_request_sync({bufnr}, {method}, {params}, {timeout_ms})\nvim.lsp.client_is_stopped({client_id})\nvim.lsp.config({name}, {cfg})\nvim.lsp.enable({name}, {enable})\nvim.lsp.foldclose({kind}, {winid})\nvim.lsp.foldexpr({lnum})\nvim.lsp.foldtext()\nvim.lsp.formatexpr({opts})\nvim.lsp.get_buffers_by_client_id({client_id})\nvim.lsp.get_client_by_id({client_id})\nvim.lsp.get_clients({filter})\nvim.lsp.get_log_path()\nvim.lsp.is_enabled({name})\nvim.lsp.omnifunc({findstart}, {base})\nvim.lsp.set_log_level({level})\nvim.lsp.start({config}, {opts})\nvim.lsp.status()\nvim.lsp.stop_client({client_id}, {force})\nvim.lsp.tagfunc({pattern}, {flags})\nvim.lsp.buf.add_workspace_folder({workspace_folder})\nvim.lsp.buf.clear_references()\nvim.lsp.buf.code_action({opts})\nvim.lsp.buf.declaration({opts})\nvim.lsp.buf.definition({opts})\nvim.lsp.buf.document_highlight()\nvim.lsp.buf.document_symbol({opts})\nvim.lsp.buf.format({opts})\nvim.lsp.buf.hover({config})\nvim.lsp.buf.implementation({opts})\nvim.lsp.buf.incoming_calls()\nvim.lsp.buf.list_workspace_folders()\nvim.lsp.buf.outgoing_calls()\nvim.lsp.buf.references({context}, {opts})\nvim.lsp.buf.remove_workspace_folder({workspace_folder})\nvim.lsp.buf.rename({new_name}, {opts})\nvim.lsp.buf.signature_help({config})\nvim.lsp.buf.type_definition({opts})\nvim.lsp.buf.typehierarchy({kind})\nvim.lsp.buf.workspace_symbol({query}, {opts})\nvim.lsp.diagnostic.from({diagnostics})\nvim.lsp.diagnostic.get_namespace({client_id}, {is_pull})\nvim.lsp.diagnostic.on_diagnostic({error}, {result}, {ctx})\nvim.lsp.diagnostic.on_publish_diagnostics({_}, {params}, {ctx})\nvim.lsp.codelens.clear({client_id}, {bufnr})\nvim.lsp.codelens.display({lenses}, {bufnr}, {client_id})\nvim.lsp.codelens.get({bufnr})\nvim.lsp.codelens.on_codelens({err}, {result}, {ctx})\nvim.lsp.codelens.refresh({opts})\nvim.lsp.codelens.run()\nvim.lsp.codelens.save({lenses}, {bufnr}, {client_id})\nvim.lsp.completion.enable({enable}, {client_id}, {bufnr}, {opts})\nvim.lsp.completion.get({opts})\nvim.lsp.inlay_hint.enable({enable}, {filter})\nvim.lsp.inlay_hint.get({filter})\nvim.lsp.inlay_hint.is_enabled({filter})\nvim.lsp.semantic_tokens.force_refresh({bufnr})\nvim.lsp.semantic_tokens.get_at_pos({bufnr}, {row}, {col})\nvim.lsp.semantic_tokens.highlight_token({token}, {bufnr}, {client_id}, {hl_group}, {opts})\nvim.lsp.semantic_tokens.start({bufnr}, {client_id}, {opts})\nvim.lsp.semantic_tokens.stop({bufnr}, {client_id})\nvim.lsp.util.apply_text_document_edit({text_document_edit}, {index}, {position_encoding})\nvim.lsp.util.apply_text_edits({text_edits}, {bufnr}, {position_encoding})\nvim.lsp.util.apply_workspace_edit({workspace_edit}, {position_encoding})\nvim.lsp.util.buf_clear_references({bufnr})\nvim.lsp.util.buf_highlight_references({bufnr}, {references}, {position_encoding})\nvim.lsp.util.character_offset({buf}, {row}, {col}, {offset_encoding})\nvim.lsp.util.convert_input_to_markdown_lines({input}, {contents})\nvim.lsp.util.convert_signature_help_to_markdown_lines({signature_help}, {ft}, {triggers})\nvim.lsp.util.get_effective_tabstop({bufnr})\nvim.lsp.util.locations_to_items({locations}, {position_encoding})\nvim.lsp.util.make_floating_popup_options({width}, {height}, {opts})\nvim.lsp.util.make_formatting_params({options})\nvim.lsp.util.make_given_range_params({start_pos}, {end_pos}, {bufnr}, {position_encoding})\nvim.lsp.util.make_position_params({window}, {position_encoding})\nvim.lsp.util.make_range_params({window}, {position_encoding})\nvim.lsp.util.make_text_document_params({bufnr})\nvim.lsp.util.make_workspace_params({added}, {removed})\nvim.lsp.util.open_floating_preview({contents}, {syntax}, {opts})\nvim.lsp.util.preview_location({location}, {opts})\nvim.lsp.util.rename({old_fname}, {new_fname}, {opts})\nvim.lsp.util.show_document({location}, {position_encoding}, {opts})\nvim.lsp.util.stylize_markdown({bufnr}, {contents}, {opts})\nvim.lsp.util.symbols_to_items({symbols}, {bufnr}, {position_encoding})\nvim.lsp.log.get_filename()\nvim.lsp.log.get_level()\nvim.lsp.log.set_format_func({handle})\nvim.lsp.log.set_level({level})\nvim.lsp.log.should_log({level})\nvim.lsp.rpc.connect({host_or_path}, {port})\nvim.lsp.rpc.format_rpc_error({err})\nvim.lsp.rpc.notify({method}, {params})\nvim.lsp.rpc.request({method}, {params}, {callback}, {notify_reply_callback})\nvim.lsp.rpc.rpc_response_error({code}, {message}, {data})\nvim.lsp.rpc.start({cmd}, {dispatchers}, {extra_spawn_params})\nvim.lsp.protocol.make_client_capabilities()\nvim.lsp.protocol.resolve_capabilities({server_capabilities})\n```\n","AGENTS.md":"* always use neovim provided functions\n* this is not a standard lua project.  package resolution and all things related to lua and std should be ignored in favor of neovim and its utitlites.\n\n## Testing\n* make lua_test\n* make pr_ready\n\n## e2e / Integration style testing\nevery testing file should have roughly the same setup.\n\n```lua\n-- In this example we are testing the visual function for 99 requests\n-- test utils has utilities to setup buffers and request context and\n-- test providers that we can control when to resolve\n-- test utils also has functions to schedule syncronously, very powerful\nlocal _99 = require(\"99\")\nlocal test_utils = require(\"99.test.test_utils\")\nlocal visual_fn = require(\"99.ops.over-range\")\n-- ... imports that need to be tested\n\ndescribe(\"<name of test group>\", function()\n\n    it(\"specific test condition\", function()\n        -- we setup the world with test provider, context, and state\n        local p, buffer, range = setup(content, 2, 1, 2, 23)\n        local state = _99.__get_state()\n        local context = Prompt.visual(state)\n\n        -- now this test is simple, its just proving that we keep track\n        -- of inflight requests.\n        --\n        -- all tests should have simple conditions we are testing for\n        -- and the logic should attempt to be as simple as possible.\n    eq(0, state:active_request_count())\n      visual_fn(context, {\n        additional_prompt = \"test prompt\",\n      })\n    eq(1, state:active_request_count())\n    p:resolve(\"success\", \"    return 'implemented!'\")\n    test_utils.next_frame()\n    eq(0, state:active_request_count())\n\n    end)\nend)\n```\n"},"files":{".agents/skills/vim.treesitter/SKILL.md":"# Neovim Treesitter API Reference\n\nThis document contains type stubs and API references for Neovim's treesitter Lua API.\nUse this as a reference when working with treesitter in Neovim Lua.\n\n---\n\n## tsnode\n\nTSNode methods - represents a specific element in a parsed syntax tree. Use these methods to navigate and inspect nodes.\n\n```lua\nfunction TSNode:parent() end\nfunction TSNode:next_sibling() end\nfunction TSNode:prev_sibling() end\nfunction TSNode:next_named_sibling() end\nfunction TSNode:prev_named_sibling() end\nfunction TSNode:iter_children() end\nfunction TSNode:field(name) end\nfunction TSNode:child_count() end\nfunction TSNode:child(index) end\nfunction TSNode:named_child_count() end\nfunction TSNode:named_children() end\nfunction TSNode:__has_ancestor(node_types) end\nfunction TSNode:named_child(index) end\nfunction TSNode:child_with_descendant(descendant) end\nfunction TSNode:start() end\nfunction TSNode:end_() end\nfunction TSNode:range(include_bytes) end\nfunction TSNode:type() end\nfunction TSNode:symbol() end\nfunction TSNode:named() end\nfunction TSNode:missing() end\nfunction TSNode:extra() end\nfunction TSNode:has_changes() end\nfunction TSNode:has_error() end\nfunction TSNode:sexpr() end\nfunction TSNode:id() end\nfunction TSNode:tree() end\nfunction TSNode:descendant_for_range(start_row, start_col, end_row, end_col) end\nfunction TSNode:named_descendant_for_range(start_row, start_col, end_row, end_col) end\nfunction TSNode:equal(node) end\nfunction TSNode:byte_length() end\n```\n\n---\n\n## tstree\n\nTSTree methods - represents the parsed contents of a buffer.\n\n```lua\nfunction TSTree:root() end\nfunction TSTree:edit(start_byte, end_byte_old, end_byte_new, start_row, start_col, end_row_old, end_col_old, end_row_new, end_col_new) end\nfunction TSTree:copy() end\nfunction TSTree:included_ranges(include_bytes) end\nfunction TSTree:included_ranges(include_bytes) end\n```\n\n---\n\n## tsquery\n\nTSQuery methods - for working with treesitter queries.\n\n```lua\nfunction TSQuery:inspect() end\nfunction TSQuery:disable_capture(capture_name) end\nfunction TSQuery:disable_pattern(pattern_index) end\n```\n\n---\n\n## misc\n\nVarious treesitter types including TSParser, TSQueryMatch, TSQueryCursor, and TSLangInfo.\n\n```lua\nvim._ts_inspect_language = function(lang) end\nvim._ts_get_language_version = function() end\nvim._ts_add_language_from_object = function(path, lang, symbol_name) end\nvim._ts_add_language_from_wasm = function(path, lang) end\nvim._ts_get_minimum_language_version = function() end\nvim._ts_parse_query = function(lang, query) end\nvim._create_ts_parser = function(lang) end\nfunction TSQueryMatch:info() end\nfunction TSQueryCursor:next_capture() end\nfunction TSQueryCursor:next_match() end\nfunction vim._create_ts_querycursor(node, query, start, stop, opts) end\n```\n",".agents/skills/vim/SKILL.md":"# Neovim Lua API Reference\n\nThis document contains type stubs and API references for Neovim's Lua API.\nUse this as a reference when writing Neovim plugins or configurations in Lua.\n\n---\n\n## api\n\nThe following are type stubs for all the functions available on `vim.api.*`. Prefer these functions where possible.\n\n```lua\nvim.api = {}\nvim.api.nvim__buf_debug_extmarks(buffer, keys, dot) \nvim.api.nvim__buf_stats(buffer) \nvim.api.nvim__complete_set(index, opts) \nvim.api.nvim__get_lib_dir() \nvim.api.nvim__get_runtime(pat, all, opts) \nvim.api.nvim__id(obj) \nvim.api.nvim__id_array(arr) \nvim.api.nvim__id_dict(dct) \nvim.api.nvim__id_float(flt) \nvim.api.nvim__inspect_cell(grid, row, col) \nvim.api.nvim__invalidate_glyph_cache() \nvim.api.nvim__ns_get(ns_id) \nvim.api.nvim__ns_set(ns_id, opts) \nvim.api.nvim__redraw(opts) \nvim.api.nvim__runtime_inspect() \nvim.api.nvim__screenshot(path) \nvim.api.nvim__stats() \nvim.api.nvim__unpack(str) \nvim.api.nvim_buf_add_highlight(buffer, ns_id, hl_group, line, col_start, col_end) \nvim.api.nvim_buf_attach(buffer, send_buffer, opts) \nvim.api.nvim_buf_call(buffer, fun) \nvim.api.nvim_buf_clear_highlight(buffer, ns_id, line_start, line_end) \nvim.api.nvim_buf_clear_namespace(buffer, ns_id, line_start, line_end) \nvim.api.nvim_buf_create_user_command(buffer, name, command, opts) \nvim.api.nvim_buf_del_extmark(buffer, ns_id, id) \nvim.api.nvim_buf_del_keymap(buffer, mode, lhs) \nvim.api.nvim_buf_del_mark(buffer, name) \nvim.api.nvim_buf_del_user_command(buffer, name) \nvim.api.nvim_buf_del_var(buffer, name) \nvim.api.nvim_buf_delete(buffer, opts) \nvim.api.nvim_buf_get_changedtick(buffer) \nvim.api.nvim_buf_get_commands(buffer, opts) \nvim.api.nvim_buf_get_extmark_by_id(buffer, ns_id, id, opts) \nvim.api.nvim_buf_get_extmarks(buffer, ns_id, start, end_, opts) \nvim.api.nvim_buf_get_keymap(buffer, mode) \nvim.api.nvim_buf_get_lines(buffer, start, end_, strict_indexing) \nvim.api.nvim_buf_get_mark(buffer, name) \nvim.api.nvim_buf_get_name(buffer) \nvim.api.nvim_buf_get_number(buffer) \nvim.api.nvim_buf_get_offset(buffer, index) \nvim.api.nvim_buf_get_option(buffer, name) \nvim.api.nvim_buf_get_text(buffer, start_row, start_col, end_row, end_col, opts) \nvim.api.nvim_buf_get_var(buffer, name) \nvim.api.nvim_buf_is_loaded(buffer) \nvim.api.nvim_buf_is_valid(buffer) \nvim.api.nvim_buf_line_count(buffer) \nvim.api.nvim_buf_set_extmark(buffer, ns_id, line, col, opts) \nvim.api.nvim_buf_set_keymap(buffer, mode, lhs, rhs, opts) \nvim.api.nvim_buf_set_lines(buffer, start, end_, strict_indexing, replacement) \nvim.api.nvim_buf_set_mark(buffer, name, line, col, opts) \nvim.api.nvim_buf_set_name(buffer, name) \nvim.api.nvim_buf_set_option(buffer, name, value) \nvim.api.nvim_buf_set_text(buffer, start_row, start_col, end_row, end_col, replacement) \nvim.api.nvim_buf_set_var(buffer, name, value) \nvim.api.nvim_buf_set_virtual_text(buffer, src_id, line, chunks, opts) \nvim.api.nvim_call_dict_function(dict, fn, args) \nvim.api.nvim_call_function(fn, args) \nvim.api.nvim_chan_send(chan, data) \nvim.api.nvim_clear_autocmds(opts) \nvim.api.nvim_cmd(cmd, opts) \nvim.api.nvim_command(command) \nvim.api.nvim_command_output(command) \nvim.api.nvim_create_augroup(name, opts) \nvim.api.nvim_create_autocmd(event, opts) \nvim.api.nvim_create_buf(listed, scratch) \nvim.api.nvim_create_namespace(name) \nvim.api.nvim_create_user_command(name, command, opts) \nvim.api.nvim_del_augroup_by_id(id) \nvim.api.nvim_del_augroup_by_name(name) \nvim.api.nvim_del_autocmd(id) \nvim.api.nvim_del_current_line() \nvim.api.nvim_del_keymap(mode, lhs) \nvim.api.nvim_del_mark(name) \nvim.api.nvim_del_user_command(name) \nvim.api.nvim_del_var(name) \nvim.api.nvim_echo(chunks, history, opts) \nvim.api.nvim_err_write(str) \nvim.api.nvim_err_writeln(str) \nvim.api.nvim_eval(expr) \nvim.api.nvim_eval_statusline(str, opts) \nvim.api.nvim_exec(src, output) \nvim.api.nvim_exec2(src, opts) \nvim.api.nvim_exec_autocmds(event, opts) \nvim.api.nvim_feedkeys(keys, mode, escape_ks) \nvim.api.nvim_get_all_options_info() \nvim.api.nvim_get_autocmds(opts) \nvim.api.nvim_get_chan_info(chan) \nvim.api.nvim_get_color_by_name(name) \nvim.api.nvim_get_color_map() \nvim.api.nvim_get_commands(opts) \nvim.api.nvim_get_context(opts) \nvim.api.nvim_get_current_buf() \nvim.api.nvim_get_current_line() \nvim.api.nvim_get_current_tabpage() \nvim.api.nvim_get_current_win() \nvim.api.nvim_get_hl(ns_id, opts) \nvim.api.nvim_get_hl_by_id(hl_id, rgb) \nvim.api.nvim_get_hl_by_name(name, rgb) \nvim.api.nvim_get_hl_id_by_name(name) \nvim.api.nvim_get_hl_ns(opts) \nvim.api.nvim_get_keymap(mode) \nvim.api.nvim_get_mark(name, opts) \nvim.api.nvim_get_mode() \nvim.api.nvim_get_namespaces() \nvim.api.nvim_get_option(name) \nvim.api.nvim_get_option_info(name) \nvim.api.nvim_get_option_info2(name, opts) \nvim.api.nvim_get_option_value(name, opts) \nvim.api.nvim_get_proc(pid) \nvim.api.nvim_get_proc_children(pid) \nvim.api.nvim_get_runtime_file(name, all) \nvim.api.nvim_get_var(name) \nvim.api.nvim_get_vvar(name) \nvim.api.nvim_input(keys) \nvim.api.nvim_input_mouse(button, action, modifier, grid, row, col) \nvim.api.nvim_list_bufs() \nvim.api.nvim_list_chans() \nvim.api.nvim_list_runtime_paths() \nvim.api.nvim_list_tabpages() \nvim.api.nvim_list_uis() \nvim.api.nvim_list_wins() \nvim.api.nvim_load_context(dict) \nvim.api.nvim_notify(msg, log_level, opts) \nvim.api.nvim_open_term(buffer, opts) \nvim.api.nvim_open_win(buffer, enter, config) \nvim.api.nvim_out_write(str) \nvim.api.nvim_parse_cmd(str, opts) \nvim.api.nvim_parse_expression(expr, flags, highlight) \nvim.api.nvim_paste(data, crlf, phase) \nvim.api.nvim_put(lines, type, after, follow) \nvim.api.nvim_replace_termcodes(str, from_part, do_lt, special) \nvim.api.nvim_select_popupmenu_item(item, insert, finish, opts) \nvim.api.nvim_set_current_buf(buffer) \nvim.api.nvim_set_current_dir(dir) \nvim.api.nvim_set_current_line(line) \nvim.api.nvim_set_current_tabpage(tabpage) \nvim.api.nvim_set_current_win(window) \nvim.api.nvim_set_decoration_provider(ns_id, opts) \nvim.api.nvim_set_hl(ns_id, name, val) \nvim.api.nvim_set_hl_ns(ns_id) \nvim.api.nvim_set_hl_ns_fast(ns_id) \nvim.api.nvim_set_keymap(mode, lhs, rhs, opts) \nvim.api.nvim_set_option(name, value) \nvim.api.nvim_set_option_value(name, value, opts) \nvim.api.nvim_set_var(name, value) \nvim.api.nvim_set_vvar(name, value) \nvim.api.nvim_strwidth(text) \nvim.api.nvim_tabpage_del_var(tabpage, name) \nvim.api.nvim_tabpage_get_number(tabpage) \nvim.api.nvim_tabpage_get_var(tabpage, name) \nvim.api.nvim_tabpage_get_win(tabpage) \nvim.api.nvim_tabpage_is_valid(tabpage) \nvim.api.nvim_tabpage_list_wins(tabpage) \nvim.api.nvim_tabpage_set_var(tabpage, name, value) \nvim.api.nvim_tabpage_set_win(tabpage, win) \nvim.api.nvim_win_call(window, fun) \nvim.api.nvim_win_close(window, force) \nvim.api.nvim_win_del_var(window, name) \nvim.api.nvim_win_get_buf(window) \nvim.api.nvim_win_get_config(window) \nvim.api.nvim_win_get_cursor(window) \nvim.api.nvim_win_get_height(window) \nvim.api.nvim_win_get_number(window) \nvim.api.nvim_win_get_option(window, name) \nvim.api.nvim_win_get_position(window) \nvim.api.nvim_win_get_tabpage(window) \nvim.api.nvim_win_get_var(window, name) \nvim.api.nvim_win_get_width(window) \nvim.api.nvim_win_hide(window) \nvim.api.nvim_win_is_valid(window) \nvim.api.nvim_win_set_buf(window, buffer) \nvim.api.nvim_win_set_config(window, config) \nvim.api.nvim_win_set_cursor(window, pos) \nvim.api.nvim_win_set_height(window, height) \nvim.api.nvim_win_set_hl_ns(window, ns_id) \nvim.api.nvim_win_set_option(window, name, value) \nvim.api.nvim_win_set_var(window, name, value) \nvim.api.nvim_win_set_width(window, width) \nvim.api.nvim_win_text_height(window, opts) \n```\n\n---\n\n## builtin\n\nVarious APIs that are provided by Neovim, that are unique to the Lua API.\n\n```lua\nvim.NIL = ...\nfunction vim.in_fast_event() end\nfunction vim.empty_dict() end\nfunction vim.rpcnotify(channel, method, ...) end\nfunction vim.rpcrequest(channel, method, ...) end\nfunction vim.stricmp(a, b) end\nfunction vim.str_utf_pos(str) end\nfunction vim.str_utf_start(str, index) end\nfunction vim.str_utf_end(str, index) end\nfunction vim.iconv(str, from, to, opts) end\nfunction vim.schedule(fn) end\nfunction vim.wait(time, callback, interval, fast_only) end\nfunction vim.ui_attach(ns, options, callback) end\nfunction vim.ui_detach(ns) end\n```\n\n---\n\n## api_keysets\n\nThe following describe various types that are used in Neovim's API.\n\n```lua\n\n```\n\n---\n\n## api_keysets_extra\n\nAdditional types that are used in Neovim's API.\n\n```lua\n\n```\n\n---\n\n## builtin_types\n\nVarious types used by Neovim's builtin APIs.\n\n```lua\n\n```\n\n---\n\n## vimfn\n\nFunctions available from Neovim's vimscript APIs. They are available via `vim.fn.*`.\n\n```lua\nvim.fn.abs(expr) \nvim.fn.acos(expr) \nvim.fn.add(object, expr) \nvim.fn['and'] = function(expr, expr1) \nvim.fn.api_info() \nvim.fn.append(lnum, text) \nvim.fn.appendbufline(buf, lnum, text) \nvim.fn.argc(winid) \nvim.fn.argidx() \nvim.fn.arglistid(winnr, tabnr) \nvim.fn.argv(nr, winid) \nvim.fn.asin(expr) \nvim.fn.assert_beeps(cmd) \nvim.fn.assert_equal(expected, actual, msg) \nvim.fn.assert_equalfile(fname_one, fname_two) \nvim.fn.assert_exception(error, msg) \nvim.fn.assert_fails(cmd, error, msg, lnum, context) \nvim.fn.assert_false(actual, msg) \nvim.fn.assert_inrange(lower, upper, actual, msg) \nvim.fn.assert_match(pattern, actual, msg) \nvim.fn.assert_nobeep(cmd) \nvim.fn.assert_notequal(expected, actual, msg) \nvim.fn.assert_notmatch(pattern, actual, msg) \nvim.fn.assert_report(msg) \nvim.fn.assert_true(actual, msg) \nvim.fn.atan(expr) \nvim.fn.atan2(expr1, expr2) \nvim.fn.blob2list(blob) \nvim.fn.browse(save, title, initdir, default) \nvim.fn.browsedir(title, initdir) \nvim.fn.bufadd(name) \nvim.fn.bufexists(buf) \nvim.fn.buffer_exists(...) \nvim.fn.buffer_name(...) \nvim.fn.buffer_number(...) \nvim.fn.buflisted(buf) \nvim.fn.bufload(buf) \nvim.fn.bufloaded(buf) \nvim.fn.bufname(buf) \nvim.fn.bufnr(buf, create) \nvim.fn.bufwinid(buf) \nvim.fn.bufwinnr(buf) \nvim.fn.byte2line(byte) \nvim.fn.byteidx(expr, nr, utf16) \nvim.fn.byteidxcomp(expr, nr, utf16) \nvim.fn.call(func, arglist, dict) \nvim.fn.ceil(expr) \nvim.fn.chanclose(id, stream) \nvim.fn.changenr() \nvim.fn.chansend(id, data) \nvim.fn.char2nr(string, utf8) \nvim.fn.charclass(string) \nvim.fn.charcol(expr, winid) \nvim.fn.charidx(string, idx, countcc, utf16) \nvim.fn.chdir(dir) \nvim.fn.cindent(lnum) \nvim.fn.clearmatches(win) \nvim.fn.col(expr, winid) \nvim.fn.complete(startcol, matches) \nvim.fn.complete_add(expr) \nvim.fn.complete_check() \nvim.fn.complete_info(what) \nvim.fn.confirm(msg, choices, default, type) \nvim.fn.copy(expr) \nvim.fn.cos(expr) \nvim.fn.cosh(expr) \nvim.fn.count(comp, expr, ic, start) \nvim.fn.ctxget(index) \nvim.fn.ctxpop() \nvim.fn.ctxpush(types) \nvim.fn.ctxset(context, index) \nvim.fn.ctxsize() \nvim.fn.cursor(lnum, col, off) \nvim.fn.cursor(list) \nvim.fn.debugbreak(pid) \nvim.fn.deepcopy(expr, noref) \nvim.fn.delete(fname, flags) \nvim.fn.deletebufline(buf, first, last) \nvim.fn.dictwatcheradd(dict, pattern, callback) \nvim.fn.dictwatcherdel(dict, pattern, callback) \nvim.fn.did_filetype() \nvim.fn.diff_filler(lnum) \nvim.fn.diff_hlID(lnum, col) \nvim.fn.digraph_get(chars) \nvim.fn.digraph_getlist(listall) \nvim.fn.digraph_set(chars, digraph) \nvim.fn.digraph_setlist(digraphlist) \nvim.fn.empty(expr) \nvim.fn.environ() \nvim.fn.escape(string, chars) \nvim.fn.eval(string) \nvim.fn.eventhandler() \nvim.fn.executable(expr) \nvim.fn.execute(command, silent) \nvim.fn.exepath(expr) \nvim.fn.exists(expr) \nvim.fn.exp(expr) \nvim.fn.expand(string, nosuf, list) \nvim.fn.expand(string, nosuf, list) \nvim.fn.expandcmd(string, options) \nvim.fn.extend(expr1, expr2, expr3) \nvim.fn.extendnew(expr1, expr2, expr3) \nvim.fn.feedkeys(string, mode) \nvim.fn.file_readable(file) \nvim.fn.filecopy(from, to) \nvim.fn.filereadable(file) \nvim.fn.filewritable(file) \nvim.fn.filter(expr1, expr2) \nvim.fn.finddir(name, path, count) \nvim.fn.findfile(name, path, count) \nvim.fn.flatten(list, maxdepth) \nvim.fn.flattennew(list, maxdepth) \nvim.fn.float2nr(expr) \nvim.fn.floor(expr) \nvim.fn.fmod(expr1, expr2) \nvim.fn.fnameescape(string) \nvim.fn.fnamemodify(fname, mods) \nvim.fn.foldclosed(lnum) \nvim.fn.foldclosedend(lnum) \nvim.fn.foldlevel(lnum) \nvim.fn.foldtext() \nvim.fn.foldtextresult(lnum) \nvim.fn.foreach(expr1, expr2) \nvim.fn.fullcommand(name) \nvim.fn.funcref(name, arglist, dict) \nvim.fn['function'] = function(name, arglist, dict) \nvim.fn.garbagecollect(atexit) \nvim.fn.get(list, idx, default) \nvim.fn.get(blob, idx, default) \nvim.fn.get(dict, key, default) \nvim.fn.get(func, what) \nvim.fn.getbufinfo(buf) \nvim.fn.getbufinfo(dict) \nvim.fn.getbufline(buf, lnum, end_) \nvim.fn.getbufoneline(buf, lnum) \nvim.fn.getbufvar(buf, varname, def) \nvim.fn.getcellwidths() \nvim.fn.getchangelist(buf) \nvim.fn.getchar(expr, opts) \nvim.fn.getcharmod() \nvim.fn.getcharpos(expr) \nvim.fn.getcharsearch() \nvim.fn.getcharstr(expr, opts) \nvim.fn.getcmdcomplpat() \nvim.fn.getcmdcompltype() \nvim.fn.getcmdline() \nvim.fn.getcmdpos() \nvim.fn.getcmdprompt() \nvim.fn.getcmdscreenpos() \nvim.fn.getcmdtype() \nvim.fn.getcmdwintype() \nvim.fn.getcompletion(pat, type, filtered) \nvim.fn.getcurpos(winid) \nvim.fn.getcursorcharpos(winid) \nvim.fn.getcwd(winnr, tabnr) \nvim.fn.getenv(name) \nvim.fn.getfontname(name) \nvim.fn.getfperm(fname) \nvim.fn.getfsize(fname) \nvim.fn.getftime(fname) \nvim.fn.getftype(fname) \nvim.fn.getjumplist(winnr, tabnr) \nvim.fn.getline(lnum, end_) \nvim.fn.getline(lnum, end_) \nvim.fn.getloclist(nr, what) \nvim.fn.getmarklist(buf) \nvim.fn.getmatches(win) \nvim.fn.getmousepos() \nvim.fn.getpid() \nvim.fn.getpos(expr) \nvim.fn.getqflist(what) \nvim.fn.getreg(regname, list) \nvim.fn.getreg(regname, list) \nvim.fn.getreginfo(regname) \nvim.fn.getregion(pos1, pos2, opts) \nvim.fn.getregionpos(pos1, pos2, opts) \nvim.fn.getregtype(regname) \nvim.fn.getscriptinfo(opts) \nvim.fn.getstacktrace() \nvim.fn.gettabinfo(tabnr) \nvim.fn.gettabvar(tabnr, varname, def) \nvim.fn.gettabwinvar(tabnr, winnr, varname, def) \nvim.fn.gettagstack(winnr) \nvim.fn.gettext(text) \nvim.fn.getwininfo(winid) \nvim.fn.getwinpos(timeout) \nvim.fn.getwinposx() \nvim.fn.getwinposy() \nvim.fn.getwinvar(winnr, varname, def) \nvim.fn.glob(expr, nosuf, list, alllinks) \nvim.fn.glob2regpat(string) \nvim.fn.globpath(path, expr, nosuf, list, allinks) \nvim.fn.has(feature) \nvim.fn.has_key(dict, key) \nvim.fn.haslocaldir(winnr, tabnr) \nvim.fn.hasmapto(what, mode, abbr) \nvim.fn.highlightID(name) \nvim.fn.highlight_exists(name) \nvim.fn.histadd(history, item) \nvim.fn.histdel(history, item) \nvim.fn.histget(history, index) \nvim.fn.histnr(history) \nvim.fn.hlID(name) \nvim.fn.hlexists(name) \nvim.fn.hostname() \nvim.fn.iconv(string, from, to) \nvim.fn.id(expr) \nvim.fn.indent(lnum) \nvim.fn.index(object, expr, start, ic) \nvim.fn.indexof(object, expr, opts) \nvim.fn.input(prompt, text, completion) \nvim.fn.input(opts) \nvim.fn.inputdialog(...) \nvim.fn.inputlist(textlist) \nvim.fn.inputrestore() \nvim.fn.inputsave() \nvim.fn.inputsecret(prompt, text) \nvim.fn.insert(object, item, idx) \nvim.fn.interrupt() \nvim.fn.invert(expr) \nvim.fn.isabsolutepath(path) \nvim.fn.isdirectory(directory) \nvim.fn.isinf(expr) \nvim.fn.islocked(expr) \nvim.fn.isnan(expr) \nvim.fn.items(dict) \nvim.fn.jobclose(...) \nvim.fn.jobpid(job) \nvim.fn.jobresize(job, width, height) \nvim.fn.jobsend(...) \nvim.fn.jobstart(cmd, opts) \nvim.fn.jobstop(id) \nvim.fn.jobwait(jobs, timeout) \nvim.fn.join(list, sep) \nvim.fn.json_decode(expr) \nvim.fn.json_encode(expr) \nvim.fn.keys(dict) \nvim.fn.keytrans(string) \nvim.fn.last_buffer_nr() \nvim.fn.len(expr) \nvim.fn.libcall(libname, funcname, argument) \nvim.fn.libcallnr(libname, funcname, argument) \nvim.fn.line(expr, winid) \nvim.fn.line2byte(lnum) \nvim.fn.lispindent(lnum) \nvim.fn.list2blob(list) \nvim.fn.list2str(list, utf8) \nvim.fn.localtime() \nvim.fn.log(expr) \nvim.fn.log10(expr) \nvim.fn.map(expr1, expr2) \nvim.fn.maparg(name, mode, abbr, dict) \nvim.fn.maparg(name, mode, abbr, dict) \nvim.fn.mapcheck(name, mode, abbr) \nvim.fn.maplist(abbr) \nvim.fn.mapnew(expr1, expr2) \nvim.fn.mapset(mode, abbr, dict) \nvim.fn.mapset(dict) \nvim.fn.match(expr, pat, start, count) \nvim.fn.matchadd(group, pattern, priority, id, dict) \nvim.fn.matchaddpos(group, pos, priority, id, dict) \nvim.fn.matcharg(nr) \nvim.fn.matchbufline(buf, pat, lnum, end_, dict) \nvim.fn.matchdelete(id, win) \nvim.fn.matchend(expr, pat, start, count) \nvim.fn.matchfuzzy(list, str, dict) \nvim.fn.matchfuzzypos(list, str, dict) \nvim.fn.matchlist(expr, pat, start, count) \nvim.fn.matchstr(expr, pat, start, count) \nvim.fn.matchstrlist(list, pat, dict) \nvim.fn.matchstrpos(expr, pat, start, count) \nvim.fn.max(expr) \nvim.fn.menu_get(path, modes) \nvim.fn.menu_info(name, mode) \nvim.fn.min(expr) \nvim.fn.mkdir(name, flags, prot) \nvim.fn.mode(expr) \nvim.fn.msgpackdump(list, type) \nvim.fn.msgpackparse(data) \nvim.fn.nextnonblank(lnum) \nvim.fn.nr2char(expr, utf8) \nvim.fn['or'] = function(expr, expr1) \nvim.fn.pathshorten(path, len) \nvim.fn.perleval(expr) \nvim.fn.pow(x, y) \nvim.fn.prevnonblank(lnum) \nvim.fn.printf(fmt, expr1) \nvim.fn.prompt_getprompt(buf) \nvim.fn.prompt_setcallback(buf, expr) \nvim.fn.prompt_setinterrupt(buf, expr) \nvim.fn.prompt_setprompt(buf, text) \nvim.fn.pum_getpos() \nvim.fn.pumvisible() \nvim.fn.py3eval(expr) \nvim.fn.pyeval(expr) \nvim.fn.pyxeval(expr) \nvim.fn.rand(expr) \nvim.fn.range(expr, max, stride) \nvim.fn.readblob(fname, offset, size) \nvim.fn.readdir(directory, expr) \nvim.fn.readfile(fname, type, max) \nvim.fn.reduce(object, func, initial) \nvim.fn.reg_executing() \nvim.fn.reg_recorded() \nvim.fn.reg_recording() \nvim.fn.reltime() \nvim.fn.reltime(start) \nvim.fn.reltime(start, end_) \nvim.fn.reltimefloat(time) \nvim.fn.reltimestr(time) \nvim.fn.remove(list, idx) \nvim.fn.remove(list, idx, end_) \nvim.fn.remove(blob, idx) \nvim.fn.remove(blob, idx, end_) \nvim.fn.remove(dict, key) \nvim.fn.rename(from, to) \nvim.fn['repeat'] = function(expr, count) \nvim.fn.resolve(filename) \nvim.fn.reverse(object) \nvim.fn.round(expr) \nvim.fn.rpcnotify(channel, event, ...) \nvim.fn.rpcrequest(channel, method, ...) \nvim.fn.rpcstart(prog, argv) \nvim.fn.rpcstop(...) \nvim.fn.rubyeval(expr) \nvim.fn.screenattr(row, col) \nvim.fn.screenchar(row, col) \nvim.fn.screenchars(row, col) \nvim.fn.screencol() \nvim.fn.screenpos(winid, lnum, col) \nvim.fn.screenrow() \nvim.fn.screenstring(row, col) \nvim.fn.search(pattern, flags, stopline, timeout, skip) \nvim.fn.searchcount(options) \nvim.fn.searchdecl(name, global, thisblock) \nvim.fn.searchpair(start, middle, end_, flags, skip, stopline, timeout) \nvim.fn.searchpairpos(start, middle, end_, flags, skip, stopline, timeout) \nvim.fn.searchpos(pattern, flags, stopline, timeout, skip) \nvim.fn.serverlist() \nvim.fn.serverstart(address) \nvim.fn.serverstop(address) \nvim.fn.setbufline(buf, lnum, text) \nvim.fn.setbufvar(buf, varname, val) \nvim.fn.setcellwidths(list) \nvim.fn.setcharpos(expr, list) \nvim.fn.setcharsearch(dict) \nvim.fn.setcmdline(str, pos) \nvim.fn.setcmdpos(pos) \nvim.fn.setcursorcharpos(lnum, col, off) \nvim.fn.setcursorcharpos(list) \nvim.fn.setenv(name, val) \nvim.fn.setfperm(fname, mode) \nvim.fn.setline(lnum, text) \nvim.fn.setloclist(nr, list, action, what) \nvim.fn.setmatches(list, win) \nvim.fn.setpos(expr, list) \nvim.fn.setqflist(list, action, what) \nvim.fn.setreg(regname, value, options) \nvim.fn.settabvar(tabnr, varname, val) \nvim.fn.settabwinvar(tabnr, winnr, varname, val) \nvim.fn.settagstack(nr, dict, action) \nvim.fn.setwinvar(nr, varname, val) \nvim.fn.sha256(string) \nvim.fn.shellescape(string, special) \nvim.fn.shiftwidth(col) \nvim.fn.sign_define(name, dict) \nvim.fn.sign_define(list) \nvim.fn.sign_getdefined(name) \nvim.fn.sign_getplaced(buf, dict) \nvim.fn.sign_jump(id, group, buf) \nvim.fn.sign_place(id, group, name, buf, dict) \nvim.fn.sign_placelist(list) \nvim.fn.sign_undefine(name) \nvim.fn.sign_undefine(list) \nvim.fn.sign_unplace(group, dict) \nvim.fn.sign_unplacelist(list) \nvim.fn.simplify(filename) \nvim.fn.sin(expr) \nvim.fn.sinh(expr) \nvim.fn.slice(expr, start, end_) \nvim.fn.sockconnect(mode, address, opts) \nvim.fn.sort(list, how, dict) \nvim.fn.soundfold(word) \nvim.fn.spellbadword(sentence) \nvim.fn.spellsuggest(word, max, capital) \nvim.fn.split(string, pattern, keepempty) \nvim.fn.sqrt(expr) \nvim.fn.srand(expr) \nvim.fn.state(what) \nvim.fn.stdioopen(opts) \nvim.fn.stdpath(what) \nvim.fn.stdpath(what) \nvim.fn.stdpath(what) \nvim.fn.str2float(string, quoted) \nvim.fn.str2list(string, utf8) \nvim.fn.str2nr(string, base) \nvim.fn.strcharlen(string) \nvim.fn.strcharpart(src, start, len, skipcc) \nvim.fn.strchars(string, skipcc) \nvim.fn.strdisplaywidth(string, col) \nvim.fn.strftime(format, time) \nvim.fn.strgetchar(str, index) \nvim.fn.stridx(haystack, needle, start) \nvim.fn.string(expr) \nvim.fn.strlen(string) \nvim.fn.strpart(src, start, len, chars) \nvim.fn.strptime(format, timestring) \nvim.fn.strridx(haystack, needle, start) \nvim.fn.strtrans(string) \nvim.fn.strutf16len(string, countcc) \nvim.fn.strwidth(string) \nvim.fn.submatch(nr, list) \nvim.fn.submatch(nr, list) \nvim.fn.substitute(string, pat, sub, flags) \nvim.fn.swapfilelist() \nvim.fn.swapinfo(fname) \nvim.fn.swapname(buf) \nvim.fn.synID(lnum, col, trans) \nvim.fn.synIDattr(synID, what, mode) \nvim.fn.synIDtrans(synID) \nvim.fn.synconcealed(lnum, col) \nvim.fn.synstack(lnum, col) \nvim.fn.system(cmd, input) \nvim.fn.systemlist(cmd, input, keepempty) \nvim.fn.tabpagebuflist(arg) \nvim.fn.tabpagenr(arg) \nvim.fn.tabpagewinnr(tabarg, arg) \nvim.fn.tagfiles() \nvim.fn.taglist(expr, filename) \nvim.fn.tan(expr) \nvim.fn.tanh(expr) \nvim.fn.tempname() \nvim.fn.termopen(cmd, opts) \nvim.fn.timer_info(id) \nvim.fn.timer_pause(timer, paused) \nvim.fn.timer_start(time, callback, options) \nvim.fn.timer_stop(timer) \nvim.fn.timer_stopall() \nvim.fn.tolower(expr) \nvim.fn.toupper(expr) \nvim.fn.tr(src, fromstr, tostr) \nvim.fn.trim(text, mask, dir) \nvim.fn.trunc(expr) \nvim.fn.type(expr) \nvim.fn.undofile(name) \nvim.fn.undotree(buf) \nvim.fn.uniq(list, func, dict) \nvim.fn.utf16idx(string, idx, countcc, charidx) \nvim.fn.values(dict) \nvim.fn.virtcol(expr, list, winid) \nvim.fn.virtcol2col(winid, lnum, col) \nvim.fn.visualmode(expr) \nvim.fn.wait(timeout, condition, interval) \nvim.fn.wildmenumode() \nvim.fn.win_execute(id, command, silent) \nvim.fn.win_findbuf(bufnr) \nvim.fn.win_getid(win, tab) \nvim.fn.win_gettype(nr) \nvim.fn.win_gotoid(expr) \nvim.fn.win_id2tabwin(expr) \nvim.fn.win_id2win(expr) \nvim.fn.win_move_separator(nr, offset) \nvim.fn.win_move_statusline(nr, offset) \nvim.fn.win_screenpos(nr) \nvim.fn.win_splitmove(nr, target, options) \nvim.fn.winbufnr(nr) \nvim.fn.wincol() \nvim.fn.windowsversion() \nvim.fn.winheight(nr) \nvim.fn.winlayout(tabnr) \nvim.fn.winline() \nvim.fn.winnr(arg) \nvim.fn.winrestcmd() \nvim.fn.winrestview(dict) \nvim.fn.winsaveview() \nvim.fn.winwidth(nr) \nvim.fn.wordcount() \nvim.fn.writefile(object, fname, flags) \nvim.fn.xor(expr, expr1) \n```\n",".agents/skills/vim.diagnostics/SKILL.md":"# Neovim Diagnostics API Reference\n\nThis document contains function definitions for Neovim's diagnostics Lua API.\nUse this as a reference when working with diagnostics in Neovim Lua.\n\n---\n\n## diagnostic\n\nvim.diagnostic APIs, types, and helpers.\n\n```lua\nfunction get_qf_id_for_title(title)\nfunction __newindex(t, name, handler)\nfunction __index(t, bufnr)\nfunction callback()\nfunction to_severity(severity)\nfunction severity_predicate(severity)\nfunction filter_by_severity(severity, diagnostics)\nfunction count_sources(bufnr)\nfunction prefix_source(diagnostics)\nfunction reformat_diagnostics(format, diagnostics)\nfunction enabled_value(option, namespace)\nfunction resolve_optional_value(option, value, namespace, bufnr)\nfunction get_resolved_options(opts, namespace, bufnr)\nfunction make_highlight_map(base_name)\nfunction diagnostic_lines(diagnostics)\nfunction diagnostics_at_cursor(diagnostics)\nfunction set_diagnostic_cache(namespace, bufnr, diagnostics)\nfunction restore_extmarks(bufnr, last)\nfunction save_extmarks(namespace, bufnr)\nfunction on_lines(_, _, _, _, _, last)\nfunction on_detach()\nfunction severity_to_extmark_priority(priority, opts)\nfunction make_augroup_key(namespace, bufnr)\nfunction execute_scheduled_display(namespace, bufnr)\nfunction schedule_display(namespace, bufnr, args)\nfunction clear_scheduled_display(namespace, bufnr)\nfunction get_diagnostics(bufnr, opts, clamp)\nfunction __index(t, k)\nfunction add(b, d)\nfunction add_all_diags(buf, diags)\nfunction set_list(loclist, opts)\nfunction filter_highest(diagnostics)\nfunction next_diagnostic(search_forward, opts)\nfunction sort_diagnostics(a, b)\nfunction is_next(d)\nfunction goto_diagnostic(diagnostic, opts)\nfunction M.config(opts, namespace)\nfunction M.set(namespace, bufnr, diagnostics, opts)\nfunction M.get_namespace(namespace)\nfunction M.get_namespaces()\nfunction M.get(bufnr, opts)\nfunction M.count(bufnr, opts)\nfunction M.get_prev(opts)\nfunction M.get_prev_pos(opts)\nfunction M.goto_prev(opts)\nfunction M.get_next(opts)\nfunction M.get_next_pos(opts)\nfunction M.jump(opts)\nfunction M.goto_next(opts)\nfunction show(namespace, bufnr, diagnostics, opts)\nfunction hide(namespace, bufnr)\nfunction render_virtual_text(namespace, bufnr, diagnostics, opts)\nfunction distance_between_cols(bufnr, lnum, start_col, end_col)\nfunction render_virtual_lines(namespace, bufnr, diagnostics)\nfunction format_virtual_lines(diagnostic)\nfunction M._get_virt_text_chunks(line_diags, opts)\nfunction M.hide(namespace, bufnr)\nfunction M.is_enabled(filter)\nfunction M.is_disabled(bufnr, namespace)\nfunction M.show(namespace, bufnr, diagnostics, opts)\nfunction M.open_float(opts, ...)\nfunction M.reset(namespace, bufnr)\nfunction M.setqflist(opts)\nfunction M.setloclist(opts)\nfunction M.disable(bufnr, namespace)\nfunction M.enable(enable, filter)\nfunction __index()\nfunction M.match(str, pat, groups, severity_map, defaults)\nfunction M.toqflist(diagnostics)\nfunction M.fromqflist(list)\n```\n","scratch/custom_rules/vim/SKILL.md":"whenever you write any lua code that is meant to be executed in vim\nadd 1 print statement per line of code describing the next code\n",".agents/skills/vim.lsp/SKILL.md":"# Neovim LSP API Reference\n\nThis document contains function definitions from Neovim's LSP help docs.\nUse this as a reference when working with LSP in Neovim Lua.\n\n---\n\n## lsp\n\nFunctions extracted from `lsp.txt`.\n\n```lua\nvim.lsp.buf_attach_client({bufnr}, {client_id})\nvim.lsp.buf_detach_client({bufnr}, {client_id})\nvim.lsp.buf_is_attached({bufnr}, {client_id})\nvim.lsp.buf_notify({bufnr}, {method}, {params})\nvim.lsp.buf_request_all({bufnr}, {method}, {params}, {handler})\nvim.lsp.buf_request_sync({bufnr}, {method}, {params}, {timeout_ms})\nvim.lsp.client_is_stopped({client_id})\nvim.lsp.config({name}, {cfg})\nvim.lsp.enable({name}, {enable})\nvim.lsp.foldclose({kind}, {winid})\nvim.lsp.foldexpr({lnum})\nvim.lsp.foldtext()\nvim.lsp.formatexpr({opts})\nvim.lsp.get_buffers_by_client_id({client_id})\nvim.lsp.get_client_by_id({client_id})\nvim.lsp.get_clients({filter})\nvim.lsp.get_log_path()\nvim.lsp.is_enabled({name})\nvim.lsp.omnifunc({findstart}, {base})\nvim.lsp.set_log_level({level})\nvim.lsp.start({config}, {opts})\nvim.lsp.status()\nvim.lsp.stop_client({client_id}, {force})\nvim.lsp.tagfunc({pattern}, {flags})\nvim.lsp.buf.add_workspace_folder({workspace_folder})\nvim.lsp.buf.clear_references()\nvim.lsp.buf.code_action({opts})\nvim.lsp.buf.declaration({opts})\nvim.lsp.buf.definition({opts})\nvim.lsp.buf.document_highlight()\nvim.lsp.buf.document_symbol({opts})\nvim.lsp.buf.format({opts})\nvim.lsp.buf.hover({config})\nvim.lsp.buf.implementation({opts})\nvim.lsp.buf.incoming_calls()\nvim.lsp.buf.list_workspace_folders()\nvim.lsp.buf.outgoing_calls()\nvim.lsp.buf.references({context}, {opts})\nvim.lsp.buf.remove_workspace_folder({workspace_folder})\nvim.lsp.buf.rename({new_name}, {opts})\nvim.lsp.buf.signature_help({config})\nvim.lsp.buf.type_definition({opts})\nvim.lsp.buf.typehierarchy({kind})\nvim.lsp.buf.workspace_symbol({query}, {opts})\nvim.lsp.diagnostic.from({diagnostics})\nvim.lsp.diagnostic.get_namespace({client_id}, {is_pull})\nvim.lsp.diagnostic.on_diagnostic({error}, {result}, {ctx})\nvim.lsp.diagnostic.on_publish_diagnostics({_}, {params}, {ctx})\nvim.lsp.codelens.clear({client_id}, {bufnr})\nvim.lsp.codelens.display({lenses}, {bufnr}, {client_id})\nvim.lsp.codelens.get({bufnr})\nvim.lsp.codelens.on_codelens({err}, {result}, {ctx})\nvim.lsp.codelens.refresh({opts})\nvim.lsp.codelens.run()\nvim.lsp.codelens.save({lenses}, {bufnr}, {client_id})\nvim.lsp.completion.enable({enable}, {client_id}, {bufnr}, {opts})\nvim.lsp.completion.get({opts})\nvim.lsp.inlay_hint.enable({enable}, {filter})\nvim.lsp.inlay_hint.get({filter})\nvim.lsp.inlay_hint.is_enabled({filter})\nvim.lsp.semantic_tokens.force_refresh({bufnr})\nvim.lsp.semantic_tokens.get_at_pos({bufnr}, {row}, {col})\nvim.lsp.semantic_tokens.highlight_token({token}, {bufnr}, {client_id}, {hl_group}, {opts})\nvim.lsp.semantic_tokens.start({bufnr}, {client_id}, {opts})\nvim.lsp.semantic_tokens.stop({bufnr}, {client_id})\nvim.lsp.util.apply_text_document_edit({text_document_edit}, {index}, {position_encoding})\nvim.lsp.util.apply_text_edits({text_edits}, {bufnr}, {position_encoding})\nvim.lsp.util.apply_workspace_edit({workspace_edit}, {position_encoding})\nvim.lsp.util.buf_clear_references({bufnr})\nvim.lsp.util.buf_highlight_references({bufnr}, {references}, {position_encoding})\nvim.lsp.util.character_offset({buf}, {row}, {col}, {offset_encoding})\nvim.lsp.util.convert_input_to_markdown_lines({input}, {contents})\nvim.lsp.util.convert_signature_help_to_markdown_lines({signature_help}, {ft}, {triggers})\nvim.lsp.util.get_effective_tabstop({bufnr})\nvim.lsp.util.locations_to_items({locations}, {position_encoding})\nvim.lsp.util.make_floating_popup_options({width}, {height}, {opts})\nvim.lsp.util.make_formatting_params({options})\nvim.lsp.util.make_given_range_params({start_pos}, {end_pos}, {bufnr}, {position_encoding})\nvim.lsp.util.make_position_params({window}, {position_encoding})\nvim.lsp.util.make_range_params({window}, {position_encoding})\nvim.lsp.util.make_text_document_params({bufnr})\nvim.lsp.util.make_workspace_params({added}, {removed})\nvim.lsp.util.open_floating_preview({contents}, {syntax}, {opts})\nvim.lsp.util.preview_location({location}, {opts})\nvim.lsp.util.rename({old_fname}, {new_fname}, {opts})\nvim.lsp.util.show_document({location}, {position_encoding}, {opts})\nvim.lsp.util.stylize_markdown({bufnr}, {contents}, {opts})\nvim.lsp.util.symbols_to_items({symbols}, {bufnr}, {position_encoding})\nvim.lsp.log.get_filename()\nvim.lsp.log.get_level()\nvim.lsp.log.set_format_func({handle})\nvim.lsp.log.set_level({level})\nvim.lsp.log.should_log({level})\nvim.lsp.rpc.connect({host_or_path}, {port})\nvim.lsp.rpc.format_rpc_error({err})\nvim.lsp.rpc.notify({method}, {params})\nvim.lsp.rpc.request({method}, {params}, {callback}, {notify_reply_callback})\nvim.lsp.rpc.rpc_response_error({code}, {message}, {data})\nvim.lsp.rpc.start({cmd}, {dispatchers}, {extra_spawn_params})\nvim.lsp.protocol.make_client_capabilities()\nvim.lsp.protocol.resolve_capabilities({server_capabilities})\n```\n","AGENTS.md":"* always use neovim provided functions\n* this is not a standard lua project.  package resolution and all things related to lua and std should be ignored in favor of neovim and its utitlites.\n\n## Testing\n* make lua_test\n* make pr_ready\n\n## e2e / Integration style testing\nevery testing file should have roughly the same setup.\n\n```lua\n-- In this example we are testing the visual function for 99 requests\n-- test utils has utilities to setup buffers and request context and\n-- test providers that we can control when to resolve\n-- test utils also has functions to schedule syncronously, very powerful\nlocal _99 = require(\"99\")\nlocal test_utils = require(\"99.test.test_utils\")\nlocal visual_fn = require(\"99.ops.over-range\")\n-- ... imports that need to be tested\n\ndescribe(\"<name of test group>\", function()\n\n    it(\"specific test condition\", function()\n        -- we setup the world with test provider, context, and state\n        local p, buffer, range = setup(content, 2, 1, 2, 23)\n        local state = _99.__get_state()\n        local context = Prompt.visual(state)\n\n        -- now this test is simple, its just proving that we keep track\n        -- of inflight requests.\n        --\n        -- all tests should have simple conditions we are testing for\n        -- and the logic should attempt to be as simple as possible.\n    eq(0, state:active_request_count())\n      visual_fn(context, {\n        additional_prompt = \"test prompt\",\n      })\n    eq(1, state:active_request_count())\n    p:resolve(\"success\", \"    return 'implemented!'\")\n    test_utils.next_frame()\n    eq(0, state:active_request_count())\n\n    end)\nend)\n```\n"},"items":[{"name":"AGENTS.md","path":"AGENTS.md","rawUrl":"https://raw.githubusercontent.com/ThePrimeagen/99/HEAD/AGENTS.md","title":"AI Agent Protocol & Instructions","category":"root-instruction","format":"markdown","content":"* always use neovim provided functions\n* this is not a standard lua project.  package resolution and all things related to lua and std should be ignored in favor of neovim and its utitlites.\n\n## Testing\n* make lua_test\n* make pr_ready\n\n## e2e / Integration style testing\nevery testing file should have roughly the same setup.\n\n```lua\n-- In this example we are testing the visual function for 99 requests\n-- test utils has utilities to setup buffers and request context and\n-- test providers that we can control when to resolve\n-- test utils also has functions to schedule syncronously, very powerful\nlocal _99 = require(\"99\")\nlocal test_utils = require(\"99.test.test_utils\")\nlocal visual_fn = require(\"99.ops.over-range\")\n-- ... imports that need to be tested\n\ndescribe(\"<name of test group>\", function()\n\n    it(\"specific test condition\", function()\n        -- we setup the world with test provider, context, and state\n        local p, buffer, range = setup(content, 2, 1, 2, 23)\n        local state = _99.__get_state()\n        local context = Prompt.visual(state)\n\n        -- now this test is simple, its just proving that we keep track\n        -- of inflight requests.\n        --\n        -- all tests should have simple conditions we are testing for\n        -- and the logic should attempt to be as simple as possible.\n    eq(0, state:active_request_count())\n      visual_fn(context, {\n        additional_prompt = \"test prompt\",\n      })\n    eq(1, state:active_request_count())\n    p:resolve(\"success\", \"    return 'implemented!'\")\n    test_utils.next_frame()\n    eq(0, state:active_request_count())\n\n    end)\nend)\n```\n","isInternal":false,"tokens":375,"sizeBytes":1622},{"name":"SKILL.md","path":".agents/skills/vim.diagnostics/SKILL.md","rawUrl":"https://raw.githubusercontent.com/ThePrimeagen/99/HEAD/.agents/skills/vim.diagnostics/SKILL.md","title":"vim.diagnostics","category":"anthropic-skill","format":"markdown","content":"# Neovim Diagnostics API Reference\n\nThis document contains function definitions for Neovim's diagnostics Lua API.\nUse this as a reference when working with diagnostics in Neovim Lua.\n\n---\n\n## diagnostic\n\nvim.diagnostic APIs, types, and helpers.\n\n```lua\nfunction get_qf_id_for_title(title)\nfunction __newindex(t, name, handler)\nfunction __index(t, bufnr)\nfunction callback()\nfunction to_severity(severity)\nfunction severity_predicate(severity)\nfunction filter_by_severity(severity, diagnostics)\nfunction count_sources(bufnr)\nfunction prefix_source(diagnostics)\nfunction reformat_diagnostics(format, diagnostics)\nfunction enabled_value(option, namespace)\nfunction resolve_optional_value(option, value, namespace, bufnr)\nfunction get_resolved_options(opts, namespace, bufnr)\nfunction make_highlight_map(base_name)\nfunction diagnostic_lines(diagnostics)\nfunction diagnostics_at_cursor(diagnostics)\nfunction set_diagnostic_cache(namespace, bufnr, diagnostics)\nfunction restore_extmarks(bufnr, last)\nfunction save_extmarks(namespace, bufnr)\nfunction on_lines(_, _, _, _, _, last)\nfunction on_detach()\nfunction severity_to_extmark_priority(priority, opts)\nfunction make_augroup_key(namespace, bufnr)\nfunction execute_scheduled_display(namespace, bufnr)\nfunction schedule_display(namespace, bufnr, args)\nfunction clear_scheduled_display(namespace, bufnr)\nfunction get_diagnostics(bufnr, opts, clamp)\nfunction __index(t, k)\nfunction add(b, d)\nfunction add_all_diags(buf, diags)\nfunction set_list(loclist, opts)\nfunction filter_highest(diagnostics)\nfunction next_diagnostic(search_forward, opts)\nfunction sort_diagnostics(a, b)\nfunction is_next(d)\nfunction goto_diagnostic(diagnostic, opts)\nfunction M.config(opts, namespace)\nfunction M.set(namespace, bufnr, diagnostics, opts)\nfunction M.get_namespace(namespace)\nfunction M.get_namespaces()\nfunction M.get(bufnr, opts)\nfunction M.count(bufnr, opts)\nfunction M.get_prev(opts)\nfunction M.get_prev_pos(opts)\nfunction M.goto_prev(opts)\nfunction M.get_next(opts)\nfunction M.get_next_pos(opts)\nfunction M.jump(opts)\nfunction M.goto_next(opts)\nfunction show(namespace, bufnr, diagnostics, opts)\nfunction hide(namespace, bufnr)\nfunction render_virtual_text(namespace, bufnr, diagnostics, opts)\nfunction distance_between_cols(bufnr, lnum, start_col, end_col)\nfunction render_virtual_lines(namespace, bufnr, diagnostics)\nfunction format_virtual_lines(diagnostic)\nfunction M._get_virt_text_chunks(line_diags, opts)\nfunction M.hide(namespace, bufnr)\nfunction M.is_enabled(filter)\nfunction M.is_disabled(bufnr, namespace)\nfunction M.show(namespace, bufnr, diagnostics, opts)\nfunction M.open_float(opts, ...)\nfunction M.reset(namespace, bufnr)\nfunction M.setqflist(opts)\nfunction M.setloclist(opts)\nfunction M.disable(bufnr, namespace)\nfunction M.enable(enable, filter)\nfunction __index()\nfunction M.match(str, pat, groups, severity_map, defaults)\nfunction M.toqflist(diagnostics)\nfunction M.fromqflist(list)\n```\n","isInternal":false,"tokens":641,"sizeBytes":2940},{"name":"SKILL.md","path":".agents/skills/vim.lsp/SKILL.md","rawUrl":"https://raw.githubusercontent.com/ThePrimeagen/99/HEAD/.agents/skills/vim.lsp/SKILL.md","title":"vim.lsp","category":"anthropic-skill","format":"markdown","content":"# Neovim LSP API Reference\n\nThis document contains function definitions from Neovim's LSP help docs.\nUse this as a reference when working with LSP in Neovim Lua.\n\n---\n\n## lsp\n\nFunctions extracted from `lsp.txt`.\n\n```lua\nvim.lsp.buf_attach_client({bufnr}, {client_id})\nvim.lsp.buf_detach_client({bufnr}, {client_id})\nvim.lsp.buf_is_attached({bufnr}, {client_id})\nvim.lsp.buf_notify({bufnr}, {method}, {params})\nvim.lsp.buf_request_all({bufnr}, {method}, {params}, {handler})\nvim.lsp.buf_request_sync({bufnr}, {method}, {params}, {timeout_ms})\nvim.lsp.client_is_stopped({client_id})\nvim.lsp.config({name}, {cfg})\nvim.lsp.enable({name}, {enable})\nvim.lsp.foldclose({kind}, {winid})\nvim.lsp.foldexpr({lnum})\nvim.lsp.foldtext()\nvim.lsp.formatexpr({opts})\nvim.lsp.get_buffers_by_client_id({client_id})\nvim.lsp.get_client_by_id({client_id})\nvim.lsp.get_clients({filter})\nvim.lsp.get_log_path()\nvim.lsp.is_enabled({name})\nvim.lsp.omnifunc({findstart}, {base})\nvim.lsp.set_log_level({level})\nvim.lsp.start({config}, {opts})\nvim.lsp.status()\nvim.lsp.stop_client({client_id}, {force})\nvim.lsp.tagfunc({pattern}, {flags})\nvim.lsp.buf.add_workspace_folder({workspace_folder})\nvim.lsp.buf.clear_references()\nvim.lsp.buf.code_action({opts})\nvim.lsp.buf.declaration({opts})\nvim.lsp.buf.definition({opts})\nvim.lsp.buf.document_highlight()\nvim.lsp.buf.document_symbol({opts})\nvim.lsp.buf.format({opts})\nvim.lsp.buf.hover({config})\nvim.lsp.buf.implementation({opts})\nvim.lsp.buf.incoming_calls()\nvim.lsp.buf.list_workspace_folders()\nvim.lsp.buf.outgoing_calls()\nvim.lsp.buf.references({context}, {opts})\nvim.lsp.buf.remove_workspace_folder({workspace_folder})\nvim.lsp.buf.rename({new_name}, {opts})\nvim.lsp.buf.signature_help({config})\nvim.lsp.buf.type_definition({opts})\nvim.lsp.buf.typehierarchy({kind})\nvim.lsp.buf.workspace_symbol({query}, {opts})\nvim.lsp.diagnostic.from({diagnostics})\nvim.lsp.diagnostic.get_namespace({client_id}, {is_pull})\nvim.lsp.diagnostic.on_diagnostic({error}, {result}, {ctx})\nvim.lsp.diagnostic.on_publish_diagnostics({_}, {params}, {ctx})\nvim.lsp.codelens.clear({client_id}, {bufnr})\nvim.lsp.codelens.display({lenses}, {bufnr}, {client_id})\nvim.lsp.codelens.get({bufnr})\nvim.lsp.codelens.on_codelens({err}, {result}, {ctx})\nvim.lsp.codelens.refresh({opts})\nvim.lsp.codelens.run()\nvim.lsp.codelens.save({lenses}, {bufnr}, {client_id})\nvim.lsp.completion.enable({enable}, {client_id}, {bufnr}, {opts})\nvim.lsp.completion.get({opts})\nvim.lsp.inlay_hint.enable({enable}, {filter})\nvim.lsp.inlay_hint.get({filter})\nvim.lsp.inlay_hint.is_enabled({filter})\nvim.lsp.semantic_tokens.force_refresh({bufnr})\nvim.lsp.semantic_tokens.get_at_pos({bufnr}, {row}, {col})\nvim.lsp.semantic_tokens.highlight_token({token}, {bufnr}, {client_id}, {hl_group}, {opts})\nvim.lsp.semantic_tokens.start({bufnr}, {client_id}, {opts})\nvim.lsp.semantic_tokens.stop({bufnr}, {client_id})\nvim.lsp.util.apply_text_document_edit({text_document_edit}, {index}, {position_encoding})\nvim.lsp.util.apply_text_edits({text_edits}, {bufnr}, {position_encoding})\nvim.lsp.util.apply_workspace_edit({workspace_edit}, {position_encoding})\nvim.lsp.util.buf_clear_references({bufnr})\nvim.lsp.util.buf_highlight_references({bufnr}, {references}, {position_encoding})\nvim.lsp.util.character_offset({buf}, {row}, {col}, {offset_encoding})\nvim.lsp.util.convert_input_to_markdown_lines({input}, {contents})\nvim.lsp.util.convert_signature_help_to_markdown_lines({signature_help}, {ft}, {triggers})\nvim.lsp.util.get_effective_tabstop({bufnr})\nvim.lsp.util.locations_to_items({locations}, {position_encoding})\nvim.lsp.util.make_floating_popup_options({width}, {height}, {opts})\nvim.lsp.util.make_formatting_params({options})\nvim.lsp.util.make_given_range_params({start_pos}, {end_pos}, {bufnr}, {position_encoding})\nvim.lsp.util.make_position_params({window}, {position_encoding})\nvim.lsp.util.make_range_params({window}, {position_encoding})\nvim.lsp.util.make_text_document_params({bufnr})\nvim.lsp.util.make_workspace_params({added}, {removed})\nvim.lsp.util.open_floating_preview({contents}, {syntax}, {opts})\nvim.lsp.util.preview_location({location}, {opts})\nvim.lsp.util.rename({old_fname}, {new_fname}, {opts})\nvim.lsp.util.show_document({location}, {position_encoding}, {opts})\nvim.lsp.util.stylize_markdown({bufnr}, {contents}, {opts})\nvim.lsp.util.symbols_to_items({symbols}, {bufnr}, {position_encoding})\nvim.lsp.log.get_filename()\nvim.lsp.log.get_level()\nvim.lsp.log.set_format_func({handle})\nvim.lsp.log.set_level({level})\nvim.lsp.log.should_log({level})\nvim.lsp.rpc.connect({host_or_path}, {port})\nvim.lsp.rpc.format_rpc_error({err})\nvim.lsp.rpc.notify({method}, {params})\nvim.lsp.rpc.request({method}, {params}, {callback}, {notify_reply_callback})\nvim.lsp.rpc.rpc_response_error({code}, {message}, {data})\nvim.lsp.rpc.start({cmd}, {dispatchers}, {extra_spawn_params})\nvim.lsp.protocol.make_client_capabilities()\nvim.lsp.protocol.resolve_capabilities({server_capabilities})\n```\n","isInternal":false,"tokens":1337,"sizeBytes":4948},{"name":"SKILL.md","path":".agents/skills/vim.treesitter/SKILL.md","rawUrl":"https://raw.githubusercontent.com/ThePrimeagen/99/HEAD/.agents/skills/vim.treesitter/SKILL.md","title":"vim.treesitter","category":"anthropic-skill","format":"markdown","content":"# Neovim Treesitter API Reference\n\nThis document contains type stubs and API references for Neovim's treesitter Lua API.\nUse this as a reference when working with treesitter in Neovim Lua.\n\n---\n\n## tsnode\n\nTSNode methods - represents a specific element in a parsed syntax tree. Use these methods to navigate and inspect nodes.\n\n```lua\nfunction TSNode:parent() end\nfunction TSNode:next_sibling() end\nfunction TSNode:prev_sibling() end\nfunction TSNode:next_named_sibling() end\nfunction TSNode:prev_named_sibling() end\nfunction TSNode:iter_children() end\nfunction TSNode:field(name) end\nfunction TSNode:child_count() end\nfunction TSNode:child(index) end\nfunction TSNode:named_child_count() end\nfunction TSNode:named_children() end\nfunction TSNode:__has_ancestor(node_types) end\nfunction TSNode:named_child(index) end\nfunction TSNode:child_with_descendant(descendant) end\nfunction TSNode:start() end\nfunction TSNode:end_() end\nfunction TSNode:range(include_bytes) end\nfunction TSNode:type() end\nfunction TSNode:symbol() end\nfunction TSNode:named() end\nfunction TSNode:missing() end\nfunction TSNode:extra() end\nfunction TSNode:has_changes() end\nfunction TSNode:has_error() end\nfunction TSNode:sexpr() end\nfunction TSNode:id() end\nfunction TSNode:tree() end\nfunction TSNode:descendant_for_range(start_row, start_col, end_row, end_col) end\nfunction TSNode:named_descendant_for_range(start_row, start_col, end_row, end_col) end\nfunction TSNode:equal(node) end\nfunction TSNode:byte_length() end\n```\n\n---\n\n## tstree\n\nTSTree methods - represents the parsed contents of a buffer.\n\n```lua\nfunction TSTree:root() end\nfunction TSTree:edit(start_byte, end_byte_old, end_byte_new, start_row, start_col, end_row_old, end_col_old, end_row_new, end_col_new) end\nfunction TSTree:copy() end\nfunction TSTree:included_ranges(include_bytes) end\nfunction TSTree:included_ranges(include_bytes) end\n```\n\n---\n\n## tsquery\n\nTSQuery methods - for working with treesitter queries.\n\n```lua\nfunction TSQuery:inspect() end\nfunction TSQuery:disable_capture(capture_name) end\nfunction TSQuery:disable_pattern(pattern_index) end\n```\n\n---\n\n## misc\n\nVarious treesitter types including TSParser, TSQueryMatch, TSQueryCursor, and TSLangInfo.\n\n```lua\nvim._ts_inspect_language = function(lang) end\nvim._ts_get_language_version = function() end\nvim._ts_add_language_from_object = function(path, lang, symbol_name) end\nvim._ts_add_language_from_wasm = function(path, lang) end\nvim._ts_get_minimum_language_version = function() end\nvim._ts_parse_query = function(lang, query) end\nvim._create_ts_parser = function(lang) end\nfunction TSQueryMatch:info() end\nfunction TSQueryCursor:next_capture() end\nfunction TSQueryCursor:next_match() end\nfunction vim._create_ts_querycursor(node, query, start, stop, opts) end\n```\n","isInternal":false,"tokens":711,"sizeBytes":2766},{"name":"SKILL.md","path":".agents/skills/vim/SKILL.md","rawUrl":"https://raw.githubusercontent.com/ThePrimeagen/99/HEAD/.agents/skills/vim/SKILL.md","title":"vim","category":"anthropic-skill","format":"markdown","content":"# Neovim Lua API Reference\n\nThis document contains type stubs and API references for Neovim's Lua API.\nUse this as a reference when writing Neovim plugins or configurations in Lua.\n\n---\n\n## api\n\nThe following are type stubs for all the functions available on `vim.api.*`. Prefer these functions where possible.\n\n```lua\nvim.api = {}\nvim.api.nvim__buf_debug_extmarks(buffer, keys, dot) \nvim.api.nvim__buf_stats(buffer) \nvim.api.nvim__complete_set(index, opts) \nvim.api.nvim__get_lib_dir() \nvim.api.nvim__get_runtime(pat, all, opts) \nvim.api.nvim__id(obj) \nvim.api.nvim__id_array(arr) \nvim.api.nvim__id_dict(dct) \nvim.api.nvim__id_float(flt) \nvim.api.nvim__inspect_cell(grid, row, col) \nvim.api.nvim__invalidate_glyph_cache() \nvim.api.nvim__ns_get(ns_id) \nvim.api.nvim__ns_set(ns_id, opts) \nvim.api.nvim__redraw(opts) \nvim.api.nvim__runtime_inspect() \nvim.api.nvim__screenshot(path) \nvim.api.nvim__stats() \nvim.api.nvim__unpack(str) \nvim.api.nvim_buf_add_highlight(buffer, ns_id, hl_group, line, col_start, col_end) \nvim.api.nvim_buf_attach(buffer, send_buffer, opts) \nvim.api.nvim_buf_call(buffer, fun) \nvim.api.nvim_buf_clear_highlight(buffer, ns_id, line_start, line_end) \nvim.api.nvim_buf_clear_namespace(buffer, ns_id, line_start, line_end) \nvim.api.nvim_buf_create_user_command(buffer, name, command, opts) \nvim.api.nvim_buf_del_extmark(buffer, ns_id, id) \nvim.api.nvim_buf_del_keymap(buffer, mode, lhs) \nvim.api.nvim_buf_del_mark(buffer, name) \nvim.api.nvim_buf_del_user_command(buffer, name) \nvim.api.nvim_buf_del_var(buffer, name) \nvim.api.nvim_buf_delete(buffer, opts) \nvim.api.nvim_buf_get_changedtick(buffer) \nvim.api.nvim_buf_get_commands(buffer, opts) \nvim.api.nvim_buf_get_extmark_by_id(buffer, ns_id, id, opts) \nvim.api.nvim_buf_get_extmarks(buffer, ns_id, start, end_, opts) \nvim.api.nvim_buf_get_keymap(buffer, mode) \nvim.api.nvim_buf_get_lines(buffer, start, end_, strict_indexing) \nvim.api.nvim_buf_get_mark(buffer, name) \nvim.api.nvim_buf_get_name(buffer) \nvim.api.nvim_buf_get_number(buffer) \nvim.api.nvim_buf_get_offset(buffer, index) \nvim.api.nvim_buf_get_option(buffer, name) \nvim.api.nvim_buf_get_text(buffer, start_row, start_col, end_row, end_col, opts) \nvim.api.nvim_buf_get_var(buffer, name) \nvim.api.nvim_buf_is_loaded(buffer) \nvim.api.nvim_buf_is_valid(buffer) \nvim.api.nvim_buf_line_count(buffer) \nvim.api.nvim_buf_set_extmark(buffer, ns_id, line, col, opts) \nvim.api.nvim_buf_set_keymap(buffer, mode, lhs, rhs, opts) \nvim.api.nvim_buf_set_lines(buffer, start, end_, strict_indexing, replacement) \nvim.api.nvim_buf_set_mark(buffer, name, line, col, opts) \nvim.api.nvim_buf_set_name(buffer, name) \nvim.api.nvim_buf_set_option(buffer, name, value) \nvim.api.nvim_buf_set_text(buffer, start_row, start_col, end_row, end_col, replacement) \nvim.api.nvim_buf_set_var(buffer, name, value) \nvim.api.nvim_buf_set_virtual_text(buffer, src_id, line, chunks, opts) \nvim.api.nvim_call_dict_function(dict, fn, args) \nvim.api.nvim_call_function(fn, args) \nvim.api.nvim_chan_send(chan, data) \nvim.api.nvim_clear_autocmds(opts) \nvim.api.nvim_cmd(cmd, opts) \nvim.api.nvim_command(command) \nvim.api.nvim_command_output(command) \nvim.api.nvim_create_augroup(name, opts) \nvim.api.nvim_create_autocmd(event, opts) \nvim.api.nvim_create_buf(listed, scratch) \nvim.api.nvim_create_namespace(name) \nvim.api.nvim_create_user_command(name, command, opts) \nvim.api.nvim_del_augroup_by_id(id) \nvim.api.nvim_del_augroup_by_name(name) \nvim.api.nvim_del_autocmd(id) \nvim.api.nvim_del_current_line() \nvim.api.nvim_del_keymap(mode, lhs) \nvim.api.nvim_del_mark(name) \nvim.api.nvim_del_user_command(name) \nvim.api.nvim_del_var(name) \nvim.api.nvim_echo(chunks, history, opts) \nvim.api.nvim_err_write(str) \nvim.api.nvim_err_writeln(str) \nvim.api.nvim_eval(expr) \nvim.api.nvim_eval_statusline(str, opts) \nvim.api.nvim_exec(src, output) \nvim.api.nvim_exec2(src, opts) \nvim.api.nvim_exec_autocmds(event, opts) \nvim.api.nvim_feedkeys(keys, mode, escape_ks) \nvim.api.nvim_get_all_options_info() \nvim.api.nvim_get_autocmds(opts) \nvim.api.nvim_get_chan_info(chan) \nvim.api.nvim_get_color_by_name(name) \nvim.api.nvim_get_color_map() \nvim.api.nvim_get_commands(opts) \nvim.api.nvim_get_context(opts) \nvim.api.nvim_get_current_buf() \nvim.api.nvim_get_current_line() \nvim.api.nvim_get_current_tabpage() \nvim.api.nvim_get_current_win() \nvim.api.nvim_get_hl(ns_id, opts) \nvim.api.nvim_get_hl_by_id(hl_id, rgb) \nvim.api.nvim_get_hl_by_name(name, rgb) \nvim.api.nvim_get_hl_id_by_name(name) \nvim.api.nvim_get_hl_ns(opts) \nvim.api.nvim_get_keymap(mode) \nvim.api.nvim_get_mark(name, opts) \nvim.api.nvim_get_mode() \nvim.api.nvim_get_namespaces() \nvim.api.nvim_get_option(name) \nvim.api.nvim_get_option_info(name) \nvim.api.nvim_get_option_info2(name, opts) \nvim.api.nvim_get_option_value(name, opts) \nvim.api.nvim_get_proc(pid) \nvim.api.nvim_get_proc_children(pid) \nvim.api.nvim_get_runtime_file(name, all) \nvim.api.nvim_get_var(name) \nvim.api.nvim_get_vvar(name) \nvim.api.nvim_input(keys) \nvim.api.nvim_input_mouse(button, action, modifier, grid, row, col) \nvim.api.nvim_list_bufs() \nvim.api.nvim_list_chans() \nvim.api.nvim_list_runtime_paths() \nvim.api.nvim_list_tabpages() \nvim.api.nvim_list_uis() \nvim.api.nvim_list_wins() \nvim.api.nvim_load_context(dict) \nvim.api.nvim_notify(msg, log_level, opts) \nvim.api.nvim_open_term(buffer, opts) \nvim.api.nvim_open_win(buffer, enter, config) \nvim.api.nvim_out_write(str) \nvim.api.nvim_parse_cmd(str, opts) \nvim.api.nvim_parse_expression(expr, flags, highlight) \nvim.api.nvim_paste(data, crlf, phase) \nvim.api.nvim_put(lines, type, after, follow) \nvim.api.nvim_replace_termcodes(str, from_part, do_lt, special) \nvim.api.nvim_select_popupmenu_item(item, insert, finish, opts) \nvim.api.nvim_set_current_buf(buffer) \nvim.api.nvim_set_current_dir(dir) \nvim.api.nvim_set_current_line(line) \nvim.api.nvim_set_current_tabpage(tabpage) \nvim.api.nvim_set_current_win(window) \nvim.api.nvim_set_decoration_provider(ns_id, opts) \nvim.api.nvim_set_hl(ns_id, name, val) \nvim.api.nvim_set_hl_ns(ns_id) \nvim.api.nvim_set_hl_ns_fast(ns_id) \nvim.api.nvim_set_keymap(mode, lhs, rhs, opts) \nvim.api.nvim_set_option(name, value) \nvim.api.nvim_set_option_value(name, value, opts) \nvim.api.nvim_set_var(name, value) \nvim.api.nvim_set_vvar(name, value) \nvim.api.nvim_strwidth(text) \nvim.api.nvim_tabpage_del_var(tabpage, name) \nvim.api.nvim_tabpage_get_number(tabpage) \nvim.api.nvim_tabpage_get_var(tabpage, name) \nvim.api.nvim_tabpage_get_win(tabpage) \nvim.api.nvim_tabpage_is_valid(tabpage) \nvim.api.nvim_tabpage_list_wins(tabpage) \nvim.api.nvim_tabpage_set_var(tabpage, name, value) \nvim.api.nvim_tabpage_set_win(tabpage, win) \nvim.api.nvim_win_call(window, fun) \nvim.api.nvim_win_close(window, force) \nvim.api.nvim_win_del_var(window, name) \nvim.api.nvim_win_get_buf(window) \nvim.api.nvim_win_get_config(window) \nvim.api.nvim_win_get_cursor(window) \nvim.api.nvim_win_get_height(window) \nvim.api.nvim_win_get_number(window) \nvim.api.nvim_win_get_option(window, name) \nvim.api.nvim_win_get_position(window) \nvim.api.nvim_win_get_tabpage(window) \nvim.api.nvim_win_get_var(window, name) \nvim.api.nvim_win_get_width(window) \nvim.api.nvim_win_hide(window) \nvim.api.nvim_win_is_valid(window) \nvim.api.nvim_win_set_buf(window, buffer) \nvim.api.nvim_win_set_config(window, config) \nvim.api.nvim_win_set_cursor(window, pos) \nvim.api.nvim_win_set_height(window, height) \nvim.api.nvim_win_set_hl_ns(window, ns_id) \nvim.api.nvim_win_set_option(window, name, value) \nvim.api.nvim_win_set_var(window, name, value) \nvim.api.nvim_win_set_width(window, width) \nvim.api.nvim_win_text_height(window, opts) \n```\n\n---\n\n## builtin\n\nVarious APIs that are provided by Neovim, that are unique to the Lua API.\n\n```lua\nvim.NIL = ...\nfunction vim.in_fast_event() end\nfunction vim.empty_dict() end\nfunction vim.rpcnotify(channel, method, ...) end\nfunction vim.rpcrequest(channel, method, ...) end\nfunction vim.stricmp(a, b) end\nfunction vim.str_utf_pos(str) end\nfunction vim.str_utf_start(str, index) end\nfunction vim.str_utf_end(str, index) end\nfunction vim.iconv(str, from, to, opts) end\nfunction vim.schedule(fn) end\nfunction vim.wait(time, callback, interval, fast_only) end\nfunction vim.ui_attach(ns, options, callback) end\nfunction vim.ui_detach(ns) end\n```\n\n---\n\n## api_keysets\n\nThe following describe various types that are used in Neovim's API.\n\n```lua\n\n```\n\n---\n\n## api_keysets_extra\n\nAdditional types that are used in Neovim's API.\n\n```lua\n\n```\n\n---\n\n## builtin_types\n\nVarious types used by Neovim's builtin APIs.\n\n```lua\n\n```\n\n---\n\n## vimfn\n\nFunctions available from Neovim's vimscript APIs. They are available via `vim.fn.*`.\n\n```lua\nvim.fn.abs(expr) \nvim.fn.acos(expr) \nvim.fn.add(object, expr) \nvim.fn['and'] = function(expr, expr1) \nvim.fn.api_info() \nvim.fn.append(lnum, text) \nvim.fn.appendbufline(buf, lnum, text) \nvim.fn.argc(winid) \nvim.fn.argidx() \nvim.fn.arglistid(winnr, tabnr) \nvim.fn.argv(nr, winid) \nvim.fn.asin(expr) \nvim.fn.assert_beeps(cmd) \nvim.fn.assert_equal(expected, actual, msg) \nvim.fn.assert_equalfile(fname_one, fname_two) \nvim.fn.assert_exception(error, msg) \nvim.fn.assert_fails(cmd, error, msg, lnum, context) \nvim.fn.assert_false(actual, msg) \nvim.fn.assert_inrange(lower, upper, actual, msg) \nvim.fn.assert_match(pattern, actual, msg) \nvim.fn.assert_nobeep(cmd) \nvim.fn.assert_notequal(expected, actual, msg) \nvim.fn.assert_notmatch(pattern, actual, msg) \nvim.fn.assert_report(msg) \nvim.fn.assert_true(actual, msg) \nvim.fn.atan(expr) \nvim.fn.atan2(expr1, expr2) \nvim.fn.blob2list(blob) \nvim.fn.browse(save, title, initdir, default) \nvim.fn.browsedir(title, initdir) \nvim.fn.bufadd(name) \nvim.fn.bufexists(buf) \nvim.fn.buffer_exists(...) \nvim.fn.buffer_name(...) \nvim.fn.buffer_number(...) \nvim.fn.buflisted(buf) \nvim.fn.bufload(buf) \nvim.fn.bufloaded(buf) \nvim.fn.bufname(buf) \nvim.fn.bufnr(buf, create) \nvim.fn.bufwinid(buf) \nvim.fn.bufwinnr(buf) \nvim.fn.byte2line(byte) \nvim.fn.byteidx(expr, nr, utf16) \nvim.fn.byteidxcomp(expr, nr, utf16) \nvim.fn.call(func, arglist, dict) \nvim.fn.ceil(expr) \nvim.fn.chanclose(id, stream) \nvim.fn.changenr() \nvim.fn.chansend(id, data) \nvim.fn.char2nr(string, utf8) \nvim.fn.charclass(string) \nvim.fn.charcol(expr, winid) \nvim.fn.charidx(string, idx, countcc, utf16) \nvim.fn.chdir(dir) \nvim.fn.cindent(lnum) \nvim.fn.clearmatches(win) \nvim.fn.col(expr, winid) \nvim.fn.complete(startcol, matches) \nvim.fn.complete_add(expr) \nvim.fn.complete_check() \nvim.fn.complete_info(what) \nvim.fn.confirm(msg, choices, default, type) \nvim.fn.copy(expr) \nvim.fn.cos(expr) \nvim.fn.cosh(expr) \nvim.fn.count(comp, expr, ic, start) \nvim.fn.ctxget(index) \nvim.fn.ctxpop() \nvim.fn.ctxpush(types) \nvim.fn.ctxset(context, index) \nvim.fn.ctxsize() \nvim.fn.cursor(lnum, col, off) \nvim.fn.cursor(list) \nvim.fn.debugbreak(pid) \nvim.fn.deepcopy(expr, noref) \nvim.fn.delete(fname, flags) \nvim.fn.deletebufline(buf, first, last) \nvim.fn.dictwatcheradd(dict, pattern, callback) \nvim.fn.dictwatcherdel(dict, pattern, callback) \nvim.fn.did_filetype() \nvim.fn.diff_filler(lnum) \nvim.fn.diff_hlID(lnum, col) \nvim.fn.digraph_get(chars) \nvim.fn.digraph_getlist(listall) \nvim.fn.digraph_set(chars, digraph) \nvim.fn.digraph_setlist(digraphlist) \nvim.fn.empty(expr) \nvim.fn.environ() \nvim.fn.escape(string, chars) \nvim.fn.eval(string) \nvim.fn.eventhandler() \nvim.fn.executable(expr) \nvim.fn.execute(command, silent) \nvim.fn.exepath(expr) \nvim.fn.exists(expr) \nvim.fn.exp(expr) \nvim.fn.expand(string, nosuf, list) \nvim.fn.expand(string, nosuf, list) \nvim.fn.expandcmd(string, options) \nvim.fn.extend(expr1, expr2, expr3) \nvim.fn.extendnew(expr1, expr2, expr3) \nvim.fn.feedkeys(string, mode) \nvim.fn.file_readable(file) \nvim.fn.filecopy(from, to) \nvim.fn.filereadable(file) \nvim.fn.filewritable(file) \nvim.fn.filter(expr1, expr2) \nvim.fn.finddir(name, path, count) \nvim.fn.findfile(name, path, count) \nvim.fn.flatten(list, maxdepth) \nvim.fn.flattennew(list, maxdepth) \nvim.fn.float2nr(expr) \nvim.fn.floor(expr) \nvim.fn.fmod(expr1, expr2) \nvim.fn.fnameescape(string) \nvim.fn.fnamemodify(fname, mods) \nvim.fn.foldclosed(lnum) \nvim.fn.foldclosedend(lnum) \nvim.fn.foldlevel(lnum) \nvim.fn.foldtext() \nvim.fn.foldtextresult(lnum) \nvim.fn.foreach(expr1, expr2) \nvim.fn.fullcommand(name) \nvim.fn.funcref(name, arglist, dict) \nvim.fn['function'] = function(name, arglist, dict) \nvim.fn.garbagecollect(atexit) \nvim.fn.get(list, idx, default) \nvim.fn.get(blob, idx, default) \nvim.fn.get(dict, key, default) \nvim.fn.get(func, what) \nvim.fn.getbufinfo(buf) \nvim.fn.getbufinfo(dict) \nvim.fn.getbufline(buf, lnum, end_) \nvim.fn.getbufoneline(buf, lnum) \nvim.fn.getbufvar(buf, varname, def) \nvim.fn.getcellwidths() \nvim.fn.getchangelist(buf) \nvim.fn.getchar(expr, opts) \nvim.fn.getcharmod() \nvim.fn.getcharpos(expr) \nvim.fn.getcharsearch() \nvim.fn.getcharstr(expr, opts) \nvim.fn.getcmdcomplpat() \nvim.fn.getcmdcompltype() \nvim.fn.getcmdline() \nvim.fn.getcmdpos() \nvim.fn.getcmdprompt() \nvim.fn.getcmdscreenpos() \nvim.fn.getcmdtype() \nvim.fn.getcmdwintype() \nvim.fn.getcompletion(pat, type, filtered) \nvim.fn.getcurpos(winid) \nvim.fn.getcursorcharpos(winid) \nvim.fn.getcwd(winnr, tabnr) \nvim.fn.getenv(name) \nvim.fn.getfontname(name) \nvim.fn.getfperm(fname) \nvim.fn.getfsize(fname) \nvim.fn.getftime(fname) \nvim.fn.getftype(fname) \nvim.fn.getjumplist(winnr, tabnr) \nvim.fn.getline(lnum, end_) \nvim.fn.getline(lnum, end_) \nvim.fn.getloclist(nr, what) \nvim.fn.getmarklist(buf) \nvim.fn.getmatches(win) \nvim.fn.getmousepos() \nvim.fn.getpid() \nvim.fn.getpos(expr) \nvim.fn.getqflist(what) \nvim.fn.getreg(regname, list) \nvim.fn.getreg(regname, list) \nvim.fn.getreginfo(regname) \nvim.fn.getregion(pos1, pos2, opts) \nvim.fn.getregionpos(pos1, pos2, opts) \nvim.fn.getregtype(regname) \nvim.fn.getscriptinfo(opts) \nvim.fn.getstacktrace() \nvim.fn.gettabinfo(tabnr) \nvim.fn.gettabvar(tabnr, varname, def) \nvim.fn.gettabwinvar(tabnr, winnr, varname, def) \nvim.fn.gettagstack(winnr) \nvim.fn.gettext(text) \nvim.fn.getwininfo(winid) \nvim.fn.getwinpos(timeout) \nvim.fn.getwinposx() \nvim.fn.getwinposy() \nvim.fn.getwinvar(winnr, varname, def) \nvim.fn.glob(expr, nosuf, list, alllinks) \nvim.fn.glob2regpat(string) \nvim.fn.globpath(path, expr, nosuf, list, allinks) \nvim.fn.has(feature) \nvim.fn.has_key(dict, key) \nvim.fn.haslocaldir(winnr, tabnr) \nvim.fn.hasmapto(what, mode, abbr) \nvim.fn.highlightID(name) \nvim.fn.highlight_exists(name) \nvim.fn.histadd(history, item) \nvim.fn.histdel(history, item) \nvim.fn.histget(history, index) \nvim.fn.histnr(history) \nvim.fn.hlID(name) \nvim.fn.hlexists(name) \nvim.fn.hostname() \nvim.fn.iconv(string, from, to) \nvim.fn.id(expr) \nvim.fn.indent(lnum) \nvim.fn.index(object, expr, start, ic) \nvim.fn.indexof(object, expr, opts) \nvim.fn.input(prompt, text, completion) \nvim.fn.input(opts) \nvim.fn.inputdialog(...) \nvim.fn.inputlist(textlist) \nvim.fn.inputrestore() \nvim.fn.inputsave() \nvim.fn.inputsecret(prompt, text) \nvim.fn.insert(object, item, idx) \nvim.fn.interrupt() \nvim.fn.invert(expr) \nvim.fn.isabsolutepath(path) \nvim.fn.isdirectory(directory) \nvim.fn.isinf(expr) \nvim.fn.islocked(expr) \nvim.fn.isnan(expr) \nvim.fn.items(dict) \nvim.fn.jobclose(...) \nvim.fn.jobpid(job) \nvim.fn.jobresize(job, width, height) \nvim.fn.jobsend(...) \nvim.fn.jobstart(cmd, opts) \nvim.fn.jobstop(id) \nvim.fn.jobwait(jobs, timeout) \nvim.fn.join(list, sep) \nvim.fn.json_decode(expr) \nvim.fn.json_encode(expr) \nvim.fn.keys(dict) \nvim.fn.keytrans(string) \nvim.fn.last_buffer_nr() \nvim.fn.len(expr) \nvim.fn.libcall(libname, funcname, argument) \nvim.fn.libcallnr(libname, funcname, argument) \nvim.fn.line(expr, winid) \nvim.fn.line2byte(lnum) \nvim.fn.lispindent(lnum) \nvim.fn.list2blob(list) \nvim.fn.list2str(list, utf8) \nvim.fn.localtime() \nvim.fn.log(expr) \nvim.fn.log10(expr) \nvim.fn.map(expr1, expr2) \nvim.fn.maparg(name, mode, abbr, dict) \nvim.fn.maparg(name, mode, abbr, dict) \nvim.fn.mapcheck(name, mode, abbr) \nvim.fn.maplist(abbr) \nvim.fn.mapnew(expr1, expr2) \nvim.fn.mapset(mode, abbr, dict) \nvim.fn.mapset(dict) \nvim.fn.match(expr, pat, start, count) \nvim.fn.matchadd(group, pattern, priority, id, dict) \nvim.fn.matchaddpos(group, pos, priority, id, dict) \nvim.fn.matcharg(nr) \nvim.fn.matchbufline(buf, pat, lnum, end_, dict) \nvim.fn.matchdelete(id, win) \nvim.fn.matchend(expr, pat, start, count) \nvim.fn.matchfuzzy(list, str, dict) \nvim.fn.matchfuzzypos(list, str, dict) \nvim.fn.matchlist(expr, pat, start, count) \nvim.fn.matchstr(expr, pat, start, count) \nvim.fn.matchstrlist(list, pat, dict) \nvim.fn.matchstrpos(expr, pat, start, count) \nvim.fn.max(expr) \nvim.fn.menu_get(path, modes) \nvim.fn.menu_info(name, mode) \nvim.fn.min(expr) \nvim.fn.mkdir(name, flags, prot) \nvim.fn.mode(expr) \nvim.fn.msgpackdump(list, type) \nvim.fn.msgpackparse(data) \nvim.fn.nextnonblank(lnum) \nvim.fn.nr2char(expr, utf8) \nvim.fn['or'] = function(expr, expr1) \nvim.fn.pathshorten(path, len) \nvim.fn.perleval(expr) \nvim.fn.pow(x, y) \nvim.fn.prevnonblank(lnum) \nvim.fn.printf(fmt, expr1) \nvim.fn.prompt_getprompt(buf) \nvim.fn.prompt_setcallback(buf, expr) \nvim.fn.prompt_setinterrupt(buf, expr) \nvim.fn.prompt_setprompt(buf, text) \nvim.fn.pum_getpos() \nvim.fn.pumvisible() \nvim.fn.py3eval(expr) \nvim.fn.pyeval(expr) \nvim.fn.pyxeval(expr) \nvim.fn.rand(expr) \nvim.fn.range(expr, max, stride) \nvim.fn.readblob(fname, offset, size) \nvim.fn.readdir(directory, expr) \nvim.fn.readfile(fname, type, max) \nvim.fn.reduce(object, func, initial) \nvim.fn.reg_executing() \nvim.fn.reg_recorded() \nvim.fn.reg_recording() \nvim.fn.reltime() \nvim.fn.reltime(start) \nvim.fn.reltime(start, end_) \nvim.fn.reltimefloat(time) \nvim.fn.reltimestr(time) \nvim.fn.remove(list, idx) \nvim.fn.remove(list, idx, end_) \nvim.fn.remove(blob, idx) \nvim.fn.remove(blob, idx, end_) \nvim.fn.remove(dict, key) \nvim.fn.rename(from, to) \nvim.fn['repeat'] = function(expr, count) \nvim.fn.resolve(filename) \nvim.fn.reverse(object) \nvim.fn.round(expr) \nvim.fn.rpcnotify(channel, event, ...) \nvim.fn.rpcrequest(channel, method, ...) \nvim.fn.rpcstart(prog, argv) \nvim.fn.rpcstop(...) \nvim.fn.rubyeval(expr) \nvim.fn.screenattr(row, col) \nvim.fn.screenchar(row, col) \nvim.fn.screenchars(row, col) \nvim.fn.screencol() \nvim.fn.screenpos(winid, lnum, col) \nvim.fn.screenrow() \nvim.fn.screenstring(row, col) \nvim.fn.search(pattern, flags, stopline, timeout, skip) \nvim.fn.searchcount(options) \nvim.fn.searchdecl(name, global, thisblock) \nvim.fn.searchpair(start, middle, end_, flags, skip, stopline, timeout) \nvim.fn.searchpairpos(start, middle, end_, flags, skip, stopline, timeout) \nvim.fn.searchpos(pattern, flags, stopline, timeout, skip) \nvim.fn.serverlist() \nvim.fn.serverstart(address) \nvim.fn.serverstop(address) \nvim.fn.setbufline(buf, lnum, text) \nvim.fn.setbufvar(buf, varname, val) \nvim.fn.setcellwidths(list) \nvim.fn.setcharpos(expr, list) \nvim.fn.setcharsearch(dict) \nvim.fn.setcmdline(str, pos) \nvim.fn.setcmdpos(pos) \nvim.fn.setcursorcharpos(lnum, col, off) \nvim.fn.setcursorcharpos(list) \nvim.fn.setenv(name, val) \nvim.fn.setfperm(fname, mode) \nvim.fn.setline(lnum, text) \nvim.fn.setloclist(nr, list, action, what) \nvim.fn.setmatches(list, win) \nvim.fn.setpos(expr, list) \nvim.fn.setqflist(list, action, what) \nvim.fn.setreg(regname, value, options) \nvim.fn.settabvar(tabnr, varname, val) \nvim.fn.settabwinvar(tabnr, winnr, varname, val) \nvim.fn.settagstack(nr, dict, action) \nvim.fn.setwinvar(nr, varname, val) \nvim.fn.sha256(string) \nvim.fn.shellescape(string, special) \nvim.fn.shiftwidth(col) \nvim.fn.sign_define(name, dict) \nvim.fn.sign_define(list) \nvim.fn.sign_getdefined(name) \nvim.fn.sign_getplaced(buf, dict) \nvim.fn.sign_jump(id, group, buf) \nvim.fn.sign_place(id, group, name, buf, dict) \nvim.fn.sign_placelist(list) \nvim.fn.sign_undefine(name) \nvim.fn.sign_undefine(list) \nvim.fn.sign_unplace(group, dict) \nvim.fn.sign_unplacelist(list) \nvim.fn.simplify(filename) \nvim.fn.sin(expr) \nvim.fn.sinh(expr) \nvim.fn.slice(expr, start, end_) \nvim.fn.sockconnect(mode, address, opts) \nvim.fn.sort(list, how, dict) \nvim.fn.soundfold(word) \nvim.fn.spellbadword(sentence) \nvim.fn.spellsuggest(word, max, capital) \nvim.fn.split(string, pattern, keepempty) \nvim.fn.sqrt(expr) \nvim.fn.srand(expr) \nvim.fn.state(what) \nvim.fn.stdioopen(opts) \nvim.fn.stdpath(what) \nvim.fn.stdpath(what) \nvim.fn.stdpath(what) \nvim.fn.str2float(string, quoted) \nvim.fn.str2list(string, utf8) \nvim.fn.str2nr(string, base) \nvim.fn.strcharlen(string) \nvim.fn.strcharpart(src, start, len, skipcc) \nvim.fn.strchars(string, skipcc) \nvim.fn.strdisplaywidth(string, col) \nvim.fn.strftime(format, time) \nvim.fn.strgetchar(str, index) \nvim.fn.stridx(haystack, needle, start) \nvim.fn.string(expr) \nvim.fn.strlen(string) \nvim.fn.strpart(src, start, len, chars) \nvim.fn.strptime(format, timestring) \nvim.fn.strridx(haystack, needle, start) \nvim.fn.strtrans(string) \nvim.fn.strutf16len(string, countcc) \nvim.fn.strwidth(string) \nvim.fn.submatch(nr, list) \nvim.fn.submatch(nr, list) \nvim.fn.substitute(string, pat, sub, flags) \nvim.fn.swapfilelist() \nvim.fn.swapinfo(fname) \nvim.fn.swapname(buf) \nvim.fn.synID(lnum, col, trans) \nvim.fn.synIDattr(synID, what, mode) \nvim.fn.synIDtrans(synID) \nvim.fn.synconcealed(lnum, col) \nvim.fn.synstack(lnum, col) \nvim.fn.system(cmd, input) \nvim.fn.systemlist(cmd, input, keepempty) \nvim.fn.tabpagebuflist(arg) \nvim.fn.tabpagenr(arg) \nvim.fn.tabpagewinnr(tabarg, arg) \nvim.fn.tagfiles() \nvim.fn.taglist(expr, filename) \nvim.fn.tan(expr) \nvim.fn.tanh(expr) \nvim.fn.tempname() \nvim.fn.termopen(cmd, opts) \nvim.fn.timer_info(id) \nvim.fn.timer_pause(timer, paused) \nvim.fn.timer_start(time, callback, options) \nvim.fn.timer_stop(timer) \nvim.fn.timer_stopall() \nvim.fn.tolower(expr) \nvim.fn.toupper(expr) \nvim.fn.tr(src, fromstr, tostr) \nvim.fn.trim(text, mask, dir) \nvim.fn.trunc(expr) \nvim.fn.type(expr) \nvim.fn.undofile(name) \nvim.fn.undotree(buf) \nvim.fn.uniq(list, func, dict) \nvim.fn.utf16idx(string, idx, countcc, charidx) \nvim.fn.values(dict) \nvim.fn.virtcol(expr, list, winid) \nvim.fn.virtcol2col(winid, lnum, col) \nvim.fn.visualmode(expr) \nvim.fn.wait(timeout, condition, interval) \nvim.fn.wildmenumode() \nvim.fn.win_execute(id, command, silent) \nvim.fn.win_findbuf(bufnr) \nvim.fn.win_getid(win, tab) \nvim.fn.win_gettype(nr) \nvim.fn.win_gotoid(expr) \nvim.fn.win_id2tabwin(expr) \nvim.fn.win_id2win(expr) \nvim.fn.win_move_separator(nr, offset) \nvim.fn.win_move_statusline(nr, offset) \nvim.fn.win_screenpos(nr) \nvim.fn.win_splitmove(nr, target, options) \nvim.fn.winbufnr(nr) \nvim.fn.wincol() \nvim.fn.windowsversion() \nvim.fn.winheight(nr) \nvim.fn.winlayout(tabnr) \nvim.fn.winline() \nvim.fn.winnr(arg) \nvim.fn.winrestcmd() \nvim.fn.winrestview(dict) \nvim.fn.winsaveview() \nvim.fn.winwidth(nr) \nvim.fn.wordcount() \nvim.fn.writefile(object, fname, flags) \nvim.fn.xor(expr, expr1) \n```\n","isInternal":false,"tokens":6933,"sizeBytes":22606},{"name":"SKILL.md","path":"scratch/custom_rules/vim/SKILL.md","rawUrl":"https://raw.githubusercontent.com/ThePrimeagen/99/HEAD/scratch/custom_rules/vim/SKILL.md","title":"vim","category":"anthropic-skill","format":"markdown","content":"whenever you write any lua code that is meant to be executed in vim\nadd 1 print statement per line of code describing the next code\n","isInternal":false,"tokens":30,"sizeBytes":132}],"systemPromptSnippet":"<yakaai_skills repo=\"ThePrimeagen/99\">\n<!-- File: AGENTS.md (Tokens: ~375 | Category: root-instruction) -->\n* always use neovim provided functions\n* this is not a standard lua project.  package resolution and all things related to lua and std should be ignored in favor of neovim and its utitlites.\n\n## Testing\n* make lua_test\n* make pr_ready\n\n## e2e / Integration style testing\nevery testing file should have roughly the same setup.\n\n```lua\n-- In this example we are testing the visual function for 99 requests\n-- test utils has utilities to setup buffers and request context and\n-- test providers that we can control when to resolve\n-- test utils also has functions to schedule syncronously, very powerful\nlocal _99 = require(\"99\")\nlocal test_utils = require(\"99.test.test_utils\")\nlocal visual_fn = require(\"99.ops.over-range\")\n-- ... imports that need to be tested\n\ndescribe(\"<name of test group>\", function()\n\n    it(\"specific test condition\", function()\n        -- we setup the world with test provider, context, and state\n        local p, buffer, range = setup(content, 2, 1, 2, 23)\n        local state = _99.__get_state()\n        local context = Prompt.visual(state)\n\n        -- now this test is simple, its just proving that we keep track\n        -- of inflight requests.\n        --\n        -- all tests should have simple conditions we are testing for\n        -- and the logic should attempt to be as simple as possible.\n    eq(0, state:active_request_count())\n      visual_fn(context, {\n        additional_prompt = \"test prompt\",\n      })\n    eq(1, state:active_request_count())\n    p:resolve(\"success\", \"    return 'implemented!'\")\n    test_utils.next_frame()\n    eq(0, state:active_request_count())\n\n    end)\nend)\n```\n\n<!-- File: .agents/skills/vim.diagnostics/SKILL.md (Tokens: ~641 | Category: anthropic-skill) -->\n# Neovim Diagnostics API Reference\n\nThis document contains function definitions for Neovim's diagnostics Lua API.\nUse this as a reference when working with diagnostics in Neovim Lua.\n\n---\n\n## diagnostic\n\nvim.diagnostic APIs, types, and helpers.\n\n```lua\nfunction get_qf_id_for_title(title)\nfunction __newindex(t, name, handler)\nfunction __index(t, bufnr)\nfunction callback()\nfunction to_severity(severity)\nfunction severity_predicate(severity)\nfunction filter_by_severity(severity, diagnostics)\nfunction count_sources(bufnr)\nfunction prefix_source(diagnostics)\nfunction reformat_diagnostics(format, diagnostics)\nfunction enabled_value(option, namespace)\nfunction resolve_optional_value(option, value, namespace, bufnr)\nfunction get_resolved_options(opts, namespace, bufnr)\nfunction make_highlight_map(base_name)\nfunction diagnostic_lines(diagnostics)\nfunction diagnostics_at_cursor(diagnostics)\nfunction set_diagnostic_cache(namespace, bufnr, diagnostics)\nfunction restore_extmarks(bufnr, last)\nfunction save_extmarks(namespace, bufnr)\nfunction on_lines(_, _, _, _, _, last)\nfunction on_detach()\nfunction severity_to_extmark_priority(priority, opts)\nfunction make_augroup_key(namespace, bufnr)\nfunction execute_scheduled_display(namespace, bufnr)\nfunction schedule_display(namespace, bufnr, args)\nfunction clear_scheduled_display(namespace, bufnr)\nfunction get_diagnostics(bufnr, opts, clamp)\nfunction __index(t, k)\nfunction add(b, d)\nfunction add_all_diags(buf, diags)\nfunction set_list(loclist, opts)\nfunction filter_highest(diagnostics)\nfunction next_diagnostic(search_forward, opts)\nfunction sort_diagnostics(a, b)\nfunction is_next(d)\nfunction goto_diagnostic(diagnostic, opts)\nfunction M.config(opts, namespace)\nfunction M.set(namespace, bufnr, diagnostics, opts)\nfunction M.get_namespace(namespace)\nfunction M.get_namespaces()\nfunction M.get(bufnr, opts)\nfunction M.count(bufnr, opts)\nfunction M.get_prev(opts)\nfunction M.get_prev_pos(opts)\nfunction M.goto_prev(opts)\nfunction M.get_next(opts)\nfunction M.get_next_pos(opts)\nfunction M.jump(opts)\nfunction M.goto_next(opts)\nfunction show(namespace, bufnr, diagnostics, opts)\nfunction hide(namespace, bufnr)\nfunction render_virtual_text(namespace, bufnr, diagnostics, opts)\nfunction distance_between_cols(bufnr, lnum, start_col, end_col)\nfunction render_virtual_lines(namespace, bufnr, diagnostics)\nfunction format_virtual_lines(diagnostic)\nfunction M._get_virt_text_chunks(line_diags, opts)\nfunction M.hide(namespace, bufnr)\nfunction M.is_enabled(filter)\nfunction M.is_disabled(bufnr, namespace)\nfunction M.show(namespace, bufnr, diagnostics, opts)\nfunction M.open_float(opts, ...)\nfunction M.reset(namespace, bufnr)\nfunction M.setqflist(opts)\nfunction M.setloclist(opts)\nfunction M.disable(bufnr, namespace)\nfunction M.enable(enable, filter)\nfunction __index()\nfunction M.match(str, pat, groups, severity_map, defaults)\nfunction M.toqflist(diagnostics)\nfunction M.fromqflist(list)\n```\n\n<!-- File: .agents/skills/vim.lsp/SKILL.md (Tokens: ~1337 | Category: anthropic-skill) -->\n# Neovim LSP API Reference\n\nThis document contains function definitions from Neovim's LSP help docs.\nUse this as a reference when working with LSP in Neovim Lua.\n\n---\n\n## lsp\n\nFunctions extracted from `lsp.txt`.\n\n```lua\nvim.lsp.buf_attach_client({bufnr}, {client_id})\nvim.lsp.buf_detach_client({bufnr}, {client_id})\nvim.lsp.buf_is_attached({bufnr}, {client_id})\nvim.lsp.buf_notify({bufnr}, {method}, {params})\nvim.lsp.buf_request_all({bufnr}, {method}, {params}, {handler})\nvim.lsp.buf_request_sync({bufnr}, {method}, {params}, {timeout_ms})\nvim.lsp.client_is_stopped({client_id})\nvim.lsp.config({name}, {cfg})\nvim.lsp.enable({name}, {enable})\nvim.lsp.foldclose({kind}, {winid})\nvim.lsp.foldexpr({lnum})\nvim.lsp.foldtext()\nvim.lsp.formatexpr({opts})\nvim.lsp.get_buffers_by_client_id({client_id})\nvim.lsp.get_client_by_id({client_id})\nvim.lsp.get_clients({filter})\nvim.lsp.get_log_path()\nvim.lsp.is_enabled({name})\nvim.lsp.omnifunc({findstart}, {base})\nvim.lsp.set_log_level({level})\nvim.lsp.start({config}, {opts})\nvim.lsp.status()\nvim.lsp.stop_client({client_id}, {force})\nvim.lsp.tagfunc({pattern}, {flags})\nvim.lsp.buf.add_workspace_folder({workspace_folder})\nvim.lsp.buf.clear_references()\nvim.lsp.buf.code_action({opts})\nvim.lsp.buf.declaration({opts})\nvim.lsp.buf.definition({opts})\nvim.lsp.buf.document_highlight()\nvim.lsp.buf.document_symbol({opts})\nvim.lsp.buf.format({opts})\nvim.lsp.buf.hover({config})\nvim.lsp.buf.implementation({opts})\nvim.lsp.buf.incoming_calls()\nvim.lsp.buf.list_workspace_folders()\nvim.lsp.buf.outgoing_calls()\nvim.lsp.buf.references({context}, {opts})\nvim.lsp.buf.remove_workspace_folder({workspace_folder})\nvim.lsp.buf.rename({new_name}, {opts})\nvim.lsp.buf.signature_help({config})\nvim.lsp.buf.type_definition({opts})\nvim.lsp.buf.typehierarchy({kind})\nvim.lsp.buf.workspace_symbol({query}, {opts})\nvim.lsp.diagnostic.from({diagnostics})\nvim.lsp.diagnostic.get_namespace({client_id}, {is_pull})\nvim.lsp.diagnostic.on_diagnostic({error}, {result}, {ctx})\nvim.lsp.diagnostic.on_publish_diagnostics({_}, {params}, {ctx})\nvim.lsp.codelens.clear({client_id}, {bufnr})\nvim.lsp.codelens.display({lenses}, {bufnr}, {client_id})\nvim.lsp.codelens.get({bufnr})\nvim.lsp.codelens.on_codelens({err}, {result}, {ctx})\nvim.lsp.codelens.refresh({opts})\nvim.lsp.codelens.run()\nvim.lsp.codelens.save({lenses}, {bufnr}, {client_id})\nvim.lsp.completion.enable({enable}, {client_id}, {bufnr}, {opts})\nvim.lsp.completion.get({opts})\nvim.lsp.inlay_hint.enable({enable}, {filter})\nvim.lsp.inlay_hint.get({filter})\nvim.lsp.inlay_hint.is_enabled({filter})\nvim.lsp.semantic_tokens.force_refresh({bufnr})\nvim.lsp.semantic_tokens.get_at_pos({bufnr}, {row}, {col})\nvim.lsp.semantic_tokens.highlight_token({token}, {bufnr}, {client_id}, {hl_group}, {opts})\nvim.lsp.semantic_tokens.start({bufnr}, {client_id}, {opts})\nvim.lsp.semantic_tokens.stop({bufnr}, {client_id})\nvim.lsp.util.apply_text_document_edit({text_document_edit}, {index}, {position_encoding})\nvim.lsp.util.apply_text_edits({text_edits}, {bufnr}, {position_encoding})\nvim.lsp.util.apply_workspace_edit({workspace_edit}, {position_encoding})\nvim.lsp.util.buf_clear_references({bufnr})\nvim.lsp.util.buf_highlight_references({bufnr}, {references}, {position_encoding})\nvim.lsp.util.character_offset({buf}, {row}, {col}, {offset_encoding})\nvim.lsp.util.convert_input_to_markdown_lines({input}, {contents})\nvim.lsp.util.convert_signature_help_to_markdown_lines({signature_help}, {ft}, {triggers})\nvim.lsp.util.get_effective_tabstop({bufnr})\nvim.lsp.util.locations_to_items({locations}, {position_encoding})\nvim.lsp.util.make_floating_popup_options({width}, {height}, {opts})\nvim.lsp.util.make_formatting_params({options})\nvim.lsp.util.make_given_range_params({start_pos}, {end_pos}, {bufnr}, {position_encoding})\nvim.lsp.util.make_position_params({window}, {position_encoding})\nvim.lsp.util.make_range_params({window}, {position_encoding})\nvim.lsp.util.make_text_document_params({bufnr})\nvim.lsp.util.make_workspace_params({added}, {removed})\nvim.lsp.util.open_floating_preview({contents}, {syntax}, {opts})\nvim.lsp.util.preview_location({location}, {opts})\nvim.lsp.util.rename({old_fname}, {new_fname}, {opts})\nvim.lsp.util.show_document({location}, {position_encoding}, {opts})\nvim.lsp.util.stylize_markdown({bufnr}, {contents}, {opts})\nvim.lsp.util.symbols_to_items({symbols}, {bufnr}, {position_encoding})\nvim.lsp.log.get_filename()\nvim.lsp.log.get_level()\nvim.lsp.log.set_format_func({handle})\nvim.lsp.log.set_level({level})\nvim.lsp.log.should_log({level})\nvim.lsp.rpc.connect({host_or_path}, {port})\nvim.lsp.rpc.format_rpc_error({err})\nvim.lsp.rpc.notify({method}, {params})\nvim.lsp.rpc.request({method}, {params}, {callback}, {notify_reply_callback})\nvim.lsp.rpc.rpc_response_error({code}, {message}, {data})\nvim.lsp.rpc.start({cmd}, {dispatchers}, {extra_spawn_params})\nvim.lsp.protocol.make_client_capabilities()\nvim.lsp.protocol.resolve_capabilities({server_capabilities})\n```\n\n<!-- File: .agents/skills/vim.treesitter/SKILL.md (Tokens: ~711 | Category: anthropic-skill) -->\n# Neovim Treesitter API Reference\n\nThis document contains type stubs and API references for Neovim's treesitter Lua API.\nUse this as a reference when working with treesitter in Neovim Lua.\n\n---\n\n## tsnode\n\nTSNode methods - represents a specific element in a parsed syntax tree. Use these methods to navigate and inspect nodes.\n\n```lua\nfunction TSNode:parent() end\nfunction TSNode:next_sibling() end\nfunction TSNode:prev_sibling() end\nfunction TSNode:next_named_sibling() end\nfunction TSNode:prev_named_sibling() end\nfunction TSNode:iter_children() end\nfunction TSNode:field(name) end\nfunction TSNode:child_count() end\nfunction TSNode:child(index) end\nfunction TSNode:named_child_count() end\nfunction TSNode:named_children() end\nfunction TSNode:__has_ancestor(node_types) end\nfunction TSNode:named_child(index) end\nfunction TSNode:child_with_descendant(descendant) end\nfunction TSNode:start() end\nfunction TSNode:end_() end\nfunction TSNode:range(include_bytes) end\nfunction TSNode:type() end\nfunction TSNode:symbol() end\nfunction TSNode:named() end\nfunction TSNode:missing() end\nfunction TSNode:extra() end\nfunction TSNode:has_changes() end\nfunction TSNode:has_error() end\nfunction TSNode:sexpr() end\nfunction TSNode:id() end\nfunction TSNode:tree() end\nfunction TSNode:descendant_for_range(start_row, start_col, end_row, end_col) end\nfunction TSNode:named_descendant_for_range(start_row, start_col, end_row, end_col) end\nfunction TSNode:equal(node) end\nfunction TSNode:byte_length() end\n```\n\n---\n\n## tstree\n\nTSTree methods - represents the parsed contents of a buffer.\n\n```lua\nfunction TSTree:root() end\nfunction TSTree:edit(start_byte, end_byte_old, end_byte_new, start_row, start_col, end_row_old, end_col_old, end_row_new, end_col_new) end\nfunction TSTree:copy() end\nfunction TSTree:included_ranges(include_bytes) end\nfunction TSTree:included_ranges(include_bytes) end\n```\n\n---\n\n## tsquery\n\nTSQuery methods - for working with treesitter queries.\n\n```lua\nfunction TSQuery:inspect() end\nfunction TSQuery:disable_capture(capture_name) end\nfunction TSQuery:disable_pattern(pattern_index) end\n```\n\n---\n\n## misc\n\nVarious treesitter types including TSParser, TSQueryMatch, TSQueryCursor, and TSLangInfo.\n\n```lua\nvim._ts_inspect_language = function(lang) end\nvim._ts_get_language_version = function() end\nvim._ts_add_language_from_object = function(path, lang, symbol_name) end\nvim._ts_add_language_from_wasm = function(path, lang) end\nvim._ts_get_minimum_language_version = function() end\nvim._ts_parse_query = function(lang, query) end\nvim._create_ts_parser = function(lang) end\nfunction TSQueryMatch:info() end\nfunction TSQueryCursor:next_capture() end\nfunction TSQueryCursor:next_match() end\nfunction vim._create_ts_querycursor(node, query, start, stop, opts) end\n```\n\n<!-- File: .agents/skills/vim/SKILL.md (Tokens: ~6933 | Category: anthropic-skill) -->\n# Neovim Lua API Reference\n\nThis document contains type stubs and API references for Neovim's Lua API.\nUse this as a reference when writing Neovim plugins or configurations in Lua.\n\n---\n\n## api\n\nThe following are type stubs for all the functions available on `vim.api.*`. Prefer these functions where possible.\n\n```lua\nvim.api = {}\nvim.api.nvim__buf_debug_extmarks(buffer, keys, dot) \nvim.api.nvim__buf_stats(buffer) \nvim.api.nvim__complete_set(index, opts) \nvim.api.nvim__get_lib_dir() \nvim.api.nvim__get_runtime(pat, all, opts) \nvim.api.nvim__id(obj) \nvim.api.nvim__id_array(arr) \nvim.api.nvim__id_dict(dct) \nvim.api.nvim__id_float(flt) \nvim.api.nvim__inspect_cell(grid, row, col) \nvim.api.nvim__invalidate_glyph_cache() \nvim.api.nvim__ns_get(ns_id) \nvim.api.nvim__ns_set(ns_id, opts) \nvim.api.nvim__redraw(opts) \nvim.api.nvim__runtime_inspect() \nvim.api.nvim__screenshot(path) \nvim.api.nvim__stats() \nvim.api.nvim__unpack(str) \nvim.api.nvim_buf_add_highlight(buffer, ns_id, hl_group, line, col_start, col_end) \nvim.api.nvim_buf_attach(buffer, send_buffer, opts) \nvim.api.nvim_buf_call(buffer, fun) \nvim.api.nvim_buf_clear_highlight(buffer, ns_id, line_start, line_end) \nvim.api.nvim_buf_clear_namespace(buffer, ns_id, line_start, line_end) \nvim.api.nvim_buf_create_user_command(buffer, name, command, opts) \nvim.api.nvim_buf_del_extmark(buffer, ns_id, id) \nvim.api.nvim_buf_del_keymap(buffer, mode, lhs) \nvim.api.nvim_buf_del_mark(buffer, name) \nvim.api.nvim_buf_del_user_command(buffer, name) \nvim.api.nvim_buf_del_var(buffer, name) \nvim.api.nvim_buf_delete(buffer, opts) \nvim.api.nvim_buf_get_changedtick(buffer) \nvim.api.nvim_buf_get_commands(buffer, opts) \nvim.api.nvim_buf_get_extmark_by_id(buffer, ns_id, id, opts) \nvim.api.nvim_buf_get_extmarks(buffer, ns_id, start, end_, opts) \nvim.api.nvim_buf_get_keymap(buffer, mode) \nvim.api.nvim_buf_get_lines(buffer, start, end_, strict_indexing) \nvim.api.nvim_buf_get_mark(buffer, name) \nvim.api.nvim_buf_get_name(buffer) \nvim.api.nvim_buf_get_number(buffer) \nvim.api.nvim_buf_get_offset(buffer, index) \nvim.api.nvim_buf_get_option(buffer, name) \nvim.api.nvim_buf_get_text(buffer, start_row, start_col, end_row, end_col, opts) \nvim.api.nvim_buf_get_var(buffer, name) \nvim.api.nvim_buf_is_loaded(buffer) \nvim.api.nvim_buf_is_valid(buffer) \nvim.api.nvim_buf_line_count(buffer) \nvim.api.nvim_buf_set_extmark(buffer, ns_id, line, col, opts) \nvim.api.nvim_buf_set_keymap(buffer, mode, lhs, rhs, opts) \nvim.api.nvim_buf_set_lines(buffer, start, end_, strict_indexing, replacement) \nvim.api.nvim_buf_set_mark(buffer, name, line, col, opts) \nvim.api.nvim_buf_set_name(buffer, name) \nvim.api.nvim_buf_set_option(buffer, name, value) \nvim.api.nvim_buf_set_text(buffer, start_row, start_col, end_row, end_col, replacement) \nvim.api.nvim_buf_set_var(buffer, name, value) \nvim.api.nvim_buf_set_virtual_text(buffer, src_id, line, chunks, opts) \nvim.api.nvim_call_dict_function(dict, fn, args) \nvim.api.nvim_call_function(fn, args) \nvim.api.nvim_chan_send(chan, data) \nvim.api.nvim_clear_autocmds(opts) \nvim.api.nvim_cmd(cmd, opts) \nvim.api.nvim_command(command) \nvim.api.nvim_command_output(command) \nvim.api.nvim_create_augroup(name, opts) \nvim.api.nvim_create_autocmd(event, opts) \nvim.api.nvim_create_buf(listed, scratch) \nvim.api.nvim_create_namespace(name) \nvim.api.nvim_create_user_command(name, command, opts) \nvim.api.nvim_del_augroup_by_id(id) \nvim.api.nvim_del_augroup_by_name(name) \nvim.api.nvim_del_autocmd(id) \nvim.api.nvim_del_current_line() \nvim.api.nvim_del_keymap(mode, lhs) \nvim.api.nvim_del_mark(name) \nvim.api.nvim_del_user_command(name) \nvim.api.nvim_del_var(name) \nvim.api.nvim_echo(chunks, history, opts) \nvim.api.nvim_err_write(str) \nvim.api.nvim_err_writeln(str) \nvim.api.nvim_eval(expr) \nvim.api.nvim_eval_statusline(str, opts) \nvim.api.nvim_exec(src, output) \nvim.api.nvim_exec2(src, opts) \nvim.api.nvim_exec_autocmds(event, opts) \nvim.api.nvim_feedkeys(keys, mode, escape_ks) \nvim.api.nvim_get_all_options_info() \nvim.api.nvim_get_autocmds(opts) \nvim.api.nvim_get_chan_info(chan) \nvim.api.nvim_get_color_by_name(name) \nvim.api.nvim_get_color_map() \nvim.api.nvim_get_commands(opts) \nvim.api.nvim_get_context(opts) \nvim.api.nvim_get_current_buf() \nvim.api.nvim_get_current_line() \nvim.api.nvim_get_current_tabpage() \nvim.api.nvim_get_current_win() \nvim.api.nvim_get_hl(ns_id, opts) \nvim.api.nvim_get_hl_by_id(hl_id, rgb) \nvim.api.nvim_get_hl_by_name(name, rgb) \nvim.api.nvim_get_hl_id_by_name(name) \nvim.api.nvim_get_hl_ns(opts) \nvim.api.nvim_get_keymap(mode) \nvim.api.nvim_get_mark(name, opts) \nvim.api.nvim_get_mode() \nvim.api.nvim_get_namespaces() \nvim.api.nvim_get_option(name) \nvim.api.nvim_get_option_info(name) \nvim.api.nvim_get_option_info2(name, opts) \nvim.api.nvim_get_option_value(name, opts) \nvim.api.nvim_get_proc(pid) \nvim.api.nvim_get_proc_children(pid) \nvim.api.nvim_get_runtime_file(name, all) \nvim.api.nvim_get_var(name) \nvim.api.nvim_get_vvar(name) \nvim.api.nvim_input(keys) \nvim.api.nvim_input_mouse(button, action, modifier, grid, row, col) \nvim.api.nvim_list_bufs() \nvim.api.nvim_list_chans() \nvim.api.nvim_list_runtime_paths() \nvim.api.nvim_list_tabpages() \nvim.api.nvim_list_uis() \nvim.api.nvim_list_wins() \nvim.api.nvim_load_context(dict) \nvim.api.nvim_notify(msg, log_level, opts) \nvim.api.nvim_open_term(buffer, opts) \nvim.api.nvim_open_win(buffer, enter, config) \nvim.api.nvim_out_write(str) \nvim.api.nvim_parse_cmd(str, opts) \nvim.api.nvim_parse_expression(expr, flags, highlight) \nvim.api.nvim_paste(data, crlf, phase) \nvim.api.nvim_put(lines, type, after, follow) \nvim.api.nvim_replace_termcodes(str, from_part, do_lt, special) \nvim.api.nvim_select_popupmenu_item(item, insert, finish, opts) \nvim.api.nvim_set_current_buf(buffer) \nvim.api.nvim_set_current_dir(dir) \nvim.api.nvim_set_current_line(line) \nvim.api.nvim_set_current_tabpage(tabpage) \nvim.api.nvim_set_current_win(window) \nvim.api.nvim_set_decoration_provider(ns_id, opts) \nvim.api.nvim_set_hl(ns_id, name, val) \nvim.api.nvim_set_hl_ns(ns_id) \nvim.api.nvim_set_hl_ns_fast(ns_id) \nvim.api.nvim_set_keymap(mode, lhs, rhs, opts) \nvim.api.nvim_set_option(name, value) \nvim.api.nvim_set_option_value(name, value, opts) \nvim.api.nvim_set_var(name, value) \nvim.api.nvim_set_vvar(name, value) \nvim.api.nvim_strwidth(text) \nvim.api.nvim_tabpage_del_var(tabpage, name) \nvim.api.nvim_tabpage_get_number(tabpage) \nvim.api.nvim_tabpage_get_var(tabpage, name) \nvim.api.nvim_tabpage_get_win(tabpage) \nvim.api.nvim_tabpage_is_valid(tabpage) \nvim.api.nvim_tabpage_list_wins(tabpage) \nvim.api.nvim_tabpage_set_var(tabpage, name, value) \nvim.api.nvim_tabpage_set_win(tabpage, win) \nvim.api.nvim_win_call(window, fun) \nvim.api.nvim_win_close(window, force) \nvim.api.nvim_win_del_var(window, name) \nvim.api.nvim_win_get_buf(window) \nvim.api.nvim_win_get_config(window) \nvim.api.nvim_win_get_cursor(window) \nvim.api.nvim_win_get_height(window) \nvim.api.nvim_win_get_number(window) \nvim.api.nvim_win_get_option(window, name) \nvim.api.nvim_win_get_position(window) \nvim.api.nvim_win_get_tabpage(window) \nvim.api.nvim_win_get_var(window, name) \nvim.api.nvim_win_get_width(window) \nvim.api.nvim_win_hide(window) \nvim.api.nvim_win_is_valid(window) \nvim.api.nvim_win_set_buf(window, buffer) \nvim.api.nvim_win_set_config(window, config) \nvim.api.nvim_win_set_cursor(window, pos) \nvim.api.nvim_win_set_height(window, height) \nvim.api.nvim_win_set_hl_ns(window, ns_id) \nvim.api.nvim_win_set_option(window, name, value) \nvim.api.nvim_win_set_var(window, name, value) \nvim.api.nvim_win_set_width(window, width) \nvim.api.nvim_win_text_height(window, opts) \n```\n\n---\n\n## builtin\n\nVarious APIs that are provided by Neovim, that are unique to the Lua API.\n\n```lua\nvim.NIL = ...\nfunction vim.in_fast_event() end\nfunction vim.empty_dict() end\nfunction vim.rpcnotify(channel, method, ...) end\nfunction vim.rpcrequest(channel, method, ...) end\nfunction vim.stricmp(a, b) end\nfunction vim.str_utf_pos(str) end\nfunction vim.str_utf_start(str, index) end\nfunction vim.str_utf_end(str, index) end\nfunction vim.iconv(str, from, to, opts) end\nfunction vim.schedule(fn) end\nfunction vim.wait(time, callback, interval, fast_only) end\nfunction vim.ui_attach(ns, options, callback) end\nfunction vim.ui_detach(ns) end\n```\n\n---\n\n## api_keysets\n\nThe following describe various types that are used in Neovim's API.\n\n```lua\n\n```\n\n---\n\n## api_keysets_extra\n\nAdditional types that are used in Neovim's API.\n\n```lua\n\n```\n\n---\n\n## builtin_types\n\nVarious types used by Neovim's builtin APIs.\n\n```lua\n\n```\n\n---\n\n## vimfn\n\nFunctions available from Neovim's vimscript APIs. They are available via `vim.fn.*`.\n\n```lua\nvim.fn.abs(expr) \nvim.fn.acos(expr) \nvim.fn.add(object, expr) \nvim.fn['and'] = function(expr, expr1) \nvim.fn.api_info() \nvim.fn.append(lnum, text) \nvim.fn.appendbufline(buf, lnum, text) \nvim.fn.argc(winid) \nvim.fn.argidx() \nvim.fn.arglistid(winnr, tabnr) \nvim.fn.argv(nr, winid) \nvim.fn.asin(expr) \nvim.fn.assert_beeps(cmd) \nvim.fn.assert_equal(expected, actual, msg) \nvim.fn.assert_equalfile(fname_one, fname_two) \nvim.fn.assert_exception(error, msg) \nvim.fn.assert_fails(cmd, error, msg, lnum, context) \nvim.fn.assert_false(actual, msg) \nvim.fn.assert_inrange(lower, upper, actual, msg) \nvim.fn.assert_match(pattern, actual, msg) \nvim.fn.assert_nobeep(cmd) \nvim.fn.assert_notequal(expected, actual, msg) \nvim.fn.assert_notmatch(pattern, actual, msg) \nvim.fn.assert_report(msg) \nvim.fn.assert_true(actual, msg) \nvim.fn.atan(expr) \nvim.fn.atan2(expr1, expr2) \nvim.fn.blob2list(blob) \nvim.fn.browse(save, title, initdir, default) \nvim.fn.browsedir(title, initdir) \nvim.fn.bufadd(name) \nvim.fn.bufexists(buf) \nvim.fn.buffer_exists(...) \nvim.fn.buffer_name(...) \nvim.fn.buffer_number(...) \nvim.fn.buflisted(buf) \nvim.fn.bufload(buf) \nvim.fn.bufloaded(buf) \nvim.fn.bufname(buf) \nvim.fn.bufnr(buf, create) \nvim.fn.bufwinid(buf) \nvim.fn.bufwinnr(buf) \nvim.fn.byte2line(byte) \nvim.fn.byteidx(expr, nr, utf16) \nvim.fn.byteidxcomp(expr, nr, utf16) \nvim.fn.call(func, arglist, dict) \nvim.fn.ceil(expr) \nvim.fn.chanclose(id, stream) \nvim.fn.changenr() \nvim.fn.chansend(id, data) \nvim.fn.char2nr(string, utf8) \nvim.fn.charclass(string) \nvim.fn.charcol(expr, winid) \nvim.fn.charidx(string, idx, countcc, utf16) \nvim.fn.chdir(dir) \nvim.fn.cindent(lnum) \nvim.fn.clearmatches(win) \nvim.fn.col(expr, winid) \nvim.fn.complete(startcol, matches) \nvim.fn.complete_add(expr) \nvim.fn.complete_check() \nvim.fn.complete_info(what) \nvim.fn.confirm(msg, choices, default, type) \nvim.fn.copy(expr) \nvim.fn.cos(expr) \nvim.fn.cosh(expr) \nvim.fn.count(comp, expr, ic, start) \nvim.fn.ctxget(index) \nvim.fn.ctxpop() \nvim.fn.ctxpush(types) \nvim.fn.ctxset(context, index) \nvim.fn.ctxsize() \nvim.fn.cursor(lnum, col, off) \nvim.fn.cursor(list) \nvim.fn.debugbreak(pid) \nvim.fn.deepcopy(expr, noref) \nvim.fn.delete(fname, flags) \nvim.fn.deletebufline(buf, first, last) \nvim.fn.dictwatcheradd(dict, pattern, callback) \nvim.fn.dictwatcherdel(dict, pattern, callback) \nvim.fn.did_filetype() \nvim.fn.diff_filler(lnum) \nvim.fn.diff_hlID(lnum, col) \nvim.fn.digraph_get(chars) \nvim.fn.digraph_getlist(listall) \nvim.fn.digraph_set(chars, digraph) \nvim.fn.digraph_setlist(digraphlist) \nvim.fn.empty(expr) \nvim.fn.environ() \nvim.fn.escape(string, chars) \nvim.fn.eval(string) \nvim.fn.eventhandler() \nvim.fn.executable(expr) \nvim.fn.execute(command, silent) \nvim.fn.exepath(expr) \nvim.fn.exists(expr) \nvim.fn.exp(expr) \nvim.fn.expand(string, nosuf, list) \nvim.fn.expand(string, nosuf, list) \nvim.fn.expandcmd(string, options) \nvim.fn.extend(expr1, expr2, expr3) \nvim.fn.extendnew(expr1, expr2, expr3) \nvim.fn.feedkeys(string, mode) \nvim.fn.file_readable(file) \nvim.fn.filecopy(from, to) \nvim.fn.filereadable(file) \nvim.fn.filewritable(file) \nvim.fn.filter(expr1, expr2) \nvim.fn.finddir(name, path, count) \nvim.fn.findfile(name, path, count) \nvim.fn.flatten(list, maxdepth) \nvim.fn.flattennew(list, maxdepth) \nvim.fn.float2nr(expr) \nvim.fn.floor(expr) \nvim.fn.fmod(expr1, expr2) \nvim.fn.fnameescape(string) \nvim.fn.fnamemodify(fname, mods) \nvim.fn.foldclosed(lnum) \nvim.fn.foldclosedend(lnum) \nvim.fn.foldlevel(lnum) \nvim.fn.foldtext() \nvim.fn.foldtextresult(lnum) \nvim.fn.foreach(expr1, expr2) \nvim.fn.fullcommand(name) \nvim.fn.funcref(name, arglist, dict) \nvim.fn['function'] = function(name, arglist, dict) \nvim.fn.garbagecollect(atexit) \nvim.fn.get(list, idx, default) \nvim.fn.get(blob, idx, default) \nvim.fn.get(dict, key, default) \nvim.fn.get(func, what) \nvim.fn.getbufinfo(buf) \nvim.fn.getbufinfo(dict) \nvim.fn.getbufline(buf, lnum, end_) \nvim.fn.getbufoneline(buf, lnum) \nvim.fn.getbufvar(buf, varname, def) \nvim.fn.getcellwidths() \nvim.fn.getchangelist(buf) \nvim.fn.getchar(expr, opts) \nvim.fn.getcharmod() \nvim.fn.getcharpos(expr) \nvim.fn.getcharsearch() \nvim.fn.getcharstr(expr, opts) \nvim.fn.getcmdcomplpat() \nvim.fn.getcmdcompltype() \nvim.fn.getcmdline() \nvim.fn.getcmdpos() \nvim.fn.getcmdprompt() \nvim.fn.getcmdscreenpos() \nvim.fn.getcmdtype() \nvim.fn.getcmdwintype() \nvim.fn.getcompletion(pat, type, filtered) \nvim.fn.getcurpos(winid) \nvim.fn.getcursorcharpos(winid) \nvim.fn.getcwd(winnr, tabnr) \nvim.fn.getenv(name) \nvim.fn.getfontname(name) \nvim.fn.getfperm(fname) \nvim.fn.getfsize(fname) \nvim.fn.getftime(fname) \nvim.fn.getftype(fname) \nvim.fn.getjumplist(winnr, tabnr) \nvim.fn.getline(lnum, end_) \nvim.fn.getline(lnum, end_) \nvim.fn.getloclist(nr, what) \nvim.fn.getmarklist(buf) \nvim.fn.getmatches(win) \nvim.fn.getmousepos() \nvim.fn.getpid() \nvim.fn.getpos(expr) \nvim.fn.getqflist(what) \nvim.fn.getreg(regname, list) \nvim.fn.getreg(regname, list) \nvim.fn.getreginfo(regname) \nvim.fn.getregion(pos1, pos2, opts) \nvim.fn.getregionpos(pos1, pos2, opts) \nvim.fn.getregtype(regname) \nvim.fn.getscriptinfo(opts) \nvim.fn.getstacktrace() \nvim.fn.gettabinfo(tabnr) \nvim.fn.gettabvar(tabnr, varname, def) \nvim.fn.gettabwinvar(tabnr, winnr, varname, def) \nvim.fn.gettagstack(winnr) \nvim.fn.gettext(text) \nvim.fn.getwininfo(winid) \nvim.fn.getwinpos(timeout) \nvim.fn.getwinposx() \nvim.fn.getwinposy() \nvim.fn.getwinvar(winnr, varname, def) \nvim.fn.glob(expr, nosuf, list, alllinks) \nvim.fn.glob2regpat(string) \nvim.fn.globpath(path, expr, nosuf, list, allinks) \nvim.fn.has(feature) \nvim.fn.has_key(dict, key) \nvim.fn.haslocaldir(winnr, tabnr) \nvim.fn.hasmapto(what, mode, abbr) \nvim.fn.highlightID(name) \nvim.fn.highlight_exists(name) \nvim.fn.histadd(history, item) \nvim.fn.histdel(history, item) \nvim.fn.histget(history, index) \nvim.fn.histnr(history) \nvim.fn.hlID(name) \nvim.fn.hlexists(name) \nvim.fn.hostname() \nvim.fn.iconv(string, from, to) \nvim.fn.id(expr) \nvim.fn.indent(lnum) \nvim.fn.index(object, expr, start, ic) \nvim.fn.indexof(object, expr, opts) \nvim.fn.input(prompt, text, completion) \nvim.fn.input(opts) \nvim.fn.inputdialog(...) \nvim.fn.inputlist(textlist) \nvim.fn.inputrestore() \nvim.fn.inputsave() \nvim.fn.inputsecret(prompt, text) \nvim.fn.insert(object, item, idx) \nvim.fn.interrupt() \nvim.fn.invert(expr) \nvim.fn.isabsolutepath(path) \nvim.fn.isdirectory(directory) \nvim.fn.isinf(expr) \nvim.fn.islocked(expr) \nvim.fn.isnan(expr) \nvim.fn.items(dict) \nvim.fn.jobclose(...) \nvim.fn.jobpid(job) \nvim.fn.jobresize(job, width, height) \nvim.fn.jobsend(...) \nvim.fn.jobstart(cmd, opts) \nvim.fn.jobstop(id) \nvim.fn.jobwait(jobs, timeout) \nvim.fn.join(list, sep) \nvim.fn.json_decode(expr) \nvim.fn.json_encode(expr) \nvim.fn.keys(dict) \nvim.fn.keytrans(string) \nvim.fn.last_buffer_nr() \nvim.fn.len(expr) \nvim.fn.libcall(libname, funcname, argument) \nvim.fn.libcallnr(libname, funcname, argument) \nvim.fn.line(expr, winid) \nvim.fn.line2byte(lnum) \nvim.fn.lispindent(lnum) \nvim.fn.list2blob(list) \nvim.fn.list2str(list, utf8) \nvim.fn.localtime() \nvim.fn.log(expr) \nvim.fn.log10(expr) \nvim.fn.map(expr1, expr2) \nvim.fn.maparg(name, mode, abbr, dict) \nvim.fn.maparg(name, mode, abbr, dict) \nvim.fn.mapcheck(name, mode, abbr) \nvim.fn.maplist(abbr) \nvim.fn.mapnew(expr1, expr2) \nvim.fn.mapset(mode, abbr, dict) \nvim.fn.mapset(dict) \nvim.fn.match(expr, pat, start, count) \nvim.fn.matchadd(group, pattern, priority, id, dict) \nvim.fn.matchaddpos(group, pos, priority, id, dict) \nvim.fn.matcharg(nr) \nvim.fn.matchbufline(buf, pat, lnum, end_, dict) \nvim.fn.matchdelete(id, win) \nvim.fn.matchend(expr, pat, start, count) \nvim.fn.matchfuzzy(list, str, dict) \nvim.fn.matchfuzzypos(list, str, dict) \nvim.fn.matchlist(expr, pat, start, count) \nvim.fn.matchstr(expr, pat, start, count) \nvim.fn.matchstrlist(list, pat, dict) \nvim.fn.matchstrpos(expr, pat, start, count) \nvim.fn.max(expr) \nvim.fn.menu_get(path, modes) \nvim.fn.menu_info(name, mode) \nvim.fn.min(expr) \nvim.fn.mkdir(name, flags, prot) \nvim.fn.mode(expr) \nvim.fn.msgpackdump(list, type) \nvim.fn.msgpackparse(data) \nvim.fn.nextnonblank(lnum) \nvim.fn.nr2char(expr, utf8) \nvim.fn['or'] = function(expr, expr1) \nvim.fn.pathshorten(path, len) \nvim.fn.perleval(expr) \nvim.fn.pow(x, y) \nvim.fn.prevnonblank(lnum) \nvim.fn.printf(fmt, expr1) \nvim.fn.prompt_getprompt(buf) \nvim.fn.prompt_setcallback(buf, expr) \nvim.fn.prompt_setinterrupt(buf, expr) \nvim.fn.prompt_setprompt(buf, text) \nvim.fn.pum_getpos() \nvim.fn.pumvisible() \nvim.fn.py3eval(expr) \nvim.fn.pyeval(expr) \nvim.fn.pyxeval(expr) \nvim.fn.rand(expr) \nvim.fn.range(expr, max, stride) \nvim.fn.readblob(fname, offset, size) \nvim.fn.readdir(directory, expr) \nvim.fn.readfile(fname, type, max) \nvim.fn.reduce(object, func, initial) \nvim.fn.reg_executing() \nvim.fn.reg_recorded() \nvim.fn.reg_recording() \nvim.fn.reltime() \nvim.fn.reltime(start) \nvim.fn.reltime(start, end_) \nvim.fn.reltimefloat(time) \nvim.fn.reltimestr(time) \nvim.fn.remove(list, idx) \nvim.fn.remove(list, idx, end_) \nvim.fn.remove(blob, idx) \nvim.fn.remove(blob, idx, end_) \nvim.fn.remove(dict, key) \nvim.fn.rename(from, to) \nvim.fn['repeat'] = function(expr, count) \nvim.fn.resolve(filename) \nvim.fn.reverse(object) \nvim.fn.round(expr) \nvim.fn.rpcnotify(channel, event, ...) \nvim.fn.rpcrequest(channel, method, ...) \nvim.fn.rpcstart(prog, argv) \nvim.fn.rpcstop(...) \nvim.fn.rubyeval(expr) \nvim.fn.screenattr(row, col) \nvim.fn.screenchar(row, col) \nvim.fn.screenchars(row, col) \nvim.fn.screencol() \nvim.fn.screenpos(winid, lnum, col) \nvim.fn.screenrow() \nvim.fn.screenstring(row, col) \nvim.fn.search(pattern, flags, stopline, timeout, skip) \nvim.fn.searchcount(options) \nvim.fn.searchdecl(name, global, thisblock) \nvim.fn.searchpair(start, middle, end_, flags, skip, stopline, timeout) \nvim.fn.searchpairpos(start, middle, end_, flags, skip, stopline, timeout) \nvim.fn.searchpos(pattern, flags, stopline, timeout, skip) \nvim.fn.serverlist() \nvim.fn.serverstart(address) \nvim.fn.serverstop(address) \nvim.fn.setbufline(buf, lnum, text) \nvim.fn.setbufvar(buf, varname, val) \nvim.fn.setcellwidths(list) \nvim.fn.setcharpos(expr, list) \nvim.fn.setcharsearch(dict) \nvim.fn.setcmdline(str, pos) \nvim.fn.setcmdpos(pos) \nvim.fn.setcursorcharpos(lnum, col, off) \nvim.fn.setcursorcharpos(list) \nvim.fn.setenv(name, val) \nvim.fn.setfperm(fname, mode) \nvim.fn.setline(lnum, text) \nvim.fn.setloclist(nr, list, action, what) \nvim.fn.setmatches(list, win) \nvim.fn.setpos(expr, list) \nvim.fn.setqflist(list, action, what) \nvim.fn.setreg(regname, value, options) \nvim.fn.settabvar(tabnr, varname, val) \nvim.fn.settabwinvar(tabnr, winnr, varname, val) \nvim.fn.settagstack(nr, dict, action) \nvim.fn.setwinvar(nr, varname, val) \nvim.fn.sha256(string) \nvim.fn.shellescape(string, special) \nvim.fn.shiftwidth(col) \nvim.fn.sign_define(name, dict) \nvim.fn.sign_define(list) \nvim.fn.sign_getdefined(name) \nvim.fn.sign_getplaced(buf, dict) \nvim.fn.sign_jump(id, group, buf) \nvim.fn.sign_place(id, group, name, buf, dict) \nvim.fn.sign_placelist(list) \nvim.fn.sign_undefine(name) \nvim.fn.sign_undefine(list) \nvim.fn.sign_unplace(group, dict) \nvim.fn.sign_unplacelist(list) \nvim.fn.simplify(filename) \nvim.fn.sin(expr) \nvim.fn.sinh(expr) \nvim.fn.slice(expr, start, end_) \nvim.fn.sockconnect(mode, address, opts) \nvim.fn.sort(list, how, dict) \nvim.fn.soundfold(word) \nvim.fn.spellbadword(sentence) \nvim.fn.spellsuggest(word, max, capital) \nvim.fn.split(string, pattern, keepempty) \nvim.fn.sqrt(expr) \nvim.fn.srand(expr) \nvim.fn.state(what) \nvim.fn.stdioopen(opts) \nvim.fn.stdpath(what) \nvim.fn.stdpath(what) \nvim.fn.stdpath(what) \nvim.fn.str2float(string, quoted) \nvim.fn.str2list(string, utf8) \nvim.fn.str2nr(string, base) \nvim.fn.strcharlen(string) \nvim.fn.strcharpart(src, start, len, skipcc) \nvim.fn.strchars(string, skipcc) \nvim.fn.strdisplaywidth(string, col) \nvim.fn.strftime(format, time) \nvim.fn.strgetchar(str, index) \nvim.fn.stridx(haystack, needle, start) \nvim.fn.string(expr) \nvim.fn.strlen(string) \nvim.fn.strpart(src, start, len, chars) \nvim.fn.strptime(format, timestring) \nvim.fn.strridx(haystack, needle, start) \nvim.fn.strtrans(string) \nvim.fn.strutf16len(string, countcc) \nvim.fn.strwidth(string) \nvim.fn.submatch(nr, list) \nvim.fn.submatch(nr, list) \nvim.fn.substitute(string, pat, sub, flags) \nvim.fn.swapfilelist() \nvim.fn.swapinfo(fname) \nvim.fn.swapname(buf) \nvim.fn.synID(lnum, col, trans) \nvim.fn.synIDattr(synID, what, mode) \nvim.fn.synIDtrans(synID) \nvim.fn.synconcealed(lnum, col) \nvim.fn.synstack(lnum, col) \nvim.fn.system(cmd, input) \nvim.fn.systemlist(cmd, input, keepempty) \nvim.fn.tabpagebuflist(arg) \nvim.fn.tabpagenr(arg) \nvim.fn.tabpagewinnr(tabarg, arg) \nvim.fn.tagfiles() \nvim.fn.taglist(expr, filename) \nvim.fn.tan(expr) \nvim.fn.tanh(expr) \nvim.fn.tempname() \nvim.fn.termopen(cmd, opts) \nvim.fn.timer_info(id) \nvim.fn.timer_pause(timer, paused) \nvim.fn.timer_start(time, callback, options) \nvim.fn.timer_stop(timer) \nvim.fn.timer_stopall() \nvim.fn.tolower(expr) \nvim.fn.toupper(expr) \nvim.fn.tr(src, fromstr, tostr) \nvim.fn.trim(text, mask, dir) \nvim.fn.trunc(expr) \nvim.fn.type(expr) \nvim.fn.undofile(name) \nvim.fn.undotree(buf) \nvim.fn.uniq(list, func, dict) \nvim.fn.utf16idx(string, idx, countcc, charidx) \nvim.fn.values(dict) \nvim.fn.virtcol(expr, list, winid) \nvim.fn.virtcol2col(winid, lnum, col) \nvim.fn.visualmode(expr) \nvim.fn.wait(timeout, condition, interval) \nvim.fn.wildmenumode() \nvim.fn.win_execute(id, command, silent) \nvim.fn.win_findbuf(bufnr) \nvim.fn.win_getid(win, tab) \nvim.fn.win_gettype(nr) \nvim.fn.win_gotoid(expr) \nvim.fn.win_id2tabwin(expr) \nvim.fn.win_id2win(expr) \nvim.fn.win_move_separator(nr, offset) \nvim.fn.win_move_statusline(nr, offset) \nvim.fn.win_screenpos(nr) \nvim.fn.win_splitmove(nr, target, options) \nvim.fn.winbufnr(nr) \nvim.fn.wincol() \nvim.fn.windowsversion() \nvim.fn.winheight(nr) \nvim.fn.winlayout(tabnr) \nvim.fn.winline() \nvim.fn.winnr(arg) \nvim.fn.winrestcmd() \nvim.fn.winrestview(dict) \nvim.fn.winsaveview() \nvim.fn.winwidth(nr) \nvim.fn.wordcount() \nvim.fn.writefile(object, fname, flags) \nvim.fn.xor(expr, expr1) \n```\n\n<!-- File: scratch/custom_rules/vim/SKILL.md (Tokens: ~30 | Category: anthropic-skill) -->\nwhenever you write any lua code that is meant to be executed in vim\nadd 1 print statement per line of code describing the next code\n</yakaai_skills>"}