free/gemini
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: free:main
Branches Tags
free:main
free:lua-http
..
compare: free:lua-http
Branches Tags
free:main
free:lua-http

No commits in common. "main" and "lua-http" have entirely different histories.
main ... lua-http

7 changed files with 151 additions and 1085 deletions
Show Stats Expand all files Collapse all files

168
README.md
View File

@ -24,8 +24,6 @@ Use your favorite Neovim package manager. Here's how to install with Lazy.nvim:
## Configuration
### API Key Setup
Set your API key using one of these methods:
1. Environment variable:
@ -39,153 +37,6 @@ export GEMINI_API_KEY="your-api-key-here"
vim.g.gemini_api_key = "your-api-key-here"
```
### Plugin Configuration
The plugin can be configured during setup. Here's an example with all available options and their defaults:
```lua
require("gemini").setup({
-- Model configuration
model = "gemini-2.0-flash", -- The Gemini model to use
api_url = "https://generativelanguage.googleapis.com/v1/models/%s:generateContent", -- API endpoint URL
-- Window appearance
window = {
-- Window width (can be number or function)
width = function()
return math.floor(vim.o.columns / 3)
end,
-- Window height (can be number or function)
height = function()
return vim.o.lines - 2
end,
border = "rounded", -- Border style: "none", "single", "double", "rounded"
title = "Gemini Chat Session",
title_pos = "center", -- Title position: "left", "center", "right"
},
-- Keymaps in chat window
mappings = {
close = 'q', -- Close chat window
return_focus = '<Esc>', -- Return to previous window
new_query = 'i', -- Start new query
},
-- Highlight groups for chat messages
highlights = {
user = "GeminiUser", -- Highlight group for user messages
separator = "GeminiSeparator", -- Highlight group for message separators
},
})
```
### Configuration Options
#### Model Configuration
- `model`: The Gemini model to use (default: "gemini-2.0-flash")
- `api_url`: The Google AI API endpoint URL format (default: "https://generativelanguage.googleapis.com/v1/models/%s:generateContent")
#### Window Appearance
- `window.width`: Width of the chat window (number or function)
- `window.height`: Height of the chat window (number or function)
- `window.border`: Border style ("none", "single", "double", "rounded")
- `window.title`: Title of the chat window
- `window.title_pos`: Position of the title ("left", "center", "right")
#### Chat Window Keymaps
- `mappings.close`: Key to close the chat window (default: 'q')
- `mappings.return_focus`: Key to return to previous window (default: '<Esc>')
- `mappings.new_query`: Key to start a new query (default: 'i')
#### Highlight Groups
- `highlights.user`: Highlight group for user messages (default: "GeminiUser")
- `highlights.separator`: Highlight group for message separators (default: "GeminiSeparator")
### Customizing Highlights
The plugin defines two highlight groups that you can customize:
```lua
-- In your init.lua or colorscheme
vim.api.nvim_set_hl(0, "GeminiUser", { fg = "#EBCB8B", bold = true })
vim.api.nvim_set_hl(0, "GeminiSeparator", { fg = "#616E88", bold = true })
```
### Default Global Keymaps
The plugin sets up the following default keymaps in normal mode:
- `<leader>gc`: Open chat window for a new query
- `<leader>gs`: Open chat window with current buffer as context
- `<leader>gq`: Clear chat history
You can override these by adding your own mappings after setup:
```lua
-- Example of custom keymaps
vim.keymap.set("n", "<leader>m", function()
require("gemini").prompt_query()
end, { desc = "Chat with Gemini AI" })
vim.keymap.set("n", "<leader>M", function()
require("gemini").prompt_query(vim.api.nvim_buf_get_lines(0, 0, -1, false))
end, { desc = "Chat with Gemini AI (with buffer context)" })
```
### Configuration Examples
1. **Custom Window Size (Percentage Based)**:
```lua
require("gemini").setup({
window = {
width = function()
-- Use 40% of screen width
return math.floor(vim.o.columns * 0.4)
end,
height = function()
-- Use 80% of screen height
return math.floor(vim.o.lines * 0.8)
end
}
})
```
2. **Fixed Window Dimensions**:
```lua
require("gemini").setup({
window = {
width = 80, -- Fixed width of 80 columns
height = 40, -- Fixed height of 40 lines
}
})
```
3. **Custom Appearance**:
```lua
require("gemini").setup({
window = {
border = "double",
title = "AI Assistant",
title_pos = "left"
},
highlights = {
user = "Statement", -- Use built-in highlight group
separator = "Comment" -- Use built-in highlight group
}
})
```
4. **Custom Keymaps**:
```lua
require("gemini").setup({
mappings = {
close = '<C-c>',
return_focus = '<C-w>',
new_query = 'a'
}
})
```
## Usage
The plugin provides several ways to interact with Gemini:
@ -219,19 +70,12 @@ The chat window appears on the right side of your editor and provides the follow
- `q`: Close the chat window (history is preserved)
- `<Esc>`: Return focus to previous buffer
- Normal mode scrolling commands (`j`, `k`, `<C-d>`, `<C-u>`, etc.) work as expected
- Window automatically scrolls to show new messages at the top
Chat Window Display:
- Your latest query is automatically positioned at the top of the window
- The AI's response appears directly below your query
- Previous conversation history is accessible by scrolling up
- Messages are clearly marked with "User:" and "Assistant:" prefixes
- Messages are separated by horizontal lines for better readability
Chat Window Restrictions:
- Leader key commands (including telescope/file operations) are disabled
- Command mode (`:`) is disabled
- Only basic navigation and chat-specific commands are allowed
- A warning message appears if you attempt restricted operations
File operations in the chat window are intentionally disabled:
- `:w`, `:e`, `:sp`, `:vs` and similar commands are blocked
- The command-line mode (`:`) is disabled to prevent file operations
- A warning message appears if you attempt these operations
### Chat Commands
@ -247,7 +91,7 @@ Chat Window Restrictions:
- Support for the latest Gemini 2.0 Flash model
- Markdown syntax highlighting for responses
- Context-aware queries using current buffer content
- Smart conversation display with latest query at the top
- Automatic scrolling to new messages
- Protected chat window to prevent accidental modifications
## Troubleshooting

63
lua/gemini/api.lua
View File

@ -1,8 +1,10 @@
local config = require("gemini.config")
local http = require("gemini.http")
local chat = require("gemini.chat") -- Add chat module
local M = {}
-- Store conversation history
local conversation_history = {}
local function get_api_key()
return vim.g.gemini_api_key or os.getenv("GEMINI_API_KEY")
end
@ -10,15 +12,13 @@ end
local function create_contents(prompt, context)
local contents = {}
-- Add conversation history
for _, message in ipairs(chat.get_conversation_history()) do
for _, message in ipairs(conversation_history) do
table.insert(contents, {
role = message.role,
parts = {{text = message.content}}
})
end
-- Add current prompt
if context then
table.insert(contents, {
role = "user",
@ -31,21 +31,11 @@ local function create_contents(prompt, context)
})
end
-- Ensure we have at least one content item
if #contents == 0 then
contents = {
{
role = "user",
parts = {{text = prompt}}
}
}
end
return contents
end
local function store_message(role, content)
chat.add_message(role, content)
table.insert(conversation_history, {role = role, content = content})
end
local function handle_response(result, callback)
@ -79,53 +69,28 @@ function M.get_response(prompt, context, callback)
return
end
-- Validate prompt
if not prompt or prompt:match("^%s*$") then
vim.schedule(function()
callback(nil, "Empty prompt")
end)
return
end
store_message("user", prompt)
-- Create the request content
local contents = {
{
role = "user",
parts = {{text = context and (context .. "\n\n" .. prompt) or prompt}}
}
}
local payload = vim.json.encode({
contents = contents,
generationConfig = {
temperature = 0.1,
topK = 1,
topP = 1,
maxOutputTokens = 2048,
}
})
-- Correctly format the URL with model and API key
local contents = create_contents(prompt, context)
local payload = vim.json.encode({contents = contents})
local url = string.format(
config.options.api_url,
config.options.model
) .. "?key=" .. api_key
config.options.api_url .. "?key=%s",
config.options.model,
api_key
)
local request = http.Request.new(url, payload)
request:execute(function(result, error)
if error then
vim.schedule(function()
callback(nil, "HTTP Error: " .. error)
end)
callback(nil, error)
return
end
handle_response(result, callback)
end)
end
function M.clear_conversation()
chat.clear() -- This will clear both the buffer and conversation history
conversation_history = {}
end
return M

169
lua/gemini/chat.lua
View File

@ -6,7 +6,6 @@ local state = {
bufnr = nil,
winnr = nil,
current_context = nil,
conversation_history = {}
}
local function setup_chat_highlighting(bufnr)
@ -22,7 +21,6 @@ local function setup_chat_highlighting(bufnr)
end
local function setup_buffer_options(bufnr)
-- Set strict buffer options
local options = {
buftype = 'nofile',
filetype = 'markdown',
@ -30,111 +28,43 @@ local function setup_buffer_options(bufnr)
swapfile = false,
bufhidden = 'wipe',
modifiable = false,
readonly = true,
undolevels = -1,
list = false,
number = false,
relativenumber = false,
modified = false,
foldmethod = 'manual',
foldlevel = 99,
textwidth = 0,
wrapmargin = 0,
expandtab = true,
autoindent = false,
smartindent = false,
}
for option, value in pairs(options) do
vim.api.nvim_buf_set_option(bufnr, option, value)
end
-- Clear buffer name to prevent file operations
vim.api.nvim_buf_set_name(bufnr, '')
end
local function setup_buffer_autocmds(bufnr)
local augroup = vim.api.nvim_create_augroup('GeminiChatBuffer', { clear = true })
-- Block ALL buffer events that could load files
local blocked_events = {
'BufReadCmd', 'FileReadCmd', 'BufWriteCmd', 'FileWriteCmd',
'BufReadPre', 'BufReadPost', 'BufWrite', 'BufWritePre', 'BufWritePost',
'FileReadPre', 'FileReadPost', 'FileWritePre', 'FileWritePost',
'BufAdd', 'BufCreate', 'BufDelete', 'BufWipeout',
'BufNew', 'BufNewFile', 'BufRead', 'BufEnter', 'BufLeave',
'FileType', 'BufFilePre', 'BufFilePost',
'FileChangedShell', 'FileChangedShellPost',
'FileChangedRO', 'FileAppendCmd', 'FileAppendPre', 'FileAppendPost',
'FilterReadPre', 'FilterReadPost', 'FocusGained', 'FocusLost'
}
for _, event in ipairs(blocked_events) do
vim.api.nvim_create_autocmd(event, {
group = augroup,
buffer = bufnr,
callback = function()
vim.notify('File operations are not allowed in the chat window', vim.log.levels.WARN)
return true -- Prevent the default handler
end
})
end
-- Override buffer behavior
vim.api.nvim_create_autocmd('BufEnter', {
vim.api.nvim_create_autocmd({'BufReadCmd', 'FileReadCmd', 'BufWriteCmd'}, {
group = augroup,
buffer = bufnr,
callback = function()
-- Force buffer settings on every enter
vim.opt_local.modifiable = false
vim.opt_local.readonly = true
vim.opt_local.swapfile = false
vim.opt_local.buftype = 'nofile'
vim.opt_local.buflisted = false
-- Disable file loading capabilities
vim.bo[bufnr].buftype = 'nofile'
vim.bo[bufnr].filetype = 'markdown'
-- Clear file name to prevent file operations
vim.api.nvim_buf_set_name(bufnr, '')
-- Return true to prevent default BufEnter handling
return true
end
})
-- Prevent any attempt to change buffer settings
vim.api.nvim_create_autocmd('OptionSet', {
group = augroup,
buffer = bufnr,
callback = function()
vim.schedule(function()
vim.opt_local.modifiable = false
vim.opt_local.readonly = true
vim.opt_local.buftype = 'nofile'
end)
vim.notify('File operations are not allowed in the chat window', vim.log.levels.WARN)
return true
end
})
end
local function setup_buffer_keymaps(bufnr)
local opts = { buffer = bufnr, nowait = true, silent = true }
-- Block ALL leader key combinations - this is the key fix!
vim.keymap.set({'n', 'v'}, '<leader>', function()
vim.notify('Leader key commands are disabled in chat window', vim.log.levels.WARN)
return '<Esc>'
end, opts)
local opts = { buffer = bufnr, nowait = true }
-- Disable file operations
local operations = {'e', 'edit', 'w', 'write', 'sp', 'split', 'vs', 'vsplit',
'new', 'vnew', 'read', 'update', 'saveas'}
for _, op in ipairs(operations) do
vim.keymap.set('n', ':' .. op, function()
vim.notify('Operation not allowed in chat window', vim.log.levels.WARN)
end, opts)
end
-- Disable command mode
vim.keymap.set('n', ':', function()
vim.notify('Commands are disabled in chat window', vim.log.levels.WARN)
return '<Esc>'
vim.notify('Command mode disabled in chat window', vim.log.levels.WARN)
end, opts)
-- Only allow specific keymaps for chat functionality
-- Set chat-specific keymaps
local mappings = config.options.mappings
vim.keymap.set('n', mappings.close, function()
vim.api.nvim_win_close(state.winnr, true)
@ -148,12 +78,6 @@ local function setup_buffer_keymaps(bufnr)
vim.keymap.set('n', mappings.new_query, function()
require("gemini").prompt_query(state.current_context)
end, opts)
-- Allow basic navigation
local allowed_keys = {'j', 'k', '<C-d>', '<C-u>', '<C-f>', '<C-b>', 'G', 'gg'}
for _, key in ipairs(allowed_keys) do
vim.keymap.set('n', key, key, opts)
end
end
function M.create_window()
@ -186,52 +110,25 @@ function M.create_window()
end
end
function M.update_content(content, is_new_chat, is_thinking)
-- Temporarily disable readonly and enable modifiable
vim.api.nvim_buf_set_option(state.bufnr, 'readonly', false)
function M.update_content(content, is_new_chat)
vim.api.nvim_buf_set_option(state.bufnr, 'modifiable', true)
local lines = vim.split(content, "\n")
if is_thinking then
-- For thinking message, just replace content
vim.api.nvim_buf_set_lines(state.bufnr, 0, -1, false, lines)
if is_new_chat then
vim.api.nvim_buf_set_lines(state.bufnr, 0, -1, false, vim.split(content, "\n"))
else
-- For actual messages
local display_lines = {}
local current_query_line = 1
-- Add all messages from history
for i, msg in ipairs(state.conversation_history) do
if i > 1 then
table.insert(display_lines, "━━━━━━━━━━━━━━━━━━━━━━━━━━")
end
if i == #state.conversation_history - 1 then
current_query_line = #display_lines + 1
end
local prefix = msg.role == "user" and "User: " or "Assistant: "
local first_line = true
local msg_lines = vim.split(msg.content, "\n")
for _, line in ipairs(msg_lines) do
if first_line then
table.insert(display_lines, prefix .. line)
first_line = false
else
table.insert(display_lines, line)
end
end
end
if #display_lines > 0 then
vim.api.nvim_buf_set_lines(state.bufnr, 0, -1, false, display_lines)
vim.api.nvim_win_set_cursor(state.winnr, {current_query_line, 0})
vim.cmd('normal! zt')
end
local separator = "━━━━━━━━━━━━━━━━━━━━━━━━━━"
vim.api.nvim_buf_set_lines(state.bufnr, -1, -1, false, {separator})
vim.api.nvim_buf_set_lines(state.bufnr, -1, -1, false, vim.split(content, "\n"))
end
-- Re-enable readonly and disable modifiable
vim.api.nvim_buf_set_option(state.bufnr, 'modifiable', false)
vim.api.nvim_buf_set_option(state.bufnr, 'readonly', true)
-- Scroll to show new content
local line_count = vim.api.nvim_buf_line_count(state.bufnr)
local content_lines = #vim.split(content, "\n")
local start_line = line_count - content_lines + 1
vim.api.nvim_win_set_cursor(state.winnr, {start_line, 0})
vim.cmd('normal! zt')
vim.cmd('wincmd p')
end
@ -243,18 +140,6 @@ function M.clear()
if state.bufnr and vim.api.nvim_buf_is_valid(state.bufnr) then
vim.api.nvim_buf_set_lines(state.bufnr, 0, -1, false, {})
end
state.conversation_history = {} -- Clear conversation history
end
-- Add functions to manage conversation history
function M.add_message(role, content)
-- Remove any existing prefix from the content
content = content:gsub("^User: ", ""):gsub("^Assistant: ", "")
table.insert(state.conversation_history, {role = role, content = content})
end
function M.get_conversation_history()
return state.conversation_history
end
return M

607
lua/gemini/completion.lua
View File

@ -1,607 +0,0 @@
local api = require("gemini.api")
local M = {}
-- State for managing current suggestion and debounce timer
local current_suggestion = {
text = nil,
start_col = nil,
namespace_id = vim.api.nvim_create_namespace('gemini_suggestion'),
timer = nil,
last_request = 0,
cache = {},
debounce_ms = 1000, -- Wait 1 second between requests
min_chars = 0, -- Minimum characters before triggering completion
max_context_lines = 10, -- Maximum number of context lines to send
}
-- Add at the top of the file with other state variables
local completion_cache = {
entries = {},
max_entries = 1000,
ttl = 30 * 60 * 1000, -- 30 minutes TTL
last_cleanup = 0
}
-- Add buffer context management
local buffer_context = {
content = nil,
last_update = 0,
bufnr = nil,
changetick = nil,
update_interval = 1000, -- Update buffer context at most every second
}
-- Function to get relevant buffer content
local function get_buffer_context()
local current_buf = vim.api.nvim_get_current_buf()
local current_tick = vim.api.nvim_buf_get_changedtick(current_buf)
local now = vim.loop.now()
-- Return cached context if buffer hasn't changed and cache is fresh
if buffer_context.content and
buffer_context.bufnr == current_buf and
buffer_context.changetick == current_tick and
(now - buffer_context.last_update) < buffer_context.update_interval then
return buffer_context.content
end
-- Get buffer info
local filetype = vim.bo.filetype
local filename = vim.fn.expand('%:t')
local cursor_pos = vim.api.nvim_win_get_cursor(0)
local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
-- Extract imports/requires from the top of the file
local imports = {}
for _, line in ipairs(lines) do
if line:match("^%s*require") or
line:match("^%s*import") or
line:match("^%s*use") or
line:match("^%s*from") then
table.insert(imports, line)
end
end
-- Get function/class definitions
local definitions = {}
for i, line in ipairs(lines) do
if line:match("^%s*function") or
line:match("^%s*local%s+function") or
line:match("^%s*class") or
line:match("^%s*struct") or
line:match("^%s*type") then
table.insert(definitions, string.format("L%d: %s", i, line))
end
end
-- Get current function context
local current_line = cursor_pos[1]
local function_context = {}
local in_function = false
local function_start = 0
for i = current_line, 1, -1 do
local line = lines[i]
if line:match("^%s*function") or line:match("^%s*local%s+function") then
function_start = i
in_function = true
break
end
end
if in_function then
-- Get up to 10 lines of the current function
local context_start = math.max(function_start, current_line - 10)
for i = context_start, current_line - 1 do
table.insert(function_context, string.format("L%d: %s", i, lines[i]))
end
end
-- Build context structure
local context = {
filetype = filetype,
filename = filename,
cursor = {
line = cursor_pos[1],
col = cursor_pos[2]
},
imports = imports,
definitions = definitions,
current_function = function_context,
visible_lines = vim.api.nvim_buf_get_lines(
0,
math.max(0, current_line - 10),
math.min(#lines, current_line + 10),
false
)
}
-- Update cache
buffer_context.content = context
buffer_context.bufnr = current_buf
buffer_context.changetick = current_tick
buffer_context.last_update = now
return context
end
-- Add completion triggers detection
local function should_trigger_completion(line_text, col)
local config = require("gemini.config")
local trigger_chars = config.options.completion.trigger_characters or "."
-- Don't trigger on empty lines or spaces
if line_text:match("^%s*$") then return false end
-- Check minimum characters
local text_before_cursor = line_text:sub(1, col)
if #text_before_cursor < current_suggestion.min_chars then return false end
-- Check if we're in a comment
local filetype = vim.bo.filetype
local comment_string = vim.bo.commentstring
if comment_string then
local comment_start = comment_string:match("^(.-)%%s")
if comment_start and text_before_cursor:match(vim.pesc(comment_start)) then
return false
end
end
-- Check for trigger characters
local last_char = text_before_cursor:sub(-1)
if trigger_chars:find(last_char, 1, true) then
return true
end
-- Check for meaningful context
local meaningful_pattern = "[%w_][%w_%.%:]*$" -- Matches identifiers and dot/colon access
local context = text_before_cursor:match(meaningful_pattern)
if context and #context >= 2 then
return true
end
return false
end
-- Improved cache key generation
local function get_cache_key(context, line_text, col)
local buffer_ctx = get_buffer_context()
local prefix = line_text:sub(1, col)
local key_parts = {
buffer_ctx.filetype,
prefix,
-- Include function context in cache key
table.concat(buffer_ctx.current_function, "\n"),
-- Include nearby definitions
table.concat(buffer_ctx.definitions, "\n"):sub(1, 200),
-- Include visible context hash
vim.fn.sha256(table.concat(buffer_ctx.visible_lines, "\n"))
}
return vim.fn.sha256(table.concat(key_parts, "||"))
end
-- Cache management
local function cleanup_cache()
local now = vim.loop.now()
if now - completion_cache.last_cleanup < 60000 then return end -- Cleanup max once per minute
local count = 0
local expired = {}
for key, entry in pairs(completion_cache.entries) do
if now - entry.timestamp > completion_cache.ttl then
table.insert(expired, key)
end
count = count + 1
end
-- Remove expired entries
for _, key in ipairs(expired) do
completion_cache.entries[key] = nil
end
-- If still too many entries, remove oldest
if count > completion_cache.max_entries then
local entries = {}
for k, v in pairs(completion_cache.entries) do
table.insert(entries, {key = k, timestamp = v.timestamp})
end
table.sort(entries, function(a, b) return a.timestamp < b.timestamp end)
for i = 1, count - completion_cache.max_entries do
completion_cache.entries[entries[i].key] = nil
end
end
completion_cache.last_cleanup = now
end
-- Cache access
local function get_cached_completion(context, line_text, col)
cleanup_cache()
local key = get_cache_key(context, line_text, col)
local entry = completion_cache.entries[key]
if entry and (vim.loop.now() - entry.timestamp) < completion_cache.ttl then
return entry.completion
end
return nil
end
local function cache_completion(context, line_text, col, completion)
local key = get_cache_key(context, line_text, col)
completion_cache.entries[key] = {
completion = completion,
timestamp = vim.loop.now()
}
end
-- Helper function to get visible lines around cursor
local function get_visible_lines()
local win = vim.api.nvim_get_current_win()
local cursor_line = vim.api.nvim_win_get_cursor(0)[1]
local top_line = vim.fn.line('w0')
local bottom_line = vim.fn.line('w$')
-- Get all visible lines
local lines = vim.api.nvim_buf_get_lines(0, top_line - 1, bottom_line, false)
local relative_cursor = cursor_line - top_line + 1
return lines, relative_cursor
end
-- Helper function to get current line indent
local function get_line_indent(line)
local indent = line:match("^%s+") or ""
return indent
end
-- Debug function
local function debug_print(...)
vim.notify(string.format(...), vim.log.levels.INFO)
end
-- Helper function to clear suggestion
local function clear_suggestion()
if current_suggestion.timer then
vim.fn.timer_stop(current_suggestion.timer)
current_suggestion.timer = nil
end
if current_suggestion.text then
vim.api.nvim_buf_clear_namespace(0, current_suggestion.namespace_id, 0, -1)
current_suggestion.text = nil
current_suggestion.start_col = nil
end
end
-- Check if we should rate limit
local function should_rate_limit()
local now = vim.loop.now()
if (now - current_suggestion.last_request) < current_suggestion.debounce_ms then
return true
end
current_suggestion.last_request = now
return false
end
-- Cache key generation
local function get_cache_key(context)
return vim.fn.sha256(context)
end
-- Helper function to show suggestion
local function show_suggestion(suggestion, start_col)
clear_suggestion()
local cursor = vim.api.nvim_win_get_cursor(0)
local line = cursor[1] - 1
local current_line = vim.api.nvim_get_current_line()
-- Get current line indent
local indent = get_line_indent(current_line)
-- Split suggestion into lines and apply indent to all lines except first
local suggestion_lines = vim.split(suggestion, "\n")
for i = 2, #suggestion_lines do
suggestion_lines[i] = indent .. suggestion_lines[i]
end
if #suggestion_lines == 0 then return end
-- Add support for different suggestion styles
local config = require("gemini.config")
local style = config.options.completion_style or "ghost" -- Add this to config
-- Show ghost text with improved styling
vim.api.nvim_buf_set_extmark(0, current_suggestion.namespace_id, line, start_col, {
virt_text = {{suggestion_lines[1], 'GeminiSuggestion'}},
virt_text_pos = 'overlay',
hl_mode = 'combine',
priority = 100, -- Add higher priority to ensure visibility
right_gravity = false -- Ensure suggestion stays at cursor position
})
-- Show remaining lines as virtual lines
if #suggestion_lines > 1 then
local virt_lines = {}
for i = 2, #suggestion_lines do
table.insert(virt_lines, {{suggestion_lines[i], 'GeminiSuggestion'}})
end
vim.api.nvim_buf_set_extmark(0, current_suggestion.namespace_id, line, start_col, {
virt_lines = virt_lines,
virt_lines_above = false,
})
end
current_suggestion.text = table.concat(suggestion_lines, "\n")
current_suggestion.start_col = start_col
end
function M.accept_suggestion()
if not (current_suggestion.text and current_suggestion.start_col) then
return false
end
local line = vim.api.nvim_win_get_cursor(0)[1] - 1
local col = vim.api.nvim_win_get_cursor(0)[2]
-- Only accept if we're still at or after the suggestion start
if col < current_suggestion.start_col then
return false
end
-- Get current line text
local line_text = vim.api.nvim_buf_get_lines(0, line, line + 1, true)[1]
local text_after_cursor = string.sub(line_text, col + 1)
-- Split suggestion into lines
local suggestion_lines = vim.split(current_suggestion.text, "\n")
if #suggestion_lines == 0 then return false end
-- For the first line, only insert the part that doesn't overlap
local first_line = suggestion_lines[1]
local common_length = 0
while common_length < #text_after_cursor and common_length < #first_line do
if string.sub(text_after_cursor, common_length + 1, common_length + 1) ==
string.sub(first_line, common_length + 1, common_length + 1) then
common_length = common_length + 1
else
break
end
end
-- Only insert the non-overlapping part
local to_insert = string.sub(first_line, common_length + 1)
if to_insert ~= "" then
vim.api.nvim_buf_set_text(
0,
line,
col,
line,
col,
{to_insert}
)
end
-- Insert remaining lines below
if #suggestion_lines > 1 then
vim.api.nvim_buf_set_lines(
0,
line + 1,
line + 1,
false,
vim.list_slice(suggestion_lines, 2)
)
end
-- Move cursor to end of inserted text
local final_line = line + #suggestion_lines - 1
local final_col
if final_line == line then
final_col = col + #to_insert
else
final_col = #suggestion_lines[#suggestion_lines]
end
vim.api.nvim_win_set_cursor(0, {final_line + 1, final_col})
-- Clear suggestion and cache for the current context
clear_suggestion()
current_suggestion.cache = {} -- Clear cache to force new suggestions
-- Schedule next completion after a short delay
vim.defer_fn(function()
if vim.b.gemini_completion_enabled then
M.trigger_completion()
end
end, 100)
return true
end
-- Modify get_context_around_cursor to use buffer context
local function get_context_around_cursor(lines, current_line, max_lines)
local context = {}
local buffer_ctx = get_buffer_context()
-- Add file and cursor information
table.insert(context, string.format("File: %s (%s)", buffer_ctx.filename, buffer_ctx.filetype))
table.insert(context, string.format("Cursor: line %d, col %d", buffer_ctx.cursor.line, buffer_ctx.cursor.col))
-- Add imports
if #buffer_ctx.imports > 0 then
table.insert(context, "\nRelevant imports:")
for _, import in ipairs(buffer_ctx.imports) do
table.insert(context, import)
end
end
-- Add relevant definitions
if #buffer_ctx.definitions > 0 then
table.insert(context, "\nRelevant definitions:")
for _, def in ipairs(buffer_ctx.definitions) do
table.insert(context, def)
end
end
-- Add current function context
if #buffer_ctx.current_function > 0 then
table.insert(context, "\nCurrent function context:")
for _, line in ipairs(buffer_ctx.current_function) do
table.insert(context, line)
end
end
-- Add visible context
table.insert(context, "\nCurrent visible context:")
for i, line in ipairs(buffer_ctx.visible_lines) do
if #line > 0 then
table.insert(context, string.format("L%d: %s", current_line - 10 + i - 1, line))
end
end
return context
end
local function create_debounced_function(fn, wait)
local timer = nil
return function(...)
local args = {...}
if timer then
vim.fn.timer_stop(timer)
end
timer = vim.fn.timer_start(wait, function()
fn(unpack(args))
timer = nil
end)
end
end
-- Use the improved debouncing
local trigger_completion_debounced = create_debounced_function(function()
M.trigger_completion()
end, current_suggestion.debounce_ms)
function M.trigger_completion()
-- Early exit conditions
if not vim.b.gemini_completion_enabled then return end
if vim.fn.pumvisible() ~= 0 then return end
local cursor = vim.api.nvim_win_get_cursor(0)
local line = cursor[1] - 1
local col = cursor[2]
local current_line = vim.api.nvim_get_current_line()
-- Check if we should trigger completion
if not should_trigger_completion(current_line, col) then
clear_suggestion()
return
end
-- Check rate limiting
if should_rate_limit() then return end
-- Get enhanced context
local buffer_ctx = get_buffer_context()
local context = get_context_around_cursor(
buffer_ctx.visible_lines,
buffer_ctx.cursor.line,
current_suggestion.max_context_lines
)
-- Check cache first
local cached_completion = get_cached_completion(context, current_line, col)
if cached_completion then
vim.schedule(function()
show_suggestion(cached_completion, col)
end)
return
end
-- Create more detailed prompt
local prompt = string.format([[
You are an autocomplete engine. Respond ONLY with the direct completion text.
DO NOT include explanations, markdown, or additional formatting.
Language: %s
File: %s
Imports:
%s
Relevant Definitions:
%s
Current Function:
%s
Complete this line:
%s]],
buffer_ctx.filetype,
buffer_ctx.filename,
table.concat(buffer_ctx.imports, "\n"),
table.concat(buffer_ctx.definitions, "\n"),
table.concat(buffer_ctx.current_function, "\n"),
current_line
)
-- Make API request
api.get_response(prompt, nil, function(response, error)
if error then
if error:match("code = 429") then
handle_rate_limit()
return
end
return
end
if response then
-- Cache the successful completion
cache_completion(context, current_line, col, response)
vim.schedule(function()
local new_cursor = vim.api.nvim_win_get_cursor(0)
if new_cursor[1] - 1 == line and new_cursor[2] == col then
show_suggestion(response, col)
end
end)
end
end)
end
-- Setup function to create highlight group and keymaps
function M.setup()
-- Create highlight group for suggestions
vim.api.nvim_set_hl(0, 'GeminiSuggestion', {
fg = '#666666',
italic = true,
blend = 15 -- Makes the ghost text slightly transparent
})
-- Map Tab to accept suggestion
vim.keymap.set('i', '<Tab>', function()
if not M.accept_suggestion() then
vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes('<Tab>', true, true, true), 'n', true)
end
end, { expr = false, noremap = true })
-- Set up autocommand for real-time completion
vim.api.nvim_create_autocmd("TextChangedI", {
pattern = "*",
callback = function()
if vim.b.gemini_completion_enabled then
M.trigger_completion()
end
end
})
-- Clear suggestion on cursor move
vim.api.nvim_create_autocmd({'CursorMovedI', 'CursorMoved'}, {
pattern = "*",
callback = function()
clear_suggestion()
end
})
end
return M

20
lua/gemini/config.lua
View File

@ -2,7 +2,7 @@ local M = {}
M.defaults = {
model = "gemini-2.0-flash",
api_url = "https://generativelanguage.googleapis.com/v1/models/%s:generateContent", -- Updated URL format
api_url = "https://generativelanguage.googleapis.com/v1/models/%s:generateContent",
window = {
width = function() return math.floor(vim.o.columns / 3) end,
height = function() return vim.o.lines - 2 end,
@ -19,22 +19,6 @@ M.defaults = {
user = "GeminiUser",
separator = "GeminiSeparator",
},
completion = {
enabled = true,
debounce_ms = 1000,
min_chars = 2,
max_context_lines = 10,
style = "ghost",
trigger_characters = ".:", -- Trigger on dot and colon
exclude_filetypes = { "TelescopePrompt", "neo-tree" },
cache_ttl = 30 * 60 * 1000, -- 30 minutes
max_cache_entries = 1000,
suggestion_highlight = {
fg = '#666666',
italic = true,
blend = 15
}
}
}
M.options = {}
@ -43,4 +27,4 @@ function M.setup(opts)
M.options = vim.tbl_deep_extend("force", {}, M.defaults, opts or {})
end
return M
return M

133
lua/gemini/http.lua
View File

@ -8,94 +8,85 @@ function Request.new(url, payload)
local self = setmetatable({}, Request)
self.url = url
self.payload = payload
self.response = ""
self.error_msg = ""
self.stdout = vim.loop.new_pipe()
self.stderr = vim.loop.new_pipe()
self.handle = nil
return self
end
function Request:execute(callback)
local stdout = vim.loop.new_pipe()
local stderr = vim.loop.new_pipe()
local handle
local output = ""
local error_output = ""
function Request:cleanup()
if self.stdout then self.stdout:close() end
if self.stderr then self.stderr:close() end
if self.handle then self.handle:close() end
end
local function cleanup()
if handle then
vim.loop.close(handle)
handle = nil
function Request:handle_error(callback, msg)
self:cleanup()
vim.schedule(function()
callback(nil, msg)
end)
end
function Request:setup_pipes(callback)
self.stdout:read_start(function(err, chunk)
if err then
self:handle_error(callback, "Read error: " .. err)
return
end
stdout:close()
stderr:close()
end
if chunk then
self.response = self.response .. chunk
end
end)
-- Print the curl command for debugging
local curl_args = {
"-s", -- silent mode
"-X", "POST",
"-H", "Content-Type: application/json",
"-d", self.payload,
self.url
}
handle = vim.loop.spawn("curl", {
args = curl_args,
stdio = {nil, stdout, stderr}
}, function(code)
self.stderr:read_start(function(err, chunk)
if err then
self:handle_error(callback, "Error reading stderr: " .. err)
return
end
if chunk then
self.error_msg = self.error_msg .. chunk
end
end)
end
function Request:execute(callback)
self.handle = vim.loop.spawn('curl', {
args = {
'-s',
'-X', 'POST',
'-H', 'Content-Type: application/json',
'-d', self.payload,
self.url
},
stdio = {nil, self.stdout, self.stderr}
}, function(exit_code)
self:cleanup()
if exit_code ~= 0 then
vim.schedule(function()
callback(nil, "Curl failed with code " .. exit_code .. ": " .. self.error_msg)
end)
return
end
local success, decoded = pcall(vim.json.decode, self.response)
vim.schedule(function()
if code ~= 0 then
callback(nil, "Curl failed with code " .. code .. ": " .. error_output)
return
end
-- Debug output
if output == "" then
callback(nil, "Empty response received")
return
end
local success, decoded = pcall(vim.json.decode, output)
if success then
callback(decoded)
else
-- Include the raw output in the error for debugging
callback(nil, string.format("JSON decode error. Raw output: %s", output))
callback(nil, "JSON decode error: " .. self.response)
end
end)
cleanup()
end)
if not handle then
vim.schedule(function()
callback(nil, "Failed to spawn curl process")
end)
cleanup()
if not self.handle then
self:handle_error(callback, "Failed to start curl")
return
end
stdout:read_start(function(err, data)
if err then
vim.schedule(function()
callback(nil, "Error reading stdout: " .. err)
end)
cleanup()
return
end
if data then
output = output .. data
end
end)
stderr:read_start(function(err, data)
if err then
vim.schedule(function()
callback(nil, "Error reading stderr: " .. err)
end)
cleanup()
return
end
if data then
error_output = error_output .. data
end
end)
self:setup_pipes(callback)
end
M.Request = Request

76
lua/gemini/init.lua
View File

@ -3,7 +3,6 @@
local api = require("gemini.api")
local chat = require("gemini.chat")
local config = require("gemini.config")
local completion = require("gemini.completion")
local M = {}
@ -26,7 +25,8 @@ function M.query(prompt, context)
chat.create_window()
local initial_content = "User: " .. prompt .. "\n\nAssistant: Thinking..."
chat.update_content(initial_content, true, true)
chat.update_content(initial_content, true)
vim.cmd('redraw')
api.get_response(prompt, context, function(response, error)
if error then
@ -40,43 +40,47 @@ function M.query(prompt, context)
end
function M.setup(opts)
-- Configure the plugin
config.setup(opts)
-- Set up completion
completion.setup()
-- Enable completion by default for all buffers
vim.api.nvim_create_autocmd("BufEnter", {
pattern = "*",
callback = function()
-- Only enable for specific filetypes
local ft = vim.bo.filetype
if not vim.tbl_contains(config.options.completion.exclude_filetypes, ft) then
vim.b.gemini_completion_enabled = true
end
end
})
-- Add completion trigger keymap
vim.keymap.set('i', '<C-x><C-g>', function()
completion.trigger_completion()
end, { desc = 'Trigger Gemini completion' })
end
function M.complete(findstart, base)
if findstart == 1 then
local line = vim.api.nvim_get_current_line()
local col = vim.api.nvim_win_get_cursor(0)[2]
local start = col
while start > 0 and string.match(line:sub(start, start), "[%w_]") do
start = start - 1
-- Ensure markdown parser is installed
pcall(vim.treesitter.language.require_language, "markdown")
-- Create commands
vim.api.nvim_create_user_command("Gemini", function(opts)
if opts.args == "" then
vim.notify("Please provide a prompt for Gemini.", vim.log.levels.WARN)
return
end
return start
else
-- Don't return "Loading..." immediately
-- Instead, return empty list and let completion handle it
return {}
end
M.query(opts.args)
end, {
desc = "Query Google AI",
nargs = "+",
complete = "shellcmd",
})
vim.api.nvim_create_user_command("GeminiClearChat", function()
api.clear_conversation()
chat.clear()
vim.notify("Chat history cleared", vim.log.levels.INFO)
end, {
desc = "Clear Gemini chat history"
})
-- Set up default keymaps
vim.keymap.set("n", "<leader>gc", function()
M.prompt_query()
end, { desc = "Chat with Gemini AI" })
vim.keymap.set("n", "<leader>gs", function()
M.prompt_query(get_current_buffer_content())
end, { desc = "Chat with Gemini AI (with buffer context)" })
vim.keymap.set("n", "<leader>gq", function()
api.clear_conversation()
chat.clear()
vim.notify("Chat history cleared", vim.log.levels.INFO)
end, { desc = "Clear Gemini chat history" })
end
return M