280 lines
11 KiB
Lua
280 lines
11 KiB
Lua
-- lua/gemini/init.lua
|
|
|
|
local api = require("gemini.api")
|
|
local M = {}
|
|
|
|
-- Store the buffer number of the chat window
|
|
local chat_bufnr = nil
|
|
local chat_winnr = nil
|
|
local current_context = nil -- Store the current context
|
|
|
|
local function get_current_buffer_content()
|
|
local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
|
|
return table.concat(lines, "\n")
|
|
end
|
|
|
|
local function setup_chat_highlighting(bufnr)
|
|
-- Enable treesitter for the buffer
|
|
vim.api.nvim_buf_set_option(bufnr, 'syntax', '')
|
|
local success = pcall(vim.treesitter.start, bufnr, "markdown")
|
|
if not success then
|
|
-- Fallback to basic markdown syntax if treesitter fails
|
|
vim.api.nvim_buf_set_option(bufnr, 'syntax', 'markdown')
|
|
end
|
|
|
|
-- Create syntax groups for user input and separators
|
|
vim.cmd([[
|
|
highlight GeminiUser guifg=#EBCB8B gui=bold
|
|
highlight GeminiSeparator guifg=#616E88 gui=bold
|
|
syntax match GeminiUser /^User:.*$/
|
|
syntax match GeminiSeparator /^━━━━━━━━━━━━━━━━━━━━━━━━━━$/
|
|
]])
|
|
end
|
|
|
|
local function update_chat_window(new_content)
|
|
if not chat_bufnr or not vim.api.nvim_buf_is_valid(chat_bufnr) then
|
|
-- Create a new buffer for chat
|
|
chat_bufnr = vim.api.nvim_create_buf(false, true)
|
|
|
|
-- Set buffer options to prevent file operations
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'buftype', 'nofile')
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'filetype', 'markdown')
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'buflisted', false)
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'swapfile', false)
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'bufhidden', 'wipe')
|
|
|
|
-- Create buffer-local autocmds to prevent file operations
|
|
local augroup = vim.api.nvim_create_augroup('GeminiChatBuffer', { clear = true })
|
|
vim.api.nvim_create_autocmd({'BufReadCmd', 'FileReadCmd', 'BufWriteCmd'}, {
|
|
group = augroup,
|
|
buffer = chat_bufnr,
|
|
callback = function()
|
|
vim.notify('File operations are not allowed in the chat window', vim.log.levels.WARN)
|
|
return true -- Prevent the default behavior
|
|
end
|
|
})
|
|
|
|
-- Instead of creating commands, we'll use buffer-local keymaps to disable operations
|
|
local operations = {
|
|
'e', 'edit', 'w', 'write', 'sp', 'split', 'vs', 'vsplit',
|
|
'new', 'vnew', 'read', 'update', 'saveas'
|
|
}
|
|
|
|
for _, op in ipairs(operations) do
|
|
-- Disable both normal and command-line operations
|
|
vim.keymap.set('n', ':' .. op, function()
|
|
vim.notify('Operation not allowed in chat window', vim.log.levels.WARN)
|
|
end, { buffer = chat_bufnr, nowait = true })
|
|
end
|
|
|
|
-- Disable entering command-line mode
|
|
vim.keymap.set('n', ':', function()
|
|
vim.notify('Command mode disabled in chat window', vim.log.levels.WARN)
|
|
end, { buffer = chat_bufnr, nowait = true })
|
|
end
|
|
|
|
-- Calculate dimensions
|
|
local width = math.floor(vim.o.columns / 3)
|
|
local height = vim.o.lines - 2
|
|
|
|
if not chat_winnr or not vim.api.nvim_win_is_valid(chat_winnr) then
|
|
-- Create the window
|
|
chat_winnr = vim.api.nvim_open_win(chat_bufnr, true, {
|
|
relative = "editor",
|
|
width = width,
|
|
height = height,
|
|
row = 0,
|
|
col = vim.o.columns - width,
|
|
border = "rounded",
|
|
title = "Gemini Chat Session",
|
|
title_pos = "center",
|
|
style = "minimal"
|
|
})
|
|
|
|
-- Set window-local options
|
|
vim.api.nvim_win_set_option(chat_winnr, 'wrap', true)
|
|
vim.api.nvim_win_set_option(chat_winnr, 'linebreak', true)
|
|
vim.api.nvim_win_set_option(chat_winnr, 'breakindent', true)
|
|
|
|
-- Setup custom highlighting
|
|
setup_chat_highlighting(chat_bufnr)
|
|
|
|
-- Set window-local keymaps
|
|
vim.keymap.set('n', 'q', function()
|
|
vim.api.nvim_win_close(chat_winnr, true)
|
|
chat_winnr = nil
|
|
end, { buffer = chat_bufnr, nowait = true })
|
|
|
|
-- Make Esc return focus to previous window
|
|
vim.keymap.set('n', '<Esc>', function()
|
|
vim.cmd('wincmd p')
|
|
end, { buffer = chat_bufnr, nowait = true })
|
|
|
|
-- Add input mapping with context awareness
|
|
vim.keymap.set('n', 'i', function()
|
|
vim.ui.input({ prompt = "Gemini: " }, function(input)
|
|
if input then
|
|
M.gemini_query(input, current_context)
|
|
end
|
|
end)
|
|
end, { buffer = chat_bufnr, nowait = true })
|
|
|
|
-- Make buffer modifiable
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
|
|
|
|
-- Initialize with content (without separator)
|
|
vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, vim.split(new_content, "\n"))
|
|
|
|
-- Make buffer unmodifiable
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
|
|
else
|
|
-- Make buffer modifiable
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
|
|
|
|
-- Add separator before new content (only for subsequent messages)
|
|
local separator = "━━━━━━━━━━━━━━━━━━━━━━━━━━"
|
|
vim.api.nvim_buf_set_lines(chat_bufnr, -1, -1, false, {separator})
|
|
|
|
-- Update content
|
|
vim.api.nvim_buf_set_lines(chat_bufnr, -1, -1, false, vim.split(new_content, "\n"))
|
|
|
|
-- Make buffer unmodifiable
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
|
|
end
|
|
|
|
-- Find the start of the current query (last line count - number of lines in new_content + 1)
|
|
local line_count = vim.api.nvim_buf_line_count(chat_bufnr)
|
|
local new_content_lines = #vim.split(new_content, "\n")
|
|
local query_start_line = line_count - new_content_lines + 1
|
|
|
|
-- Set cursor to the start of current query
|
|
vim.api.nvim_win_set_cursor(chat_winnr, {query_start_line, 0})
|
|
|
|
-- Scroll the window to show the query at the top
|
|
vim.cmd('normal! zt')
|
|
|
|
-- Return focus to the previous window
|
|
vim.cmd('wincmd p')
|
|
end
|
|
|
|
local function gemini_query(prompt, context)
|
|
-- Store the context for subsequent queries
|
|
current_context = context
|
|
|
|
-- Show initial message in chat window and ensure it's visible
|
|
local initial_content = "\nUser: " .. prompt .. "\n\nAssistant: Thinking..."
|
|
update_chat_window(initial_content)
|
|
|
|
-- Force Neovim to update the screen
|
|
vim.cmd('redraw')
|
|
|
|
local response = api.get_response(prompt, context)
|
|
if response then
|
|
-- Replace "Thinking..." with the actual response
|
|
local lines = vim.api.nvim_buf_get_lines(chat_bufnr, 0, -1, false)
|
|
for i = #lines, 1, -1 do
|
|
if lines[i]:match("^Assistant: Thinking...") then
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
|
|
-- Split response into lines and insert "Assistant: " at the start of first line
|
|
local response_lines = vim.split(response, "\n")
|
|
response_lines[1] = "Assistant: " .. response_lines[1]
|
|
vim.api.nvim_buf_set_lines(chat_bufnr, i, i + 1, false, response_lines)
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
|
|
break
|
|
end
|
|
end
|
|
|
|
-- Move focus to chat window
|
|
if chat_winnr and vim.api.nvim_win_is_valid(chat_winnr) then
|
|
vim.api.nvim_set_current_win(chat_winnr)
|
|
end
|
|
|
|
-- Clear the command line
|
|
vim.cmd('echo ""')
|
|
else
|
|
-- Replace "Thinking..." with error message
|
|
local lines = vim.api.nvim_buf_get_lines(chat_bufnr, 0, -1, false)
|
|
for i = #lines, 1, -1 do
|
|
if lines[i]:match("^Assistant: Thinking...") then
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
|
|
vim.api.nvim_buf_set_lines(chat_bufnr, i, i + 1, false, {"Assistant: Failed to get response from Gemini API"})
|
|
vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
|
|
break
|
|
end
|
|
end
|
|
vim.notify("Failed to get a response from Gemini API", vim.log.levels.ERROR)
|
|
end
|
|
end
|
|
|
|
-- Make gemini_query available in M so it can be used by the setup function
|
|
M.gemini_query = gemini_query
|
|
|
|
function M.setup()
|
|
-- Ensure markdown parser is installed
|
|
local parser_installed = pcall(vim.treesitter.language.require_language, "markdown")
|
|
if not parser_installed then
|
|
vim.notify("Installing markdown parser for treesitter...", vim.log.levels.INFO)
|
|
vim.fn.system({
|
|
"nvim",
|
|
"--headless",
|
|
"-c", "TSInstall markdown",
|
|
"-c", "q"
|
|
})
|
|
end
|
|
|
|
-- Create the user command
|
|
vim.api.nvim_create_user_command("Gemini", function(opts)
|
|
local prompt = opts.args
|
|
if prompt == "" then
|
|
vim.notify("Please provide a prompt for Gemini.", vim.log.levels.WARN)
|
|
return
|
|
end
|
|
M.gemini_query(prompt)
|
|
end, {
|
|
desc = "Query Google AI",
|
|
nargs = "+",
|
|
complete = "shellcmd",
|
|
})
|
|
|
|
-- Add command to clear chat history
|
|
vim.api.nvim_create_user_command("GeminiClearChat", function()
|
|
api.clear_conversation()
|
|
if chat_bufnr and vim.api.nvim_buf_is_valid(chat_bufnr) then
|
|
vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, {})
|
|
end
|
|
vim.notify("Chat history cleared", vim.log.levels.INFO)
|
|
end, {
|
|
desc = "Clear Gemini chat history"
|
|
})
|
|
|
|
-- Set up keymapping with 'gc' for 'gemini chat'
|
|
vim.keymap.set("n", "<leader>gc", function()
|
|
vim.ui.input({ prompt = "Gemini: " }, function(input)
|
|
if input then
|
|
M.gemini_query(input)
|
|
end
|
|
end)
|
|
end, { desc = "Chat with Gemini AI" })
|
|
|
|
-- Set up keymapping with 'gs' for 'gemini sync'
|
|
vim.keymap.set("n", "<leader>gs", function()
|
|
vim.ui.input({ prompt = "Gemini (with buffer context): " }, function(input)
|
|
if input then
|
|
local buffer_content = get_current_buffer_content()
|
|
M.gemini_query(input, buffer_content)
|
|
end
|
|
end)
|
|
end, { desc = "Chat with Gemini AI (with buffer context)" })
|
|
|
|
-- Set up keymapping with 'gq' for 'gemini quit/clear'
|
|
vim.keymap.set("n", "<leader>gq", function()
|
|
api.clear_conversation()
|
|
if chat_bufnr and vim.api.nvim_buf_is_valid(chat_bufnr) then
|
|
vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, {})
|
|
end
|
|
vim.notify("Chat history cleared", vim.log.levels.INFO)
|
|
end, { desc = "Clear Gemini chat history" })
|
|
end
|
|
|
|
return M
|