Refactor lsp.Server God Object: extract chat and completion subsystems

The Server type accumulated two large, tangled feature subsystems (in-editor
chat and code completion) alongside its core LSP dispatch role. Pull them into
cohesive types that own their state and logic while delegating shared
infrastructure back to Server via a back-reference.

- Add completionService (completion_service.go): owns the completion
  cache/throttle state (completionState) and all completion request-handling
  logic (handleCompletion, plan/jobs/execute, provider-native path,
  post-processing, message building, prefix heuristics). Methods moved off
  Server in handlers_completion.go to completionService.
- Add chatService (chat_service.go + chat_handlers.go): owns the input-activity
  clock (lastInput, with its own mutex instead of Server.mu) and all in-editor
  chat logic (detection, transcript history, message building, edit
  application, inline prompts) plus the slash-command handlers
  (chat_commands.go).
- Server now holds chat/completion fields, wires them in NewServer, and
  delegates (dispatch table, didChange, debounce gate) to them. Thin Server
  shims preserve the existing completion-state API for callers/tests.

Pure refactor: no behavior or LSP protocol changes. Tests adjusted only to
reach the relocated methods/state via the services. All tests pass with -race;
coverage 86.1%.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

1 files changed, 52 insertions, 0 deletions

diff --git a/internal/lsp/chat_service.go b/internal/lsp/chat_service.go
new file mode 100644
index 0000000..fd39e14
--- /dev/null
+++ b/internal/lsp/chat_service.go
@@ -0,0 +1,52 @@
+package lsp
+
+import (
+	"sync"
+	"time"
+)
+
+// chatService owns the in-editor chat subsystem that used to be inlined on
+// Server. It tracks editor input activity (used by the completion debounce
+// gate) and reaches back into the Server (via srv) for shared infrastructure
+// such as configuration, LLM clients, document access and edit dispatch.
+//
+// Pulling this out of Server keeps the chat detection/history/command logic
+// cohesive and gives the input-activity clock its own small mutex instead of
+// piggy-backing on Server.mu.
+type chatService struct {
+	srv *Server
+
+	activityMu sync.RWMutex
+	lastInput  time.Time
+}
+
+// newChatService constructs the chat subsystem bound to srv.
+func newChatService(srv *Server) *chatService {
+	return &chatService{srv: srv}
+}
+
+// markActivity records that the editor just sent input. The completion
+// debounce gate uses this timestamp to decide how long to wait before issuing
+// an LLM request.
+func (c *chatService) markActivity() {
+	c.activityMu.Lock()
+	c.lastInput = time.Now()
+	c.activityMu.Unlock()
+}
+
+// lastActivity returns the most recent input timestamp (zero if none yet).
+func (c *chatService) lastActivity() time.Time {
+	c.activityMu.RLock()
+	defer c.activityMu.RUnlock()
+	return c.lastInput
+}
+
+// chatSvc returns the chat subsystem, lazily constructing it for the bare
+// Server literals used in some tests. Production code always has it wired up
+// by NewServer.
+func (s *Server) chatSvc() *chatService {
+	if s.chat == nil {
+		s.chat = newChatService(s)
+	}
+	return s.chat
+}