Update terminal tests for multi-instance support

- Completely rewrite terminal_spec.lua to test instances table instead of single bufnr
- Add comprehensive tests for multi-instance functionality:
  - Instance creation and management
  - Git root vs current directory as instance identifier
  - Buffer name sanitization for special characters
  - Invalid buffer cleanup from instances table
- Add tests for single-instance mode using 'global' key
- Update force_insert_mode tests to work with instances table
- All tests validate both single and multi-instance behavior

Author: ahdzib-maya

tests/spec/terminal_spec.lua

@@ -48,6 +48,11 @@ describe('terminal module', function()
       return 42
     end
 
+    -- Mock vim.fn.getcwd
+    _G.vim.fn.getcwd = function()
+      return '/test/current/dir'
+    end
+
     -- Mock vim.api.nvim_win_close
     _G.vim.api.nvim_win_close = function(win_id, force)
       -- Remove the window from win_ids
@@ -78,12 +83,14 @@ describe('terminal module', function()
       },
       git = {
         use_git_root = true,
+        multi_instance = true,
       },
     }
 
     claude_code = {
       claude_code = {
-        bufnr = nil,
+        instances = {},
+        current_instance = nil,
         saved_updatetime = nil,
       },
     }
@@ -95,10 +102,11 @@ describe('terminal module', function()
     }
   end)
 
-  describe('toggle', function()
-    it('should open terminal window when Claude Code is not running', function()
-      -- Claude Code is not running (bufnr is nil)
-      claude_code.claude_code.bufnr = nil
+  describe('toggle with multi-instance enabled', function()
+    it('should create new instance when none exists', function()
+      -- No instances exist
+      claude_code.claude_code.instances = {}
+      claude_code.claude_code.current_instance = nil
 
       -- Call toggle
       terminal.toggle(claude_code, config, git)
@@ -122,36 +130,43 @@ describe('terminal module', function()
       assert.is_true(resize_cmd_found, 'Resize command should be called')
       assert.is_true(terminal_cmd_found, 'Terminal command should be called')
 
-      -- Buffer number should be set
-      assert.is_not_nil(claude_code.claude_code.bufnr, 'Claude Code buffer number should be set')
+      -- Current instance should be set
+      assert.is_not_nil(claude_code.claude_code.current_instance, 'Current instance should be set')
+      
+      -- Instance should be created in instances table
+      local current_instance = claude_code.claude_code.current_instance
+      assert.is_not_nil(claude_code.claude_code.instances[current_instance], 'Instance buffer should be set')
     end)
 
-    it('should use git root when configured', function()
-      -- Claude Code is not running (bufnr is nil)
-      claude_code.claude_code.bufnr = nil
-
-      -- Set git config to use root
+    it('should use git root as instance identifier when use_git_root is true', function()
+      -- Configure to use git root
       config.git.use_git_root = true
+      config.git.multi_instance = true
 
       -- Call toggle
       terminal.toggle(claude_code, config, git)
 
-      -- Check that git root was used in terminal command
-      local git_root_cmd_found = false
+      -- Current instance should be git root
+      assert.are.equal('/test/git/root', claude_code.claude_code.current_instance)
+    end)
 
-      for _, cmd in ipairs(vim_cmd_calls) do
-        if cmd:match('terminal pushd /test/git/root && ' .. config.command .. ' && popd') then
-          git_root_cmd_found = true
-          break
-        end
-      end
+    it('should use current directory as instance identifier when use_git_root is false', function()
+      -- Configure to use current directory
+      config.git.use_git_root = false
+      config.git.multi_instance = true
 
-      assert.is_true(git_root_cmd_found, 'Terminal command should include git root')
+      -- Call toggle
+      terminal.toggle(claude_code, config, git)
+
+      -- Current instance should be current directory
+      assert.are.equal('/test/current/dir', claude_code.claude_code.current_instance)
     end)
 
-    it('should close window when Claude Code is visible', function()
-      -- Claude Code is running and visible
-      claude_code.claude_code.bufnr = 42
+    it('should close window when instance is visible', function()
+      -- Setup existing instance
+      local instance_id = '/test/git/root'
+      claude_code.claude_code.instances[instance_id] = 42
+      claude_code.claude_code.current_instance = instance_id
       win_ids = { 100, 101 } -- Windows displaying the buffer
 
       -- Create a function to clear the win_ids array
@@ -168,9 +183,11 @@ describe('terminal module', function()
       assert.are.equal(0, #win_ids, 'Windows should be closed')
     end)
 
-    it('should reopen window when Claude Code exists but is hidden', function()
-      -- Claude Code is running but not visible
-      claude_code.claude_code.bufnr = 42
+    it('should reopen window when instance exists but is hidden', function()
+      -- Setup existing instance that's not visible
+      local instance_id = '/test/git/root'
+      claude_code.claude_code.instances[instance_id] = 42
+      claude_code.claude_code.current_instance = instance_id
       win_ids = {} -- No windows displaying the buffer
 
       -- Call toggle
@@ -195,13 +212,98 @@ describe('terminal module', function()
       assert.is_true(resize_cmd_found, 'Resize command should be called')
       assert.is_true(buffer_cmd_found, 'Buffer command should be called with correct buffer number')
     end)
+
+    it('should create buffer with sanitized name for multi-instance', function()
+      -- Use an instance ID with special characters
+      config.git.use_git_root = false
+      config.git.multi_instance = true
+      
+      -- Mock getcwd to return path with special characters
+      _G.vim.fn.getcwd = function()
+        return '/test/path with spaces/and-symbols!'
+      end
+
+      -- Call toggle
+      terminal.toggle(claude_code, config, git)
+
+      -- Check that file command was called with sanitized name
+      local file_cmd_found = false
+      for _, cmd in ipairs(vim_cmd_calls) do
+        if cmd:match('file claude%-code%-.*') then
+          file_cmd_found = true
+          -- Ensure no special characters remain
+          assert.is_false(cmd:match('[^%w%-_]'), 'Buffer name should not contain special characters')
+          break
+        end
+      end
+
+      assert.is_true(file_cmd_found, 'File command should be called with sanitized buffer name')
+    end)
+
+    it('should clean up invalid buffers from instances table', function()
+      -- Setup invalid buffer in instances
+      local instance_id = '/test/git/root'
+      claude_code.claude_code.instances[instance_id] = 999 -- Invalid buffer number
+      
+      -- Mock nvim_buf_is_valid to return false for this buffer
+      _G.vim.api.nvim_buf_is_valid = function(bufnr)
+        return bufnr ~= 999
+      end
+
+      -- Call toggle
+      terminal.toggle(claude_code, config, git)
+
+      -- Invalid buffer should be cleaned up
+      assert.is_nil(claude_code.claude_code.instances[instance_id], 'Invalid buffer should be cleaned up')
+    end)
+  end)
+
+  describe('toggle with multi-instance disabled', function()
+    before_each(function()
+      config.git.multi_instance = false
+    end)
+
+    it('should use global instance when multi-instance is disabled', function()
+      -- Call toggle
+      terminal.toggle(claude_code, config, git)
+
+      -- Current instance should be "global"
+      assert.are.equal('global', claude_code.claude_code.current_instance)
+    end)
+
+    it('should create single global instance', function()
+      -- Call toggle
+      terminal.toggle(claude_code, config, git)
+
+      -- Check that global instance is created
+      assert.is_not_nil(claude_code.claude_code.instances['global'], 'Global instance should be created')
+    end)
+  end)
+
+  describe('git root usage', function()
+    it('should use git root when configured', function()
+      -- Set git config to use root
+      config.git.use_git_root = true
+
+      -- Call toggle
+      terminal.toggle(claude_code, config, git)
+
+      -- Check that git root was used in terminal command
+      local git_root_cmd_found = false
+
+      for _, cmd in ipairs(vim_cmd_calls) do
+        if cmd:match('terminal pushd /test/git/root && ' .. config.command .. ' && popd') then
+          git_root_cmd_found = true
+          break
+        end
+      end
+
+      assert.is_true(git_root_cmd_found, 'Terminal command should include git root')
+    end)
   end)
 
   describe('start_in_normal_mode option', function()
     it('should not enter insert mode when start_in_normal_mode is true', function()
-      -- Claude Code is not running (bufnr is nil)
-      claude_code.claude_code.bufnr = nil
-
       -- Set start_in_normal_mode to true
       config.window.start_in_normal_mode = true
 
@@ -224,9 +326,6 @@ describe('terminal module', function()
     end)
 
     it('should enter insert mode when start_in_normal_mode is false', function()
-      -- Claude Code is not running (bufnr is nil)
-      claude_code.claude_code.bufnr = nil
-
       -- Set start_in_normal_mode to false
       config.window.start_in_normal_mode = false
 
@@ -251,43 +350,59 @@ describe('terminal module', function()
 
   describe('force_insert_mode', function()
     it('should check insert mode conditions in terminal buffer', function()
+      -- Setup mock with instances table
+      local mock_claude_code = {
+        claude_code = {
+          instances = {
+            ['/test/instance'] = 1,
+          },
+          current_instance = '/test/instance',
+        },
+      }
+      local mock_config = {
+        window = {
+          start_in_normal_mode = false,
+        },
+      }
+
       -- For this test, we'll just verify that the function can be called without error
       local success, _ = pcall(function()
-        -- Setup minimal mock
-        local mock_claude_code = {
-          claude_code = {
-            bufnr = 1,
-          },
-        }
-        local mock_config = {
-          window = {
-            start_in_normal_mode = false,
-          },
-        }
         terminal.force_insert_mode(mock_claude_code, mock_config)
       end)
 
       assert.is_true(success, 'Force insert mode function should run without error')
     end)
 
     it('should handle non-terminal buffers correctly', function()
+      -- Setup mock with instances table but different current buffer
+      local mock_claude_code = {
+        claude_code = {
+          instances = {
+            ['/test/instance'] = 2,
+          },
+          current_instance = '/test/instance',
+        },
+      }
+      local mock_config = {
+        window = {
+          start_in_normal_mode = false,
+        },
+      }
+
+      -- Mock bufnr to return different buffer
+      _G.vim.fn.bufnr = function(pattern)
+        if pattern == '%' then
+          return 1 -- Different from instances buffer
+        end
+        return 1
+      end
+
       -- For this test, we'll just verify that the function can be called without error
       local success, _ = pcall(function()
-        -- Setup minimal mock that's different from terminal buffer
-        local mock_claude_code = {
-          claude_code = {
-            bufnr = 2,
-          },
-        }
-        local mock_config = {
-          window = {
-            start_in_normal_mode = false,
-          },
-        }
         terminal.force_insert_mode(mock_claude_code, mock_config)
       end)
 
       assert.is_true(success, 'Force insert mode function should run without error')
     end)
   end)
-end)
+end)