From 9054ba178f6033a8637f89999f3a8cd39a5be4da Mon Sep 17 00:00:00 2001
From: Jonas Widen <jonas.widen@widens.eu>
Date: Sun, 16 Mar 2025 18:31:40 +0100
Subject: [PATCH 1/9] try to use nvim http client instead of curl

---
 lua/gemini/api.lua  | 189 ++++++++++++++++++++++++++------------------
 lua/gemini/init.lua |  37 +++++----
 2 files changed, 130 insertions(+), 96 deletions(-)

diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index 0de6338..a9da6d8 100644
--- a/lua/gemini/api.lua
+++ b/lua/gemini/api.lua
@@ -5,37 +5,92 @@ local M = {}
 -- Store conversation history
 local conversation_history = {}
 
+-- Helper function to get API key
 local function get_api_key()
-	-- Check for environment variable
-	local api_key = os.getenv("GEMINI_API_KEY")
-	if api_key then
-		return api_key
-	end
-
-	-- Check for Neovim global variable
-	api_key = vim.g.gemini_api_key
-	if api_key then
-		return api_key
-	end
-
-	return nil -- API key not found
+	return vim.g.gemini_api_key or os.getenv("GEMINI_API_KEY")
 end
 
-local function make_request(prompt, context)
-	local api_key = get_api_key()
+-- Async HTTP request function
+local function async_request(url, payload, callback)
+	local host, port = vim.uri_from_fname(url):match("^https://([^/]+)(/.*)$")
+	local client = vim.loop.new_tcp()
+	
+	client:connect(host, 443, function(err)
+		if err then 
+			vim.schedule(function()
+				callback(nil, "Connection error: " .. err)
+			end)
+			return
+		end
 
-	if not api_key then
-		vim.notify(
-			"Google AI API key not set. Set GEMINI_API_KEY environment variable or g.gemini_api_key in your init.vim or init.lua.",
-			vim.log.levels.ERROR
+		local ssl = vim.loop.new_tls()
+		ssl:wrap(client)
+		
+		local request = string.format(
+			"POST %s HTTP/1.1\r\n" ..
+			"Host: %s\r\n" ..
+			"Content-Type: application/json\r\n" ..
+			"Content-Length: %d\r\n" ..
+			"\r\n" ..
+			"%s",
+			port, host, #payload, payload
 		)
-		return nil
+		
+		local response = ""
+		
+		ssl:write(request, function(err)
+			if err then
+				vim.schedule(function()
+					callback(nil, "Write error: " .. err)
+				end)
+				return
+			end
+			
+			ssl:read_start(function(err, chunk)
+				if err then
+					vim.schedule(function()
+						callback(nil, "Read error: " .. err)
+					end)
+					return
+				end
+				
+				if chunk then
+					response = response .. chunk
+				else
+					-- Connection closed, process response
+					local body = response:match("\r\n\r\n(.+)$")
+					local success, decoded = pcall(vim.json.decode, body)
+					
+					vim.schedule(function()
+						if success then
+							callback(decoded)
+						else
+							callback(nil, "JSON decode error: " .. body)
+						end
+					end)
+					
+					ssl:close()
+					client:close()
+				end
+			end)
+		end)
+	end)
+end
+
+function M.get_response(prompt, context, callback)
+	local api_key = get_api_key()
+	
+	if not api_key then
+		vim.schedule(function()
+			callback(nil, "API key not set")
+		end)
+		return
 	end
 
 	local model = "gemini-2.0-flash"
 	local contents = {}
 	
-	-- Add conversation history to the request
+	-- Add conversation history
 	for _, message in ipairs(conversation_history) do
 		table.insert(contents, {
 			role = message.role,
@@ -45,7 +100,7 @@ local function make_request(prompt, context)
 		})
 	end
 
-	-- Add the current prompt
+	-- Add current prompt
 	if context then
 		table.insert(contents, {
 			role = "user",
@@ -62,77 +117,53 @@ local function make_request(prompt, context)
 		})
 	end
 
-	local payload = vim.json.encode({
-		contents = contents,
-	})
-
-	-- Escape the payload for shell
-	payload = vim.fn.shellescape(payload)
-
-	local command = string.format(
-		"curl -s -X POST "
-			.. "'https://generativelanguage.googleapis.com/v1/models/%s:generateContent?key=%s' "
-			.. "-H 'Content-Type: application/json' "
-			.. "-d %s",
-		model,
-		api_key,
-		payload
-	)
-
-	local result = vim.fn.system(command)
-
-	-- Check for errors during the curl execution
-	if vim.v.shell_error ~= 0 then
-		vim.notify("Error executing curl. Check your command and ensure curl is installed.", vim.log.levels.ERROR)
-		return nil
-	end
-
-	local success, decoded_result = pcall(vim.json.decode, result)
-	if not success then
-		vim.notify("Failed to decode API response: " .. result, vim.log.levels.ERROR)
-		return nil
-	end
-
-	return decoded_result
-end
-
-function M.get_response(prompt, context)
-	-- Add user message to history
+	-- Store prompt in history
 	table.insert(conversation_history, {
 		role = "user",
 		content = prompt
 	})
 
-	local result = make_request(prompt, context)
+	local payload = vim.json.encode({
+		contents = contents,
+	})
 
-	if result then
-		if result.error then
-			vim.notify("API Error: " .. vim.inspect(result.error), vim.log.levels.ERROR)
-			return nil
+	local url = string.format(
+		"https://generativelanguage.googleapis.com/v1/models/%s:generateContent?key=%s",
+		model,
+		api_key
+	)
+
+	async_request(url, payload, function(result, error)
+		if error then
+			callback(nil, error)
+			return
 		end
 
-		if
-			result.candidates
-			and result.candidates[1]
-			and result.candidates[1].content
-			and result.candidates[1].content.parts
-			and result.candidates[1].content.parts[1]
-			and result.candidates[1].content.parts[1].text
-		then
+		if result.error then
+			callback(nil, "API Error: " .. vim.inspect(result.error))
+			return
+		end
+
+		if result.candidates and
+		   result.candidates[1] and
+		   result.candidates[1].content and
+		   result.candidates[1].content.parts and
+		   result.candidates[1].content.parts[1] and
+		   result.candidates[1].content.parts[1].text then
+			
 			local response_text = result.candidates[1].content.parts[1].text
-			-- Add assistant response to history
+			
+			-- Store response in history
 			table.insert(conversation_history, {
 				role = "model",
 				content = response_text
 			})
-			return response_text
+			
+			callback(response_text)
+		else
+			callback(nil, "Unexpected response structure")
 		end
-		
-		vim.notify("Unexpected response structure: " .. vim.inspect(result), vim.log.levels.ERROR)
-	end
-	
-	vim.notify("No response from Google AI API or malformed response.", vim.log.levels.ERROR)
-	return nil
+	end)
 end
 
 -- Add function to clear conversation history
diff --git a/lua/gemini/init.lua b/lua/gemini/init.lua
index 49c3446..a968846 100644
--- a/lua/gemini/init.lua
+++ b/lua/gemini/init.lua
@@ -161,15 +161,31 @@ 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
+    -- Show initial message in chat window
     local initial_content = "User: " .. 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
+    -- 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
         vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
         
@@ -204,20 +220,7 @@ local function gemini_query(prompt, context)
         
         -- 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 = 1, #lines do
-            if lines[i] == "Assistant: Thinking..." then
-                lines[i] = "Assistant: Failed to get response from Gemini API"
-                vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
-                vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, lines)
-                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)
 end
 
 -- Make gemini_query available in M so it can be used by the setup function

From 6a3d4844869c6dac5804093f0b191230fa2993b2 Mon Sep 17 00:00:00 2001
From: Jonas Widen <jonas.widen@widens.eu>
Date: Sun, 16 Mar 2025 18:33:46 +0100
Subject: [PATCH 2/9] Fixed crash

---
 lua/gemini/api.lua | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index a9da6d8..687d093 100644
--- a/lua/gemini/api.lua
+++ b/lua/gemini/api.lua
@@ -12,7 +12,17 @@ end
 
 -- Async HTTP request function
 local function async_request(url, payload, callback)
-	local host, port = vim.uri_from_fname(url):match("^https://([^/]+)(/.*)$")
+	-- Parse URL properly
+	local host = url:match("^https://([^/]+)")
+	local path = url:match("^https://[^/]+(.*)$")
+	
+	if not host or not path then
+		vim.schedule(function()
+			callback(nil, "Invalid URL format")
+		end)
+		return
+	end
+
 	local client = vim.loop.new_tcp()
 	
 	client:connect(host, 443, function(err)
@@ -33,7 +43,7 @@ local function async_request(url, payload, callback)
 			"Content-Length: %d\r\n" ..
 			"\r\n" ..
 			"%s",
-			port, host, #payload, payload
+			path, host, #payload, payload
 		)
 		
 		local response = ""

From f299d0fae792383d7bef2f8970118afb5a064696 Mon Sep 17 00:00:00 2001
From: Jonas Widen <jonas.widen@widens.eu>
Date: Sun, 16 Mar 2025 18:34:42 +0100
Subject: [PATCH 3/9] Fixed crash

---
 lua/gemini/api.lua | 103 +++++++++++++++++++++++++++------------------
 1 file changed, 62 insertions(+), 41 deletions(-)

diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index 687d093..f1d4564 100644
--- a/lua/gemini/api.lua
+++ b/lua/gemini/api.lua
@@ -23,65 +23,86 @@ local function async_request(url, payload, callback)
 		return
 	end
 
-	local client = vim.loop.new_tcp()
-	
-	client:connect(host, 443, function(err)
-		if err then 
+	-- Resolve hostname to IP
+	vim.loop.getaddrinfo(host, "443", {
+		family = "inet",
+		socktype = "stream",
+		protocol = "tcp"
+	}, function(err, res)
+		if err then
 			vim.schedule(function()
-				callback(nil, "Connection error: " .. err)
+				callback(nil, "DNS resolution error: " .. err)
 			end)
 			return
 		end
 
-		local ssl = vim.loop.new_tls()
-		ssl:wrap(client)
+		if not res or #res == 0 then
+			vim.schedule(function()
+				callback(nil, "Could not resolve hostname")
+			end)
+			return
+		end
+
+		local client = vim.loop.new_tcp()
 		
-		local request = string.format(
-			"POST %s HTTP/1.1\r\n" ..
-			"Host: %s\r\n" ..
-			"Content-Type: application/json\r\n" ..
-			"Content-Length: %d\r\n" ..
-			"\r\n" ..
-			"%s",
-			path, host, #payload, payload
-		)
-		
-		local response = ""
-		
-		ssl:write(request, function(err)
-			if err then
+		client:connect(res[1].addr, res[1].port, function(err)
+			if err then 
 				vim.schedule(function()
-					callback(nil, "Write error: " .. err)
+					callback(nil, "Connection error: " .. err)
 				end)
 				return
 			end
+
+			local ssl = vim.loop.new_tls()
+			ssl:wrap(client)
 			
-			ssl:read_start(function(err, chunk)
+			local request = string.format(
+				"POST %s HTTP/1.1\r\n" ..
+				"Host: %s\r\n" ..
+				"Content-Type: application/json\r\n" ..
+				"Content-Length: %d\r\n" ..
+				"\r\n" ..
+				"%s",
+				path, host, #payload, payload
+			)
+			
+			local response = ""
+			
+			ssl:write(request, function(err)
 				if err then
 					vim.schedule(function()
-						callback(nil, "Read error: " .. err)
+						callback(nil, "Write error: " .. err)
 					end)
 					return
 				end
 				
-				if chunk then
-					response = response .. chunk
-				else
-					-- Connection closed, process response
-					local body = response:match("\r\n\r\n(.+)$")
-					local success, decoded = pcall(vim.json.decode, body)
+				ssl:read_start(function(err, chunk)
+					if err then
+						vim.schedule(function()
+							callback(nil, "Read error: " .. err)
+						end)
+						return
+					end
 					
-					vim.schedule(function()
-						if success then
-							callback(decoded)
-						else
-							callback(nil, "JSON decode error: " .. body)
-						end
-					end)
-					
-					ssl:close()
-					client:close()
-				end
+					if chunk then
+						response = response .. chunk
+					else
+						-- Connection closed, process response
+						local body = response:match("\r\n\r\n(.+)$")
+						local success, decoded = pcall(vim.json.decode, body)
+						
+						vim.schedule(function()
+							if success then
+								callback(decoded)
+							else
+								callback(nil, "JSON decode error: " .. body)
+							end
+						end)
+						
+						ssl:close()
+						client:close()
+					end
+				end)
 			end)
 		end)
 	end)

From 9d3f4c8bffeff81db0b5f1f7f06c8ff8b479c9d3 Mon Sep 17 00:00:00 2001
From: Jonas Widen <jonas.widen@widens.eu>
Date: Sun, 16 Mar 2025 18:35:50 +0100
Subject: [PATCH 4/9] Fixed crash

---
 lua/gemini/api.lua | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index f1d4564..c3d2c76 100644
--- a/lua/gemini/api.lua
+++ b/lua/gemini/api.lua
@@ -53,8 +53,8 @@ local function async_request(url, payload, callback)
 				return
 			end
 
-			local ssl = vim.loop.new_tls()
-			ssl:wrap(client)
+			-- Create TLS wrapper
+			local tls_client = vim.loop.new_tls_wrap(client)
 			
 			local request = string.format(
 				"POST %s HTTP/1.1\r\n" ..
@@ -68,7 +68,7 @@ local function async_request(url, payload, callback)
 			
 			local response = ""
 			
-			ssl:write(request, function(err)
+			tls_client:write(request, function(err)
 				if err then
 					vim.schedule(function()
 						callback(nil, "Write error: " .. err)
@@ -76,7 +76,7 @@ local function async_request(url, payload, callback)
 					return
 				end
 				
-				ssl:read_start(function(err, chunk)
+				tls_client:read_start(function(err, chunk)
 					if err then
 						vim.schedule(function()
 							callback(nil, "Read error: " .. err)
@@ -99,7 +99,7 @@ local function async_request(url, payload, callback)
 							end
 						end)
 						
-						ssl:close()
+						tls_client:close()
 						client:close()
 					end
 				end)

From cc5b5f4e13dafbad9c9b6e1a8781b61da6978830 Mon Sep 17 00:00:00 2001
From: Jonas Widen <jonas.widen@widens.eu>
Date: Sun, 16 Mar 2025 18:37:14 +0100
Subject: [PATCH 5/9] Fixed crash

---
 lua/gemini/api.lua | 137 +++++++++++++++++++++------------------------
 1 file changed, 63 insertions(+), 74 deletions(-)

diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index c3d2c76..1c7bada 100644
--- a/lua/gemini/api.lua
+++ b/lua/gemini/api.lua
@@ -12,98 +12,87 @@ end
 
 -- Async HTTP request function
 local function async_request(url, payload, callback)
-	-- Parse URL properly
-	local host = url:match("^https://([^/]+)")
-	local path = url:match("^https://[^/]+(.*)$")
+	-- Create a temporary file for the response
+	local temp_file = vim.fn.tempname()
 	
-	if not host or not path then
+	-- Construct curl command
+	local curl_cmd = string.format(
+		'curl -s -X POST -H "Content-Type: application/json" -d %s %s',
+		vim.fn.shellescape(payload),
+		vim.fn.shellescape(url)
+	)
+
+	-- Create job
+	local stdout = vim.loop.new_pipe()
+	local stderr = vim.loop.new_pipe()
+	
+	local handle
+	handle = vim.loop.spawn('curl', {
+		args = {
+			'-s',
+			'-X', 'POST',
+			'-H', 'Content-Type: application/json',
+			'-d', payload,
+			url
+		},
+		stdio = {nil, stdout, stderr}
+	}, function(code)
+		stdout:close()
+		stderr:close()
+		handle:close()
+	end)
+
+	if not handle then
 		vim.schedule(function()
-			callback(nil, "Invalid URL format")
+			callback(nil, "Failed to start curl")
 		end)
 		return
 	end
 
-	-- Resolve hostname to IP
-	vim.loop.getaddrinfo(host, "443", {
-		family = "inet",
-		socktype = "stream",
-		protocol = "tcp"
-	}, function(err, res)
+	local response = ""
+	local error_msg = ""
+
+	stdout:read_start(function(err, chunk)
 		if err then
 			vim.schedule(function()
-				callback(nil, "DNS resolution error: " .. err)
+				callback(nil, "Read error: " .. err)
 			end)
 			return
 		end
+		if chunk then
+			response = response .. chunk
+		end
+	end)
 
-		if not res or #res == 0 then
+	stderr:read_start(function(err, chunk)
+		if err then
 			vim.schedule(function()
-				callback(nil, "Could not resolve hostname")
+				callback(nil, "Error reading stderr: " .. err)
+			end)
+			return
+		end
+		if chunk then
+			error_msg = error_msg .. chunk
+		end
+	end)
+
+	-- When everything is done
+	handle:on('exit', function(code)
+		if code ~= 0 then
+			vim.schedule(function()
+				callback(nil, "Curl failed: " .. error_msg)
 			end)
 			return
 		end
 
-		local client = vim.loop.new_tcp()
-		
-		client:connect(res[1].addr, res[1].port, function(err)
-			if err then 
-				vim.schedule(function()
-					callback(nil, "Connection error: " .. err)
-				end)
-				return
+		-- Try to parse the response
+		local success, decoded = pcall(vim.json.decode, response)
+		vim.schedule(function()
+			if success then
+				callback(decoded)
+			else
+				callback(nil, "JSON decode error: " .. response)
 			end
-
-			-- Create TLS wrapper
-			local tls_client = vim.loop.new_tls_wrap(client)
-			
-			local request = string.format(
-				"POST %s HTTP/1.1\r\n" ..
-				"Host: %s\r\n" ..
-				"Content-Type: application/json\r\n" ..
-				"Content-Length: %d\r\n" ..
-				"\r\n" ..
-				"%s",
-				path, host, #payload, payload
-			)
-			
-			local response = ""
-			
-			tls_client:write(request, function(err)
-				if err then
-					vim.schedule(function()
-						callback(nil, "Write error: " .. err)
-					end)
-					return
-				end
-				
-				tls_client:read_start(function(err, chunk)
-					if err then
-						vim.schedule(function()
-							callback(nil, "Read error: " .. err)
-						end)
-						return
-					end
-					
-					if chunk then
-						response = response .. chunk
-					else
-						-- Connection closed, process response
-						local body = response:match("\r\n\r\n(.+)$")
-						local success, decoded = pcall(vim.json.decode, body)
-						
-						vim.schedule(function()
-							if success then
-								callback(decoded)
-							else
-								callback(nil, "JSON decode error: " .. body)
-							end
-						end)
-						
-						tls_client:close()
-						client:close()
-					end
-				end)
-			end)
 		end)
 	end)
 end

From 05906e65ba83eb2fd30f5f3557c84777f1557c52 Mon Sep 17 00:00:00 2001
From: Jonas Widen <jonas.widen@widens.eu>
Date: Sun, 16 Mar 2025 18:38:31 +0100
Subject: [PATCH 6/9] Fixed crash

---
 lua/gemini/api.lua | 94 +++++++++++++++++++++-------------------------
 1 file changed, 42 insertions(+), 52 deletions(-)

diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index 1c7bada..bc62d30 100644
--- a/lua/gemini/api.lua
+++ b/lua/gemini/api.lua
@@ -12,22 +12,15 @@ end
 
 -- Async HTTP request function
 local function async_request(url, payload, callback)
-	-- Create a temporary file for the response
-	local temp_file = vim.fn.tempname()
-	
-	-- Construct curl command
-	local curl_cmd = string.format(
-		'curl -s -X POST -H "Content-Type: application/json" -d %s %s',
-		vim.fn.shellescape(payload),
-		vim.fn.shellescape(url)
-	)
+	local response = ""
+	local error_msg = ""
 
-	-- Create job
+	-- Create pipes for stdout and stderr
 	local stdout = vim.loop.new_pipe()
 	local stderr = vim.loop.new_pipe()
 	
-	local handle
-	handle = vim.loop.spawn('curl', {
+	-- Spawn curl process
+	local handle = vim.loop.spawn('curl', {
 		args = {
 			'-s',
 			'-X', 'POST',
@@ -36,51 +29,15 @@ local function async_request(url, payload, callback)
 			url
 		},
 		stdio = {nil, stdout, stderr}
-	}, function(code)
+	}, function(exit_code, signal)  -- This is the exit callback
+		-- Close all handles
 		stdout:close()
 		stderr:close()
 		handle:close()
-	end)
 
-	if not handle then
-		vim.schedule(function()
-			callback(nil, "Failed to start curl")
-		end)
-		return
-	end
-
-	local response = ""
-	local error_msg = ""
-
-	stdout:read_start(function(err, chunk)
-		if err then
+		if exit_code ~= 0 then
 			vim.schedule(function()
-				callback(nil, "Read error: " .. err)
-			end)
-			return
-		end
-		if chunk then
-			response = response .. chunk
-		end
-	end)
-
-	stderr:read_start(function(err, chunk)
-		if err then
-			vim.schedule(function()
-				callback(nil, "Error reading stderr: " .. err)
-			end)
-			return
-		end
-		if chunk then
-			error_msg = error_msg .. chunk
-		end
-	end)
-
-	-- When everything is done
-	handle:on('exit', function(code)
-		if code ~= 0 then
-			vim.schedule(function()
-				callback(nil, "Curl failed: " .. error_msg)
+				callback(nil, "Curl failed with code " .. exit_code .. ": " .. error_msg)
 			end)
 			return
 		end
@@ -95,6 +52,39 @@ local function async_request(url, payload, callback)
 			end
 		end)
 	end)
+
+	if not handle then
+		vim.schedule(function()
+			callback(nil, "Failed to start curl")
+		end)
+		return
+	end
+
+	-- Handle stdout data
+	stdout:read_start(function(err, chunk)
+		if err then
+			vim.schedule(function()
+				callback(nil, "Read error: " .. err)
+			end)
+			return
+		end
+		if chunk then
+			response = response .. chunk
+		end
+	end)
+
+	-- Handle stderr data
+	stderr:read_start(function(err, chunk)
+		if err then
+			vim.schedule(function()
+				callback(nil, "Error reading stderr: " .. err)
+			end)
+			return
+		end
+		if chunk then
+			error_msg = error_msg .. chunk
+		end
+	end)
 end
 
 function M.get_response(prompt, context, callback)

From 838a1b4e51fcbd13aee9979577ea73b0a676f326 Mon Sep 17 00:00:00 2001
From: Jonas Widen <jonas.widen@widens.eu>
Date: Sun, 16 Mar 2025 18:39:52 +0100
Subject: [PATCH 7/9] Fixed crash

---
 lua/gemini/api.lua | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index bc62d30..bf3a55f 100644
--- a/lua/gemini/api.lua
+++ b/lua/gemini/api.lua
@@ -19,8 +19,15 @@ local function async_request(url, payload, callback)
 	local stdout = vim.loop.new_pipe()
 	local stderr = vim.loop.new_pipe()
 	
-	-- Spawn curl process
-	local handle = vim.loop.spawn('curl', {
+	-- Spawn curl process with handle in broader scope
+	local handle
+	local function cleanup()
+		if stdout then stdout:close() end
+		if stderr then stderr:close() end
+		if handle then handle:close() end
+	end
+
+	handle = vim.loop.spawn('curl', {
 		args = {
 			'-s',
 			'-X', 'POST',
@@ -30,10 +37,8 @@ local function async_request(url, payload, callback)
 		},
 		stdio = {nil, stdout, stderr}
 	}, function(exit_code, signal)  -- This is the exit callback
-		-- Close all handles
-		stdout:close()
-		stderr:close()
-		handle:close()
+		-- Clean up handles
+		cleanup()
 
 		if exit_code ~= 0 then
 			vim.schedule(function()
@@ -54,6 +59,7 @@ local function async_request(url, payload, callback)
 	end)
 
 	if not handle then
+		cleanup()
 		vim.schedule(function()
 			callback(nil, "Failed to start curl")
 		end)
@@ -63,6 +69,7 @@ local function async_request(url, payload, callback)
 	-- Handle stdout data
 	stdout:read_start(function(err, chunk)
 		if err then
+			cleanup()
 			vim.schedule(function()
 				callback(nil, "Read error: " .. err)
 			end)
@@ -76,6 +83,7 @@ local function async_request(url, payload, callback)
 	-- Handle stderr data
 	stderr:read_start(function(err, chunk)
 		if err then
+			cleanup()
 			vim.schedule(function()
 				callback(nil, "Error reading stderr: " .. err)
 			end)

From 9e2bc5e1e4e1be3140c8d7abaf103ef1133b851b Mon Sep 17 00:00:00 2001
From: Jonas Widen <jonas.widen@widens.eu>
Date: Sun, 16 Mar 2025 18:44:52 +0100
Subject: [PATCH 8/9] Refactor code

---
 lua/gemini/api.lua | 250 +++++++++++++++++++++++----------------------
 1 file changed, 127 insertions(+), 123 deletions(-)

diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index bf3a55f..20f4f8d 100644
--- a/lua/gemini/api.lua
+++ b/lua/gemini/api.lua
@@ -10,91 +10,154 @@ local function get_api_key()
 	return vim.g.gemini_api_key or os.getenv("GEMINI_API_KEY")
 end
 
--- Async HTTP request function
-local function async_request(url, payload, callback)
-	local response = ""
-	local error_msg = ""
+-- Create a Request class to handle HTTP requests
+local Request = {}
+Request.__index = Request
 
-	-- Create pipes for stdout and stderr
-	local stdout = vim.loop.new_pipe()
-	local stderr = vim.loop.new_pipe()
-	
-	-- Spawn curl process with handle in broader scope
-	local handle
-	local function cleanup()
-		if stdout then stdout:close() end
-		if stderr then stderr:close() end
-		if handle then handle:close() end
-	end
+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
 
-	handle = vim.loop.spawn('curl', {
+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', payload,
-			url
+			'-d', self.payload,
+			self.url
 		},
-		stdio = {nil, stdout, stderr}
-	}, function(exit_code, signal)  -- This is the exit callback
-		-- Clean up handles
-		cleanup()
+		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 .. ": " .. error_msg)
+				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, response)
+		local success, decoded = pcall(vim.json.decode, self.response)
 		vim.schedule(function()
 			if success then
 				callback(decoded)
 			else
-				callback(nil, "JSON decode error: " .. response)
+				callback(nil, "JSON decode error: " .. self.response)
 			end
 		end)
 	end)
 
-	if not handle then
-		cleanup()
-		vim.schedule(function()
-			callback(nil, "Failed to start curl")
-		end)
+	if not self.handle then
+		self:handle_error(callback, "Failed to start curl")
 		return
 	end
 
-	-- Handle stdout data
-	stdout:read_start(function(err, chunk)
-		if err then
-			cleanup()
-			vim.schedule(function()
-				callback(nil, "Read error: " .. err)
-			end)
-			return
-		end
-		if chunk then
-			response = response .. chunk
-		end
-	end)
-
-	-- Handle stderr data
-	stderr:read_start(function(err, chunk)
-		if err then
-			cleanup()
-			vim.schedule(function()
-				callback(nil, "Error reading stderr: " .. err)
-			end)
-			return
-		end
-		if chunk then
-			error_msg = error_msg .. chunk
-		end
-	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,
+			parts = {{text = message.content}}
+		})
+	end
+
+	-- Add current prompt
+	if context then
+		table.insert(contents, {
+			role = "user",
+			parts = {{text = "Context:\n" .. context .. "\n\nQuery: " .. prompt}}
+		})
+	else
+		table.insert(contents, {
+			role = "user",
+			parts = {{text = prompt}}
+		})
+	end
+
+	return contents
+end
+
+function Message.store_message(role, content)
+	table.insert(conversation_history, {role = role, content = content})
+end
+
+function Message.handle_response(result, callback)
+	if result.error then
+		callback(nil, "API Error: " .. vim.inspect(result.error))
+		return
+	end
+
+	if result.candidates and
+	   result.candidates[1] and
+	   result.candidates[1].content and
+	   result.candidates[1].content.parts and
+	   result.candidates[1].content.parts[1] and
+	   result.candidates[1].content.parts[1].text then
+		
+		local response_text = result.candidates[1].content.parts[1].text
+		Message.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()
 	
@@ -105,86 +168,27 @@ function M.get_response(prompt, context, callback)
 		return
 	end
 
-	local model = "gemini-2.0-flash"
-	local contents = {}
-	
-	-- Add conversation history
-	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",
-			parts = {{
-				text = "Context:\n" .. context .. "\n\nQuery: " .. prompt
-			}}
-		})
-	else
-		table.insert(contents, {
-			role = "user",
-			parts = {{
-				text = prompt
-			}}
-		})
-	end
-
 	-- Store prompt in history
-	table.insert(conversation_history, {
-		role = "user",
-		content = prompt
-	})
-
-	local payload = vim.json.encode({
-		contents = contents,
-	})
+	Message.store_message("user", prompt)
 
+	local contents = Message.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",
-		model,
+		"gemini-2.0-flash",
 		api_key
 	)
 
-	async_request(url, payload, function(result, error)
+	local request = Request.new(url, payload)
+	request:execute(function(result, error)
 		if error then
 			callback(nil, error)
 			return
 		end
-
-		if result.error then
-			callback(nil, "API Error: " .. vim.inspect(result.error))
-			return
-		end
-
-		if result.candidates and
-		   result.candidates[1] and
-		   result.candidates[1].content and
-		   result.candidates[1].content.parts and
-		   result.candidates[1].content.parts[1] and
-		   result.candidates[1].content.parts[1].text then
-			
-			local response_text = result.candidates[1].content.parts[1].text
-			
-			-- Store response in history
-			table.insert(conversation_history, {
-				role = "model",
-				content = response_text
-			})
-			
-			callback(response_text)
-		else
-			callback(nil, "Unexpected response structure")
-		end
+		Message.handle_response(result, callback)
 	end)
 end
 
--- Add function to clear conversation history
 function M.clear_conversation()
 	conversation_history = {}
 end

From ec2f8862d9d8422211f7daa831c64efd5aecc6af Mon Sep 17 00:00:00 2001
From: Jonas Widen <jonas.widen@widens.eu>
Date: Sun, 16 Mar 2025 18:50:48 +0100
Subject: [PATCH 9/9] More refactoring

---
 lua/gemini/api.lua    | 124 ++------------------
 lua/gemini/chat.lua   | 145 +++++++++++++++++++++++
 lua/gemini/config.lua |  30 +++++
 lua/gemini/http.lua   |  93 +++++++++++++++
 lua/gemini/init.lua   | 264 +++++-------------------------------------
 5 files changed, 307 insertions(+), 349 deletions(-)
 create mode 100644 lua/gemini/chat.lua
 create mode 100644 lua/gemini/config.lua
 create mode 100644 lua/gemini/http.lua

diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index 20f4f8d..f92e1c0 100644
--- a/lua/gemini/api.lua
+++ b/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 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 function 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
-	Message.store_message("user", prompt)
+	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",
-		"gemini-2.0-flash",
+		config.options.api_url .. "?key=%s",
+		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
 
diff --git a/lua/gemini/chat.lua b/lua/gemini/chat.lua
new file mode 100644
index 0000000..b988541
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/lua/gemini/config.lua b/lua/gemini/config.lua
new file mode 100644
index 0000000..d0d1c41
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/lua/gemini/http.lua b/lua/gemini/http.lua
new file mode 100644
index 0000000..f0a4a7d
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/lua/gemini/init.lua b/lua/gemini/init.lua
index a968846..5aa34eb 100644
--- a/lua/gemini/init.lua
+++ b/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 chat_bufnr = nil
-local chat_winnr = nil
-local current_context = nil  -- Store the current context
+local M = {}
 
 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 })
+function M.prompt_query(context)
+    local prompt = context and "Gemini (with buffer context): " or "Gemini: "
+    vim.ui.input({ prompt = prompt }, function(input)
+        if input then
+            M.query(input, context)
         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)
 end
 
-local function gemini_query(prompt, context)
-    -- Store the context for subsequent queries
-    current_context = context
+function M.query(prompt, context)
+    chat.set_context(context)
+    chat.create_window()
     
-    -- Show initial message in chat window
     local initial_content = "User: " .. prompt .. "\n\nAssistant: Thinking..."
-    update_chat_window(initial_content)
-    
-    -- Force Neovim to update the screen
+    chat.update_content(initial_content, true)
     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
-        vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', 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 ""')
+        local content = "User: " .. prompt .. "\n\nAssistant: " .. response
+        chat.update_content(content, true)
     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(opts)
+    -- Configure the plugin
+    config.setup(opts)
 
-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
+    pcall(vim.treesitter.language.require_language, "markdown")
 
-    -- Create the user command
+    -- Create commands
     vim.api.nvim_create_user_command("Gemini", function(opts)
-        local prompt = opts.args
-        if prompt == "" then
+        if opts.args == "" 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
-            vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, {})
-        end
+        chat.clear()
         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)
-            if input then
-                M.gemini_query(input)
-            end
-        end)
+        M.prompt_query()
     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)
+        M.prompt_query(get_current_buffer_content())
     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
+        chat.clear()
         vim.notify("Chat history cleared", vim.log.levels.INFO)
     end, { desc = "Clear Gemini chat history" })
 end