More refactoring

lua/gemini/api.lua

@@ -1,114 +1,17 @@
--- lua/gemini/api.lua
+local config = require("gemini.config")
-
+local http = require("gemini.http")
 local M = {}
 
 -- Store conversation history
 local conversation_history = {}
 
--- Helper function to get API key
 local function get_api_key()
 	return vim.g.gemini_api_key or os.getenv("GEMINI_API_KEY")
 end
 
--- Create a Request class to handle HTTP requests
+local function create_contents(prompt, context)
-local Request = {}
-Request.__index = Request
-
-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: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
-
-function Request:handle_error(callback, msg)
-	self:cleanup()
-	vim.schedule(function()
-		callback(nil, msg)
-	end)
-end
-
-function Request:setup_pipes(callback)
-	-- Handle stdout data
-	self.stdout:read_start(function(err, chunk)
-		if err then
-			self:handle_error(callback, "Read error: " .. err)
-			return
-		end
-		if chunk then
-			self.response = self.response .. chunk
-		end
-	end)
-
-	-- Handle stderr data
-	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
-
-		-- Try to parse the response
-		local success, decoded = pcall(vim.json.decode, self.response)
-		vim.schedule(function()
-			if success then
-				callback(decoded)
-			else
-				callback(nil, "JSON decode error: " .. self.response)
-			end
-		end)
-	end)
-
-	if not self.handle then
-		self:handle_error(callback, "Failed to start curl")
-		return
-	end
-
-	self:setup_pipes(callback)
-end
-
--- Message handling functions
-local Message = {}
-
-function Message.create_contents(prompt, context)
 	local contents = {}
 	
-	-- Add conversation history
 	for _, message in ipairs(conversation_history) do
 		table.insert(contents, {
 			role = message.role,
@@ -116,7 +19,6 @@ function Message.create_contents(prompt, context)
 		})
 	end
 
-	-- Add current prompt
 	if context then
 		table.insert(contents, {
 			role = "user",
@@ -132,11 +34,11 @@ function Message.create_contents(prompt, context)
 	return contents
 end
 
-function Message.store_message(role, content)
+local function store_message(role, content)
 	table.insert(conversation_history, {role = role, content = content})
 end
 
-function Message.handle_response(result, callback)
+local function handle_response(result, callback)
 	if result.error then
 		callback(nil, "API Error: " .. vim.inspect(result.error))
 		return
@@ -150,14 +52,13 @@ function Message.handle_response(result, callback)
 	   result.candidates[1].content.parts[1].text then
 		
 		local response_text = result.candidates[1].content.parts[1].text
-		Message.store_message("model", response_text)
+		store_message("model", response_text)
 		callback(response_text)
 	else
 		callback(nil, "Unexpected response structure")
 	end
 end
 
--- Main API functions
 function M.get_response(prompt, context, callback)
 	local api_key = get_api_key()
 	
@@ -168,24 +69,23 @@ function M.get_response(prompt, context, callback)
 		return
 	end
 
-	-- Store prompt in history
+	store_message("user", prompt)
-	Message.store_message("user", prompt)
 
-	local contents = Message.create_contents(prompt, context)
+	local contents = create_contents(prompt, context)
 	local payload = vim.json.encode({contents = contents})
 	local url = string.format(
-		"https://generativelanguage.googleapis.com/v1/models/%s:generateContent?key=%s",
+		config.options.api_url .. "?key=%s",
-		"gemini-2.0-flash",
+		config.options.model,
 		api_key
 	)
 
-	local request = Request.new(url, payload)
+	local request = http.Request.new(url, payload)
 	request:execute(function(result, error)
 		if error then
 			callback(nil, error)
 			return
 		end
-		Message.handle_response(result, callback)
+		handle_response(result, callback)
 	end)
 end
 

lua/gemini/chat.lua

@@ -0,0 +1,145 @@
+local config = require("gemini.config")
+local M = {}
+
+-- Store chat state
+local state = {
+    bufnr = nil,
+    winnr = nil,
+    current_context = nil,
+}
+
+local function setup_chat_highlighting(bufnr)
+    vim.api.nvim_buf_set_option(bufnr, 'syntax', '')
+    pcall(vim.treesitter.start, bufnr, "markdown")
+
+    vim.cmd([[
+        highlight default GeminiUser guifg=#EBCB8B gui=bold
+        highlight default GeminiSeparator guifg=#616E88 gui=bold
+        syntax match GeminiUser /^User:.*$/
+        syntax match GeminiSeparator /^━━━━━━━━━━━━━━━━━━━━━━━━━━$/
+    ]])
+end
+
+local function setup_buffer_options(bufnr)
+    local options = {
+        buftype = 'nofile',
+        filetype = 'markdown',
+        buflisted = false,
+        swapfile = false,
+        bufhidden = 'wipe',
+        modifiable = false,
+    }
+
+    for option, value in pairs(options) do
+        vim.api.nvim_buf_set_option(bufnr, option, value)
+    end
+end
+
+local function setup_buffer_autocmds(bufnr)
+    local augroup = vim.api.nvim_create_augroup('GeminiChatBuffer', { clear = true })
+    vim.api.nvim_create_autocmd({'BufReadCmd', 'FileReadCmd', 'BufWriteCmd'}, {
+        group = augroup,
+        buffer = bufnr,
+        callback = function()
+            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 }
+    
+    -- 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('Command mode disabled in chat window', vim.log.levels.WARN)
+    end, opts)
+
+    -- Set chat-specific keymaps
+    local mappings = config.options.mappings
+    vim.keymap.set('n', mappings.close, function()
+        vim.api.nvim_win_close(state.winnr, true)
+        state.winnr = nil
+    end, opts)
+
+    vim.keymap.set('n', mappings.return_focus, function()
+        vim.cmd('wincmd p')
+    end, opts)
+
+    vim.keymap.set('n', mappings.new_query, function()
+        require("gemini").prompt_query(state.current_context)
+    end, opts)
+end
+
+function M.create_window()
+    if not state.bufnr or not vim.api.nvim_buf_is_valid(state.bufnr) then
+        state.bufnr = vim.api.nvim_create_buf(false, true)
+        setup_buffer_options(state.bufnr)
+        setup_buffer_autocmds(state.bufnr)
+        setup_buffer_keymaps(state.bufnr)
+    end
+
+    local win_opts = config.options.window
+    if not state.winnr or not vim.api.nvim_win_is_valid(state.winnr) then
+        state.winnr = vim.api.nvim_open_win(state.bufnr, true, {
+            relative = "editor",
+            width = win_opts.width(),
+            height = win_opts.height(),
+            row = 0,
+            col = vim.o.columns - win_opts.width(),
+            border = win_opts.border,
+            title = win_opts.title,
+            title_pos = win_opts.title_pos,
+            style = "minimal"
+        })
+
+        vim.api.nvim_win_set_option(state.winnr, 'wrap', true)
+        vim.api.nvim_win_set_option(state.winnr, 'linebreak', true)
+        vim.api.nvim_win_set_option(state.winnr, 'breakindent', true)
+
+        setup_chat_highlighting(state.bufnr)
+    end
+end
+
+function M.update_content(content, is_new_chat)
+    vim.api.nvim_buf_set_option(state.bufnr, 'modifiable', true)
+
+    if is_new_chat then
+        vim.api.nvim_buf_set_lines(state.bufnr, 0, -1, false, vim.split(content, "\n"))
+    else
+        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
+
+    vim.api.nvim_buf_set_option(state.bufnr, 'modifiable', false)
+
+    -- 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
+
+function M.set_context(context)
+    state.current_context = context
+end
+
+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
+end
+
+return M

lua/gemini/config.lua

@@ -0,0 +1,30 @@
+local M = {}
+
+M.defaults = {
+    model = "gemini-2.0-flash",
+    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,
+        border = "rounded",
+        title = "Gemini Chat Session",
+        title_pos = "center",
+    },
+    mappings = {
+        close = 'q',
+        return_focus = '<Esc>',
+        new_query = 'i',
+    },
+    highlights = {
+        user = "GeminiUser",
+        separator = "GeminiSeparator",
+    },
+}
+
+M.options = {}
+
+function M.setup(opts)
+    M.options = vim.tbl_deep_extend("force", {}, M.defaults, opts or {})
+end
+
+return M

lua/gemini/http.lua

@@ -0,0 +1,93 @@
+local M = {}
+
+-- HTTP Request class
+local Request = {}
+Request.__index = Request
+
+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: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
+
+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
+        if chunk then
+            self.response = self.response .. chunk
+        end
+    end)
+
+    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 success then
+                callback(decoded)
+            else
+                callback(nil, "JSON decode error: " .. self.response)
+            end
+        end)
+    end)
+
+    if not self.handle then
+        self:handle_error(callback, "Failed to start curl")
+        return
+    end
+
+    self:setup_pipes(callback)
+end
+
+M.Request = Request
+return M

lua/gemini/init.lua

@@ -1,294 +1,84 @@
 -- lua/gemini/init.lua
 
 local api = require("gemini.api")
-local M = {}
+local chat = require("gemini.chat")
+local config = require("gemini.config")
 
--- Store the buffer number of the chat window
+local M = {}
-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)
+function M.prompt_query(context)
-    -- Enable treesitter for the buffer
+    local prompt = context and "Gemini (with buffer context): " or "Gemini: "
-    vim.api.nvim_buf_set_option(bufnr, 'syntax', '')
+    vim.ui.input({ prompt = prompt }, function(input)
-    local success = pcall(vim.treesitter.start, bufnr, "markdown")
+        if input then
-    if not success then
+            M.query(input, context)
-        -- 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
-
+    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)
+function M.query(prompt, context)
-    -- Store the context for subsequent queries
+    chat.set_context(context)
-    current_context = context
+    chat.create_window()
     
-    -- Show initial message in chat window
     local initial_content = "User: " .. prompt .. "\n\nAssistant: Thinking..."
-    update_chat_window(initial_content)
+    chat.update_content(initial_content, true)
-    
-    -- Force Neovim to update the screen
     vim.cmd('redraw')
     
-    -- Make async request
     api.get_response(prompt, context, function(response, error)
         if error then
-            -- Replace "Thinking..." with error message
-            local lines = vim.api.nvim_buf_get_lines(chat_bufnr, 0, -1, false)
-            for i = 1, #lines do
-                if lines[i] == "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: Error - " .. error})
-                    vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
-                    break
-                end
-            end
             vim.notify("Failed to get response: " .. error, vim.log.levels.ERROR)
             return
         end
 
-        -- Make buffer modifiable
+        local content = "User: " .. prompt .. "\n\nAssistant: " .. response
-        vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
+        chat.update_content(content, true)
-        
-        -- Get all lines
-        local lines = vim.api.nvim_buf_get_lines(chat_bufnr, 0, -1, false)
-        
-        -- Find and remove the "Thinking..." line
-        for i = 1, #lines do
-            if lines[i] == "Assistant: Thinking..." then
-                -- Remove the "Thinking..." line
-                table.remove(lines, i)
-                -- Insert response lines
-                local response_lines = vim.split(response, "\n")
-                response_lines[1] = "Assistant: " .. response_lines[1]
-                for j = #response_lines, 1, -1 do
-                    table.insert(lines, i, response_lines[j])
-                end
-                break
-            end
-        end
-        
-        -- Update buffer with modified lines
-        vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, lines)
-        
-        -- Make buffer unmodifiable
-        vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
-        
-        -- 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 ""')
     end)
 end
 
--- Make gemini_query available in M so it can be used by the setup function
+function M.setup(opts)
-M.gemini_query = gemini_query
+    -- Configure the plugin
+    config.setup(opts)
 
-function M.setup()
     -- Ensure markdown parser is installed
-    local parser_installed = pcall(vim.treesitter.language.require_language, "markdown")
+    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
+    -- Create commands
     vim.api.nvim_create_user_command("Gemini", function(opts)
-        local prompt = opts.args
+        if opts.args == "" then
-        if prompt == "" then
             vim.notify("Please provide a prompt for Gemini.", vim.log.levels.WARN)
             return
         end
-        M.gemini_query(prompt)
+        M.query(opts.args)
     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
+        chat.clear()
-            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'
+    -- Set up default keymaps
     vim.keymap.set("n", "<leader>gc", function()
-        vim.ui.input({ prompt = "Gemini: " }, function(input)
+        M.prompt_query()
-            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)
+        M.prompt_query(get_current_buffer_content())
-            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
+        chat.clear()
-            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