refactor: enhance logging, improve temp file handling, clean up comments

Change-Id: I28d3cce0c41312fa18c25645194461cc9614bf5d
Signed-off-by: Thomas Kosiewski <[email protected]>

Author: ThomasK33

lua/claudecode/diff.lua

@@ -2,7 +2,6 @@
 -- Manages different diff providers (native Neovim and diffview.nvim) with automatic detection and fallback.
 local M = {}
 
--- Internal state with safe defaults
 local diff_config = {
   diff_provider = "auto",
   diff_opts = {
@@ -29,7 +28,7 @@ function M.get_current_provider()
     if M.is_diffview_available() then
       return "diffview"
     else
-      vim.notify("diffview.nvim not found, falling back to native diff", vim.log.levels.WARN)
+      vim.notify("diffview.nvim not found, falling back to native diff", vim.log.levels.WARN) -- Explain fallback
       return "native"
     end
   else
@@ -40,7 +39,6 @@ end
 --- Setup the diff module with configuration
 -- @param user_diff_config table|nil User configuration for diff functionality
 function M.setup(user_diff_config)
-  -- Simple setup without config module dependency for now
   if user_diff_config then
     diff_config = {
       diff_provider = user_diff_config.diff_provider or diff_config.diff_provider,
@@ -70,13 +68,35 @@ end
 -- @param filename string Base filename for the temporary file
 -- @return string|nil, string|nil The temporary file path and error message
 function M._create_temp_file(content, filename)
-  local tmp_dir = vim.fn.tempname() .. "_claudecode_diff"
-  local ok, err = pcall(vim.fn.mkdir, tmp_dir, "p")
-  if not ok then
-    return nil, "Failed to create temporary directory: " .. tostring(err)
+  local base_dir_cache = vim.fn.stdpath("cache") .. "/claudecode_diffs"
+  local mkdir_ok_cache, mkdir_err_cache = pcall(vim.fn.mkdir, base_dir_cache, "p")
+
+  local final_base_dir
+  if mkdir_ok_cache then
+    final_base_dir = base_dir_cache
+  else
+    local base_dir_temp = vim.fn.stdpath("temp") .. "/claudecode_diffs"
+    local mkdir_ok_temp, mkdir_err_temp = pcall(vim.fn.mkdir, base_dir_temp, "p")
+    if not mkdir_ok_temp then
+      local err_to_report = mkdir_err_temp or mkdir_err_cache or "unknown error creating base temp dir"
+      return nil, "Failed to create base temporary directory: " .. tostring(err_to_report)
+    end
+    final_base_dir = base_dir_temp
+  end
+
+  local session_id_base = vim.fn.fnamemodify(vim.fn.tempname(), ":t") .. "_" .. tostring(os.time()) .. "_" .. tostring(math.random(1000, 9999))
+  local session_id = session_id_base:gsub("[^A-Za-z0-9_-]", "")
+  if session_id == "" then -- Fallback if all characters were problematic, ensuring a directory can be made.
+    session_id = "claudecode_session"
   end
 
-  local tmp_file = tmp_dir .. "/" .. filename
+  local tmp_session_dir = final_base_dir .. "/" .. session_id
+  local mkdir_session_ok, mkdir_session_err = pcall(vim.fn.mkdir, tmp_session_dir, "p")
+  if not mkdir_session_ok then
+    return nil, "Failed to create temporary session directory: " .. tostring(mkdir_session_err)
+  end
+
+  local tmp_file = tmp_session_dir .. "/" .. filename
   local file = io.open(tmp_file, "w")
   if not file then
     return nil, "Failed to create temporary file: " .. tmp_file
@@ -105,82 +125,40 @@ end
 -- @param tab_name string Name for the diff tab/view
 -- @return table Result with provider, tab_name, and success status
 function M._open_native_diff(old_file_path, new_file_path, new_file_contents, tab_name)
-  -- Create temporary file for new content
   local new_filename = vim.fn.fnamemodify(new_file_path, ":t") .. ".new"
   local tmp_file, err = M._create_temp_file(new_file_contents, new_filename)
   if not tmp_file then
     return { provider = "native", tab_name = tab_name, success = false, error = err }
   end
 
-  -- Choose whether to open in current tab or new tab based on configuration
   if diff_config and diff_config.diff_opts and diff_config.diff_opts.open_in_current_tab then
-    -- Save current buffer info for restoration later if needed
     local original_buf = vim.api.nvim_get_current_buf()
-    local _ = vim.api.nvim_buf_get_name(original_buf) -- unused for now but may be needed later
-
-    -- Open the original file in the current buffer
+    local _ = vim.api.nvim_buf_get_name(original_buf) -- Storing original buffer name, though not currently used, might be useful for future enhancements.
     vim.cmd("edit " .. vim.fn.fnameescape(old_file_path))
   else
-    -- Create a new tab for the diff (old behavior)
     vim.cmd("tabnew")
-
-    -- Set the tab name
     vim.api.nvim_buf_set_name(0, tab_name)
-
-    -- Open the original file
     vim.cmd("edit " .. vim.fn.fnameescape(old_file_path))
   end
 
-  -- Enable diff mode
   vim.cmd("diffthis")
 
-  -- Create split based on configuration
   if diff_config and diff_config.diff_opts and diff_config.diff_opts.vertical_split then
     vim.cmd("vertical split")
   else
     vim.cmd("split")
   end
 
-  -- Open the temporary file with new content
   vim.cmd("edit " .. vim.fn.fnameescape(tmp_file))
   vim.api.nvim_buf_set_name(0, new_file_path .. " (New)")
 
-  -- Configure the new content buffer
   local new_buf = vim.api.nvim_get_current_buf()
   vim.api.nvim_set_option_value("buftype", "nofile", { buf = new_buf })
   vim.api.nvim_set_option_value("bufhidden", "wipe", { buf = new_buf })
   vim.api.nvim_set_option_value("swapfile", false, { buf = new_buf })
 
-  -- Enable diff mode
   vim.cmd("diffthis")
 
-  -- Set up buffer-local keymaps for diff navigation and exit (only in current tab mode)
-  if diff_config and diff_config.diff_opts and diff_config.diff_opts.open_in_current_tab then
-    local function setup_diff_keymaps()
-      -- Map <leader>dq to quit diff mode
-      vim.keymap.set("n", "<leader>dq", function()
-        vim.cmd("diffoff!")
-        vim.cmd("wincmd o") -- Close other windows (the diff split)
-        M._cleanup_temp_file(tmp_file)
-        vim.notify("Diff mode exited", vim.log.levels.INFO)
-      end, { buffer = true, desc = "Exit diff mode" })
-
-      -- Map <leader>da to accept all changes (replace current buffer with new content)
-      vim.keymap.set("n", "<leader>da", function()
-        vim.cmd("diffoff!")
-        vim.cmd("wincmd o") -- Close other windows
-        -- Load the new content into the current buffer
-        local lines = vim.split(new_file_contents, "\n")
-        vim.api.nvim_buf_set_lines(0, 0, -1, false, lines)
-        M._cleanup_temp_file(tmp_file)
-        vim.notify("All changes accepted", vim.log.levels.INFO)
-      end, { buffer = true, desc = "Accept all changes" })
-    end
-
-    setup_diff_keymaps()
-  end
-
-  -- Set up autocmd for cleanup when buffers are deleted
   local cleanup_group = vim.api.nvim_create_augroup("ClaudeCodeDiffCleanup", { clear = false })
   vim.api.nvim_create_autocmd({ "BufDelete", "BufWipeout" }, {
     group = cleanup_group,
@@ -191,18 +169,6 @@ function M._open_native_diff(old_file_path, new_file_path, new_file_contents, ta
     once = true,
   })
 
-  -- Show diff info with helpful keymaps
-  vim.defer_fn(function()
-    local message
-    if diff_config and diff_config.diff_opts and diff_config.diff_opts.open_in_current_tab then
-      message =
-        string.format("Diff: %s | Use ]c/[c to navigate, <leader>da to accept all, <leader>dq to exit", tab_name)
-    else
-      message = string.format("Diff: %s | Use ]c/[c to navigate changes, close tab when done", tab_name)
-    end
-    vim.notify(message, vim.log.levels.INFO)
-  end, 100)
-
   return {
     provider = "native",
     tab_name = tab_name,
@@ -218,8 +184,8 @@ end
 -- @param tab_name string Name for the diff tab/view
 -- @return table Result with provider, tab_name, and success status
 function M._open_diffview_diff(old_file_path, new_file_path, new_file_contents, tab_name)
-  -- For now, fall back to native implementation
-  -- This will be properly implemented in Phase 4
+  -- TODO: Implement full diffview.nvim integration (Phase 4)
+  -- For now, fall back to native implementation. This notification informs the user about the current behavior.
   vim.notify("diffview.nvim integration not yet implemented, using native diff", vim.log.levels.INFO)
   return M._open_native_diff(old_file_path, new_file_path, new_file_contents, tab_name)
 end

lua/claudecode/init.lua

@@ -75,7 +75,6 @@ M.state = {
 function M.setup(opts)
   opts = opts or {}
 
-  -- Separate terminal config from main config
   local terminal_opts = nil
   if opts.terminal then
     terminal_opts = opts.terminal
@@ -84,23 +83,26 @@ function M.setup(opts)
 
   local config = require("claudecode.config")
   M.state.config = config.apply(opts)
-  vim.g.claudecode_user_config = vim.deepcopy(M.state.config) -- Make config globally accessible
-
-  if terminal_opts then
-    local terminal_setup_ok, terminal_module = pcall(require, "claudecode.terminal")
-    if terminal_setup_ok then
-      terminal_module.setup(terminal_opts)
-    else
-      vim.notify("Failed to load claudecode.terminal module for setup.", vim.log.levels.ERROR)
-    end
+  -- vim.g.claudecode_user_config is no longer needed as config values are passed directly.
+
+  local logger = require("claudecode.logger")
+  logger.setup(M.state.config)
+
+  -- Setup terminal module: always try to call setup to pass terminal_cmd,
+  -- even if terminal_opts (for split_side etc.) are not provided.
+  local terminal_setup_ok, terminal_module = pcall(require, "claudecode.terminal")
+  if terminal_setup_ok then
+    -- terminal_opts might be nil if user only configured top-level terminal_cmd
+    -- and not specific terminal appearance options.
+    -- The terminal.setup function handles nil for its first argument.
+    terminal_module.setup(terminal_opts, M.state.config.terminal_cmd)
+  else
+    logger.error("init", "Failed to load claudecode.terminal module for setup.")
   end
 
-  -- Setup diff module with configuration
   local diff = require("claudecode.diff")
   diff.setup(M.state.config)
 
-  -- TODO: Set up logger with configured log level
-
   if M.state.config.auto_start then
     M.start(false) -- Suppress notification on auto-start
   end
@@ -150,7 +152,6 @@ function M.start(show_startup_notification)
   local lock_success, lock_result = lockfile.create(M.state.port)
 
   if not lock_success then
-    -- Stop server if lock file creation fails
     server.stop()
     M.state.server = nil
     M.state.port = nil
@@ -161,7 +162,7 @@ function M.start(show_startup_notification)
 
   if M.state.config.track_selection then
     local selection = require("claudecode.selection")
-    selection.enable(server)
+    selection.enable(server, M.state.config.visual_demotion_delay_ms)
   end
 
   if show_startup_notification then
@@ -211,6 +212,8 @@ end
 --- Set up user commands
 ---@private
 function M._create_commands()
+  local logger = require("claudecode.logger")
+
   vim.api.nvim_create_user_command("ClaudeCodeStart", function()
     M.start()
   end, {
@@ -235,19 +238,73 @@ function M._create_commands()
 
   vim.api.nvim_create_user_command("ClaudeCodeSend", function(opts)
     if not M.state.server then
+      logger.error("command", "ClaudeCodeSend: Claude Code integration is not running.")
       vim.notify("Claude Code integration is not running", vim.log.levels.ERROR)
       return
     end
+    logger.debug(
+      "command",
+      "ClaudeCodeSend (new logic) invoked. Mode: "
+        .. vim.fn.mode(1)
+        .. ", Neovim's reported range: "
+        .. tostring(opts and opts.range)
+    )
+    -- We now ignore opts.range and rely on the selection module's state,
+    -- as opts.range was found to be 0 even when in visual mode for <cmd> mappings.
 
-    -- The selection.send_at_mention_for_visual_selection() function itself
-    -- will check for a valid visual selection and show an error if none exists.
-    -- This simplifies handling calls from keymaps vs. direct :'<,'>Cmd invocations.
-    local selection_module = require("claudecode.selection")
-    selection_module.send_at_mention_for_visual_selection()
+    if not M.state.server then
+      logger.error("command", "ClaudeCodeSend: Claude Code integration is not running.")
+      vim.notify("Claude Code integration is not running", vim.log.levels.ERROR, { title = "ClaudeCode Error" })
+      return
+    end
+
+    local selection_module_ok, selection_module = pcall(require, "claudecode.selection")
+    if selection_module_ok then
+      local sent_successfully = selection_module.send_at_mention_for_visual_selection()
+      if sent_successfully then
+        vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Esc>", true, false, true), "n", false)
+        logger.debug("command", "ClaudeCodeSend: Exited visual mode after successful send.")
+      end
+    else
+      logger.error("command", "ClaudeCodeSend: Failed to load selection module.")
+      vim.notify("Failed to send selection: selection module not loaded.", vim.log.levels.ERROR)
+    end
   end, {
     desc = "Send current visual selection as an at_mention to Claude Code",
     range = true, -- Important: This makes the command expect a range (visual selection)
   })
+
+  local terminal_ok, terminal = pcall(require, "claudecode.terminal")
+  if terminal_ok then
+    vim.api.nvim_create_user_command("ClaudeCode", function(_opts)
+      local current_mode = vim.fn.mode()
+      if current_mode == "v" or current_mode == "V" or current_mode == "\22" then -- \22 is CTRL-V (blockwise visual mode)
+        vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Esc>", true, false, true), "n", false)
+      end
+      terminal.toggle({}) -- `opts.fargs` can be used for future enhancements.
+    end, {
+      nargs = "?",
+      desc = "Toggle the Claude Code terminal window",
+    })
+
+    vim.api.nvim_create_user_command("ClaudeCodeOpen", function(_opts)
+      terminal.open({})
+    end, {
+      nargs = "?",
+      desc = "Open the Claude Code terminal window",
+    })
+
+    vim.api.nvim_create_user_command("ClaudeCodeClose", function()
+      terminal.close()
+    end, {
+      desc = "Close the Claude Code terminal window",
+    })
+  else
+    logger.error(
+      "init",
+      "Terminal module not found. Terminal commands (ClaudeCode, ClaudeCodeOpen, ClaudeCodeClose) not registered."
+    )
+  end
 end
 
 --- Get version information