hexai-lsp: Go Coverage Report

+ +

// Summary: Hexai LSP entrypoint; parses flags and delegates to internal/hexailsp.
+package main
+
+import (
+        "flag"
+        "log"
+        "os"
+
+        "codeberg.org/snonux/hexai/internal"
+        "codeberg.org/snonux/hexai/internal/hexailsp"
+)
+
+func main() {
+        logPath := flag.String("log", "/tmp/hexai-lsp.log", "path to log file (optional)")
+        showVersion := flag.Bool("version", false, "print version and exit")
+        flag.Parse()
+        if *showVersion {
+                log.Println(internal.Version)
+                return
+        }
+
+        if err := hexailsp.Run(*logPath, os.Stdin, os.Stdout, os.Stderr); err != nil {
+                log.Fatalf("server error: %v", err)
+        }
+}
+

+ +

// Summary: Hexai CLI entrypoint; parses flags and delegates to internal/hexaicli.
+package main
+
+import (
+        "context"
+        "flag"
+        "fmt"
+        "os"
+
+        "codeberg.org/snonux/hexai/internal"
+        "codeberg.org/snonux/hexai/internal/hexaicli"
+)
+
+func main() {
+        showVersion := flag.Bool("version", false, "print version and exit")
+        flag.Parse()
+        if *showVersion {
+                fmt.Fprintln(os.Stdout, internal.Version)
+                return
+        }
+
+        if err := hexaicli.Run(context.Background(), flag.Args(), os.Stdin, os.Stdout, os.Stderr); err != nil {
+                os.Exit(1)
+        }
+}
+

+ +

// Summary: Application configuration model and loader; reads ~/.config/hexai/config.json and merges defaults.
+package appconfig
+
+import (
+    "encoding/json"
+    "fmt"
+    "log"
+    "os"
+    "path/filepath"
+    "slices"
+    "strconv"
+    "strings"
+)
+
+// App holds user-configurable settings read from ~/.config/hexai/config.json.
+type App struct {
+        MaxTokens          int    `json:"max_tokens"`
+        ContextMode        string `json:"context_mode"`
+        ContextWindowLines int    `json:"context_window_lines"`
+        MaxContextTokens   int    `json:"max_context_tokens"`
+        LogPreviewLimit    int    `json:"log_preview_limit"`
+        // Single knob for LSP requests; if set, overrides hardcoded temps in LSP.
+    CodingTemperature *float64 `json:"coding_temperature"`
+    // Minimum identifier characters required for manual (TriggerKind=1) invoke
+    // to proceed without structural triggers. 0 means always allow.
+    ManualInvokeMinPrefix int `json:"manual_invoke_min_prefix"`
+
+    // Completion debounce in milliseconds. When > 0, the server waits until
+    // there has been no text change for at least this duration before sending
+    // an LLM completion request.
+    CompletionDebounceMs int `json:"completion_debounce_ms"`
+    // Completion throttle in milliseconds. When > 0, caps the minimum spacing
+    // between LLM requests (both chat and code-completer paths).
+    CompletionThrottleMs int `json:"completion_throttle_ms"`
+
+        TriggerCharacters []string `json:"trigger_characters"`
+        Provider          string   `json:"provider"`
+
+        // Provider-specific options
+        OpenAIBaseURL string `json:"openai_base_url"`
+        OpenAIModel   string `json:"openai_model"`
+        // Default temperature for OpenAI requests (nil means use provider default)
+        OpenAITemperature *float64 `json:"openai_temperature"`
+        OllamaBaseURL     string   `json:"ollama_base_url"`
+        OllamaModel       string   `json:"ollama_model"`
+        // Default temperature for Ollama requests (nil means use provider default)
+        OllamaTemperature *float64 `json:"ollama_temperature"`
+        CopilotBaseURL    string   `json:"copilot_base_url"`
+        CopilotModel      string   `json:"copilot_model"`
+        // Default temperature for Copilot requests (nil means use provider default)
+        CopilotTemperature *float64 `json:"copilot_temperature"`
+}
+
+// Constructor: defaults for App (kept first among functions)
+func newDefaultConfig() App {
+        // Coding-friendly default temperature across providers
+        // Users can override per provider in config.json (including 0.0).
+        t := 0.2
+        return App{
+                MaxTokens:          4000,
+                ContextMode:        "always-full",
+                ContextWindowLines: 120,
+                MaxContextTokens:   4000,
+                LogPreviewLimit:    100,
+                CodingTemperature:  &t,
+                OpenAITemperature:  &t,
+                OllamaTemperature:  &t,
+        CopilotTemperature: &t,
+        ManualInvokeMinPrefix: 0,
+        CompletionDebounceMs: 200,
+        CompletionThrottleMs: 0,
+    }
+}
+
+// Load reads configuration from a file and merges with defaults.
+// It respects the XDG Base Directory Specification.
+func Load(logger *log.Logger) App {
+    cfg := newDefaultConfig()
+    if logger == nil {
+        return cfg // Return defaults if no logger is provided (e.g. in tests)
+    }
+
+    configPath, err := getConfigPath()
+    if err != nil {
+        logger.Printf("%v", err)
+        // Even if config path cannot be resolved, still allow env overrides below.
+    } else {
+        if fileCfg, err := loadFromFile(configPath, logger); err == nil && fileCfg != nil {
+            cfg.mergeWith(fileCfg)
+        }
+        // When the config file is missing or invalid, we keep defaults and still
+        // apply any environment overrides below.
+    }
+
+    // Environment overrides (take precedence over file)
+    if envCfg := loadFromEnv(logger); envCfg != nil {
+        cfg.mergeWith(envCfg)
+    }
+    return cfg
+}
+
+// Private helpers
+func loadFromFile(path string, logger *log.Logger) (*App, error) {
+        f, err := os.Open(path)
+        if err != nil {
+                if !os.IsNotExist(err) && logger != nil {
+                        logger.Printf("cannot open config file %s: %v", path, err)
+                }
+                return nil, err
+        }
+        defer f.Close()
+
+        dec := json.NewDecoder(f)
+        var fileCfg App
+        if err := dec.Decode(&fileCfg); err != nil {
+                if logger != nil {
+                        logger.Printf("invalid config file %s: %v", path, err)
+                }
+                return nil, err
+        }
+        return &fileCfg, nil
+}
+
+func (a *App) mergeWith(other *App) {
+    a.mergeBasics(other)
+    a.mergeProviderFields(other)
+}
+
+// mergeBasics merges general (non-provider) fields.
+func (a *App) mergeBasics(other *App) {
+        if other.MaxTokens > 0 {
+                a.MaxTokens = other.MaxTokens
+        }
+        if s := strings.TrimSpace(other.ContextMode); s != "" {
+                a.ContextMode = s
+        }
+        if other.ContextWindowLines > 0 {
+                a.ContextWindowLines = other.ContextWindowLines
+        }
+        if other.MaxContextTokens > 0 {
+                a.MaxContextTokens = other.MaxContextTokens
+        }
+        if other.LogPreviewLimit >= 0 {
+                a.LogPreviewLimit = other.LogPreviewLimit
+        }
+    if other.CodingTemperature != nil { // allow explicit 0.0
+        a.CodingTemperature = other.CodingTemperature
+    }
+    if other.ManualInvokeMinPrefix >= 0 {
+        a.ManualInvokeMinPrefix = other.ManualInvokeMinPrefix
+    }
+    if other.CompletionDebounceMs > 0 { a.CompletionDebounceMs = other.CompletionDebounceMs }
+    if other.CompletionThrottleMs > 0 { a.CompletionThrottleMs = other.CompletionThrottleMs }
+        if len(other.TriggerCharacters) > 0 {
+                a.TriggerCharacters = slices.Clone(other.TriggerCharacters)
+        }
+        if s := strings.TrimSpace(other.Provider); s != "" {
+                a.Provider = s
+        }
+}
+
+// mergeProviderFields merges per-provider configuration.
+func (a *App) mergeProviderFields(other *App) {
+        if s := strings.TrimSpace(other.OpenAIBaseURL); s != "" {
+                a.OpenAIBaseURL = s
+        }
+        if s := strings.TrimSpace(other.OpenAIModel); s != "" {
+                a.OpenAIModel = s
+        }
+        if other.OpenAITemperature != nil { // allow explicit 0.0
+                a.OpenAITemperature = other.OpenAITemperature
+        }
+        if s := strings.TrimSpace(other.OllamaBaseURL); s != "" {
+                a.OllamaBaseURL = s
+        }
+        if s := strings.TrimSpace(other.OllamaModel); s != "" {
+                a.OllamaModel = s
+        }
+        if other.OllamaTemperature != nil { // allow explicit 0.0
+                a.OllamaTemperature = other.OllamaTemperature
+        }
+        if s := strings.TrimSpace(other.CopilotBaseURL); s != "" {
+                a.CopilotBaseURL = s
+        }
+        if s := strings.TrimSpace(other.CopilotModel); s != "" {
+                a.CopilotModel = s
+        }
+        if other.CopilotTemperature != nil { // allow explicit 0.0
+                a.CopilotTemperature = other.CopilotTemperature
+        }
+}
+
+func getConfigPath() (string, error) {
+        var configPath string
+        if xdgConfigHome := os.Getenv("XDG_CONFIG_HOME"); xdgConfigHome != "" {
+                configPath = filepath.Join(xdgConfigHome, "hexai", "config.json")
+        } else {
+                home, err := os.UserHomeDir()
+                if err != nil {
+                        return "", fmt.Errorf("cannot find user home directory: %v", err)
+                }
+                configPath = filepath.Join(home, ".config", "hexai", "config.json")
+        }
+    return configPath, nil
+}
+
+// --- Environment overrides ---
+
+// loadFromEnv constructs an App containing only fields set via HEXAI_* env vars.
+// These values should take precedence over file config when merged.
+func loadFromEnv(logger *log.Logger) *App {
+    var out App
+    var any bool
+
+    // helpers
+    getenv := func(k string) string { return strings.TrimSpace(os.Getenv(k)) }
+    parseInt := func(k string) (int, bool) {
+        v := getenv(k)
+        if v == "" { return 0, false }
+        n, err := strconv.Atoi(v)
+        if err != nil { if logger != nil { logger.Printf("invalid %s: %v", k, err) } ; return 0, false }
+        return n, true
+    }
+    parseFloatPtr := func(k string) (*float64, bool) {
+        v := getenv(k)
+        if v == "" { return nil, false }
+        f, err := strconv.ParseFloat(v, 64)
+        if err != nil {
+            if logger != nil { logger.Printf("invalid %s: %v", k, err) }
+            return nil, false
+        }
+        return &f, true
+    }
+
+    if n, ok := parseInt("HEXAI_MAX_TOKENS"); ok {
+        out.MaxTokens = n; any = true
+    }
+    if s := getenv("HEXAI_CONTEXT_MODE"); s != "" {
+        out.ContextMode = s; any = true
+    }
+    if n, ok := parseInt("HEXAI_CONTEXT_WINDOW_LINES"); ok {
+        out.ContextWindowLines = n; any = true
+    }
+    if n, ok := parseInt("HEXAI_MAX_CONTEXT_TOKENS"); ok {
+        out.MaxContextTokens = n; any = true
+    }
+    if n, ok := parseInt("HEXAI_LOG_PREVIEW_LIMIT"); ok {
+        out.LogPreviewLimit = n; any = true
+    }
+    if n, ok := parseInt("HEXAI_MANUAL_INVOKE_MIN_PREFIX"); ok {
+        out.ManualInvokeMinPrefix = n; any = true
+    }
+    if n, ok := parseInt("HEXAI_COMPLETION_DEBOUNCE_MS"); ok {
+        out.CompletionDebounceMs = n; any = true
+    }
+    if n, ok := parseInt("HEXAI_COMPLETION_THROTTLE_MS"); ok {
+        out.CompletionThrottleMs = n; any = true
+    }
+    if f, ok := parseFloatPtr("HEXAI_CODING_TEMPERATURE"); ok {
+        out.CodingTemperature = f; any = true
+    }
+    if s := getenv("HEXAI_TRIGGER_CHARACTERS"); s != "" {
+        parts := strings.Split(s, ",")
+        out.TriggerCharacters = nil
+        for _, p := range parts {
+            if t := strings.TrimSpace(p); t != "" {
+                out.TriggerCharacters = append(out.TriggerCharacters, t)
+            }
+        }
+        any = true
+    }
+    if s := getenv("HEXAI_PROVIDER"); s != "" {
+        out.Provider = s; any = true
+    }
+
+    // Provider-specific
+    if s := getenv("HEXAI_OPENAI_BASE_URL"); s != "" { out.OpenAIBaseURL = s; any = true }
+    if s := getenv("HEXAI_OPENAI_MODEL"); s != "" { out.OpenAIModel = s; any = true }
+    if f, ok := parseFloatPtr("HEXAI_OPENAI_TEMPERATURE"); ok { out.OpenAITemperature = f; any = true }
+
+    if s := getenv("HEXAI_OLLAMA_BASE_URL"); s != "" { out.OllamaBaseURL = s; any = true }
+    if s := getenv("HEXAI_OLLAMA_MODEL"); s != "" { out.OllamaModel = s; any = true }
+    if f, ok := parseFloatPtr("HEXAI_OLLAMA_TEMPERATURE"); ok { out.OllamaTemperature = f; any = true }
+
+    if s := getenv("HEXAI_COPILOT_BASE_URL"); s != "" { out.CopilotBaseURL = s; any = true }
+    if s := getenv("HEXAI_COPILOT_MODEL"); s != "" { out.CopilotModel = s; any = true }
+    if f, ok := parseFloatPtr("HEXAI_COPILOT_TEMPERATURE"); ok { out.CopilotTemperature = f; any = true }
+
+    if !any {
+        return nil
+    }
+    return &out
+}
+

+ +

// Summary: Hexai CLI runner; reads input, creates an LLM client, builds messages,
+// streams or collects the model output, and prints a short summary to stderr.
+package hexaicli
+
+import (
+    "bufio"
+    "context"
+    "fmt"
+    "io"
+    "log"
+    "os"
+    "strings"
+    "time"
+
+        "codeberg.org/snonux/hexai/internal/appconfig"
+        "codeberg.org/snonux/hexai/internal/llm"
+        "codeberg.org/snonux/hexai/internal/logging"
+)
+
+// Run executes the Hexai CLI behavior given arguments and I/O streams.
+// It assumes flags have already been parsed by the caller.
+func Run(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer) error {
+    // Load configuration with a logger so file-based config is respected.
+    logger := log.New(stderr, "hexai ", log.LstdFlags|log.Lmsgprefix)
+    cfg := appconfig.Load(logger)
+    client, err := newClientFromConfig(cfg)
+    if err != nil {
+        fmt.Fprintf(stderr, logging.AnsiBase+"hexai: LLM disabled: %v"+logging.AnsiReset+"\n", err)
+        return err
+    }
+
+        return RunWithClient(ctx, args, stdin, stdout, stderr, client)
+}
+
+// RunWithClient executes the CLI flow using an already-constructed client.
+// Useful for testing and embedding.
+func RunWithClient(ctx context.Context, args []string, stdin io.Reader, stdout, stderr io.Writer, client llm.Client) error {
+        input, err := readInput(stdin, args)
+        if err != nil {
+                fmt.Fprintln(stderr, logging.AnsiBase+err.Error()+logging.AnsiReset)
+                return err
+        }
+        printProviderInfo(stderr, client)
+        msgs := buildMessages(input)
+        if err := runChat(ctx, client, msgs, input, stdout, stderr); err != nil {
+                fmt.Fprintf(stderr, logging.AnsiBase+"hexai: error: %v"+logging.AnsiReset+"\n", err)
+                return err
+        }
+        return nil
+}
+
+// readInput reads from stdin and args, then combines them per CLI rules.
+func readInput(stdin io.Reader, args []string) (string, error) {
+        var stdinData string
+        if fi, err := os.Stdin.Stat(); err == nil && (fi.Mode()&os.ModeCharDevice) == 0 {
+                b, _ := io.ReadAll(bufio.NewReader(stdin))
+                stdinData = strings.TrimSpace(string(b))
+        }
+        argData := strings.TrimSpace(strings.Join(args, " "))
+        switch {
+        case stdinData != "" && argData != "":
+                return fmt.Sprintf("%s:\n\n%s", argData, stdinData), nil
+        case stdinData != "":
+                return stdinData, nil
+        case argData != "":
+                return argData, nil
+        default:
+                return "", fmt.Errorf("hexai: no input provided; pass text as an argument or via stdin")
+        }
+}
+
+// newClientFromConfig builds an LLM client from the app config and env keys.
+func newClientFromConfig(cfg appconfig.App) (llm.Client, error) {
+    llmCfg := llm.Config{
+        Provider:       cfg.Provider,
+        OpenAIBaseURL:  cfg.OpenAIBaseURL,
+        OpenAIModel:    cfg.OpenAIModel,
+        OpenAITemperature: cfg.OpenAITemperature,
+        OllamaBaseURL:  cfg.OllamaBaseURL,
+        OllamaModel:    cfg.OllamaModel,
+        OllamaTemperature: cfg.OllamaTemperature,
+        CopilotBaseURL: cfg.CopilotBaseURL,
+        CopilotModel:   cfg.CopilotModel,
+        CopilotTemperature: cfg.CopilotTemperature,
+    }
+    // Prefer HEXAI_OPENAI_API_KEY; fall back to OPENAI_API_KEY
+    oaKey := os.Getenv("HEXAI_OPENAI_API_KEY")
+    if strings.TrimSpace(oaKey) == "" {
+        oaKey = os.Getenv("OPENAI_API_KEY")
+    }
+    // Prefer HEXAI_COPILOT_API_KEY; fall back to COPILOT_API_KEY
+    cpKey := os.Getenv("HEXAI_COPILOT_API_KEY")
+    if strings.TrimSpace(cpKey) == "" {
+        cpKey = os.Getenv("COPILOT_API_KEY")
+    }
+    return llm.NewFromConfig(llmCfg, oaKey, cpKey)
+}
+
+// buildMessages creates system and user messages based on input content.
+func buildMessages(input string) []llm.Message {
+        lower := strings.ToLower(input)
+        system := "You are Hexai CLI. Default to very short, concise answers. If the user asks for commands, output only the commands (one per line) with no commentary or explanation. Only when the word 'explain' appears in the prompt, produce a verbose explanation."
+        if strings.Contains(lower, "explain") {
+                system = "You are Hexai CLI. The user requested an explanation. Provide a clear, verbose explanation with reasoning and details. If commands are needed, include them with brief context."
+        }
+        return []llm.Message{
+                {Role: "system", Content: system},
+                {Role: "user", Content: input},
+        }
+}
+
+// runChat executes the chat request, handling streaming and summary output.
+func runChat(ctx context.Context, client llm.Client, msgs []llm.Message, input string, out io.Writer, errw io.Writer) error {
+        start := time.Now()
+        var output string
+        if s, ok := client.(llm.Streamer); ok {
+                var b strings.Builder
+                if err := s.ChatStream(ctx, msgs, func(chunk string) {
+                        b.WriteString(chunk)
+                        fmt.Fprint(out, chunk)
+                }); err != nil {
+                        return err
+                }
+                output = b.String()
+        } else {
+                txt, err := client.Chat(ctx, msgs)
+                if err != nil {
+                        return err
+                }
+                output = txt
+                fmt.Fprint(out, output)
+        }
+        dur := time.Since(start)
+        fmt.Fprintf(errw, "\n"+logging.AnsiBase+"done provider=%s model=%s time=%s in_bytes=%d out_bytes=%d"+logging.AnsiReset+"\n",
+                client.Name(), client.DefaultModel(), dur.Round(time.Millisecond), len(input), len(output))
+        return nil
+}
+
+// printProviderInfo writes the provider/model line to stderr.
+func printProviderInfo(errw io.Writer, client llm.Client) {
+        fmt.Fprintf(errw, logging.AnsiBase+"provider=%s model=%s"+logging.AnsiReset+"\n", client.Name(), client.DefaultModel())
+}
+

+ +

// Summary: Hexai LSP runner; configures logging, loads config, builds the LLM client,
+// and constructs/runs the LSP server (with injectable factory for tests).
+package hexailsp
+
+import (
+        "io"
+        "log"
+        "os"
+        "strings"
+
+        "codeberg.org/snonux/hexai/internal/appconfig"
+        "codeberg.org/snonux/hexai/internal/llm"
+        "codeberg.org/snonux/hexai/internal/logging"
+        "codeberg.org/snonux/hexai/internal/lsp"
+)
+
+// ServerRunner is the minimal interface satisfied by lsp.Server.
+type ServerRunner interface{ Run() error }
+
+// ServerFactory creates a ServerRunner. Default uses lsp.NewServer.
+type ServerFactory func(r io.Reader, w io.Writer, logger *log.Logger, opts lsp.ServerOptions) ServerRunner
+
+// Run configures logging, loads config, builds the LLM client and runs the LSP server.
+// It is thin and delegates to RunWithFactory for testability.
+func Run(logPath string, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
+        logger := log.New(stderr, "hexai-lsp ", log.LstdFlags|log.Lmsgprefix)
+        if strings.TrimSpace(logPath) != "" {
+                f, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+                if err != nil {
+                        logger.Fatalf("failed to open log file: %v", err)
+                }
+                defer f.Close()
+                logger.SetOutput(f)
+        }
+        logging.Bind(logger)
+        cfg := appconfig.Load(logger)
+        return RunWithFactory(logPath, stdin, stdout, logger, cfg, nil, nil)
+}
+
+// RunWithFactory is the testable entrypoint. When client is nil, it is built from cfg+env.
+// When factory is nil, lsp.NewServer is used.
+func RunWithFactory(logPath string, stdin io.Reader, stdout io.Writer, logger *log.Logger, cfg appconfig.App, client llm.Client, factory ServerFactory) error {
+        normalizeLoggingConfig(&cfg)
+        client = buildClientIfNil(cfg, client)
+        factory = ensureFactory(factory)
+
+        opts := makeServerOptions(cfg, strings.TrimSpace(logPath) != "", client)
+        server := factory(stdin, stdout, logger, opts)
+        if err := server.Run(); err != nil {
+                logger.Fatalf("server error: %v", err)
+        }
+        return nil
+}
+
+// --- helpers to keep RunWithFactory small ---
+
+func normalizeLoggingConfig(cfg *appconfig.App) {
+        cfg.ContextMode = strings.ToLower(strings.TrimSpace(cfg.ContextMode))
+        if cfg.LogPreviewLimit >= 0 {
+                logging.SetLogPreviewLimit(cfg.LogPreviewLimit)
+        }
+}
+
+func buildClientIfNil(cfg appconfig.App, client llm.Client) llm.Client {
+        if client != nil {
+                return client
+        }
+        llmCfg := llm.Config{
+                Provider:           cfg.Provider,
+                OpenAIBaseURL:      cfg.OpenAIBaseURL,
+                OpenAIModel:        cfg.OpenAIModel,
+                OpenAITemperature:  cfg.OpenAITemperature,
+                OllamaBaseURL:      cfg.OllamaBaseURL,
+                OllamaModel:        cfg.OllamaModel,
+                OllamaTemperature:  cfg.OllamaTemperature,
+                CopilotBaseURL:     cfg.CopilotBaseURL,
+                CopilotModel:       cfg.CopilotModel,
+                CopilotTemperature: cfg.CopilotTemperature,
+        }
+    // Prefer HEXAI_OPENAI_API_KEY; fall back to OPENAI_API_KEY
+    oaKey := os.Getenv("HEXAI_OPENAI_API_KEY")
+    if strings.TrimSpace(oaKey) == "" {
+        oaKey = os.Getenv("OPENAI_API_KEY")
+    }
+    // Prefer HEXAI_COPILOT_API_KEY; fall back to COPILOT_API_KEY
+    cpKey := os.Getenv("HEXAI_COPILOT_API_KEY")
+    if strings.TrimSpace(cpKey) == "" {
+        cpKey = os.Getenv("COPILOT_API_KEY")
+    }
+        if c, err := llm.NewFromConfig(llmCfg, oaKey, cpKey); err != nil {
+                logging.Logf("lsp ", "llm disabled: %v", err)
+                return nil
+        } else {
+                logging.Logf("lsp ", "llm enabled provider=%s model=%s", c.Name(), c.DefaultModel())
+                return c
+        }
+}
+
+func ensureFactory(factory ServerFactory) ServerFactory {
+        if factory != nil {
+                return factory
+        }
+        return func(r io.Reader, w io.Writer, logger *log.Logger, opts lsp.ServerOptions) ServerRunner {
+                return lsp.NewServer(r, w, logger, opts)
+        }
+}
+
+func makeServerOptions(cfg appconfig.App, logContext bool, client llm.Client) lsp.ServerOptions {
+    return lsp.ServerOptions{
+        LogContext:        logContext,
+        MaxTokens:         cfg.MaxTokens,
+        ContextMode:       cfg.ContextMode,
+        WindowLines:       cfg.ContextWindowLines,
+        MaxContextTokens:  cfg.MaxContextTokens,
+        CodingTemperature: cfg.CodingTemperature,
+        Client:            client,
+        TriggerCharacters: cfg.TriggerCharacters,
+        ManualInvokeMinPrefix: cfg.ManualInvokeMinPrefix,
+        CompletionDebounceMs:  cfg.CompletionDebounceMs,
+        CompletionThrottleMs:  cfg.CompletionThrottleMs,
+    }
+}
+

+ +

// Summary: GitHub Copilot client for chat and Codex-style code completion.
+package llm
+
+import (
+        "bytes"
+        "context"
+        "encoding/json"
+        "errors"
+        "fmt"
+        "io"
+        "net/http"
+        "regexp"
+        "strings"
+        "time"
+
+        "encoding/base64"
+        appver "codeberg.org/snonux/hexai/internal"
+        "codeberg.org/snonux/hexai/internal/logging"
+)
+
+// copilotClient implements Client against GitHub Copilot's Chat Completions API.
+type copilotClient struct {
+        httpClient         *http.Client
+        apiKey             string
+        baseURL            string
+        defaultModel       string
+        chatLogger         logging.ChatLogger
+        defaultTemperature *float64
+
+        // cached Copilot session token retrieved from GitHub API using apiKey
+        sessionToken string
+        tokenExpiry  time.Time
+}
+
+type copilotChatRequest struct {
+        Model       string           `json:"model"`
+        Messages    []copilotMessage `json:"messages"`
+        Temperature *float64         `json:"temperature,omitempty"`
+        MaxTokens   *int             `json:"max_tokens,omitempty"`
+        Stop        []string         `json:"stop,omitempty"`
+}
+
+type copilotMessage struct {
+        Role    string `json:"role"`
+        Content string `json:"content"`
+}
+
+type copilotChatResponse struct {
+        Choices []struct {
+                Index   int `json:"index"`
+                Message struct {
+                        Role    string `json:"role"`
+                        Content string `json:"content"`
+                } `json:"message"`
+                FinishReason string `json:"finish_reason"`
+        } `json:"choices"`
+        Error *struct {
+                Message string `json:"message"`
+                Type    string `json:"type"`
+                Param   any    `json:"param"`
+                Code    any    `json:"code"`
+        } `json:"error,omitempty"`
+}
+
+// Constructor (kept among the first functions by convention)
+func newCopilot(baseURL, model, apiKey string, defaultTemp *float64) Client {
+        if strings.TrimSpace(baseURL) == "" {
+                baseURL = "https://api.githubcopilot.com"
+        }
+        if strings.TrimSpace(model) == "" {
+                // GitHub Models (Copilot API) commonly supports gpt-4o/gpt-4o-mini.
+                // Default to a broadly available, cost-effective option.
+                model = "gpt-4o-mini"
+        }
+        return copilotClient{
+                httpClient:         &http.Client{Timeout: 30 * time.Second},
+                apiKey:             apiKey,
+                baseURL:            strings.TrimRight(baseURL, "/"),
+                defaultModel:       model,
+                chatLogger:         logging.NewChatLogger("copilot"),
+                defaultTemperature: defaultTemp,
+        }
+}
+
+func (c copilotClient) Chat(ctx context.Context, messages []Message, opts ...RequestOption) (string, error) {
+        if strings.TrimSpace(c.apiKey) == "" {
+                return nilStringErr("missing Copilot API key")
+        }
+        // Ensure we have a fresh session token
+        if err := c.ensureSession(ctx); err != nil {
+                return "", err
+        }
+        o := Options{Model: c.defaultModel}
+        for _, opt := range opts {
+                opt(&o)
+        }
+        if o.Model == "" {
+                o.Model = c.defaultModel
+        }
+        start := time.Now()
+        logMessages := make([]struct{ Role, Content string }, len(messages))
+        for i, m := range messages {
+                logMessages[i] = struct{ Role, Content string }{m.Role, m.Content}
+        }
+        c.chatLogger.LogStart(false, o.Model, o.Temperature, o.MaxTokens, o.Stop, logMessages)
+
+        req := buildCopilotChatRequest(o, messages, c.defaultTemperature)
+        body, err := json.Marshal(req)
+        if err != nil {
+                logging.Logf("llm/copilot ", "marshal error: %v", err)
+                return "", err
+        }
+
+        endpoint := c.baseURL + "/chat/completions"
+        logging.Logf("llm/copilot ", "POST %s", endpoint)
+        resp, err := c.postJSON(ctx, endpoint, body, c.headersChat())
+        if err != nil {
+                logging.Logf("llm/copilot ", "%shttp error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+                return "", err
+        }
+        defer resp.Body.Close()
+        if err := handleCopilotNon2xx(resp, start); err != nil {
+                return "", err
+        }
+        out, err := decodeCopilotChat(resp, start)
+        if err != nil {
+                return "", err
+        }
+        if len(out.Choices) == 0 {
+                logging.Logf("llm/copilot ", "%sno choices returned duration=%s%s", logging.AnsiRed, time.Since(start), logging.AnsiBase)
+                return "", errors.New("copilot: no choices returned")
+        }
+        content := out.Choices[0].Message.Content
+        logging.Logf("llm/copilot ", "success choice=0 finish=%s size=%d preview=%s%s%s duration=%s", out.Choices[0].FinishReason, len(content), logging.AnsiGreen, logging.PreviewForLog(content), logging.AnsiBase, time.Since(start))
+        return content, nil
+}
+
+// Provider metadata
+func (c copilotClient) Name() string         { return "copilot" }
+func (c copilotClient) DefaultModel() string { return c.defaultModel }
+
+// helpers
+func buildCopilotChatRequest(o Options, messages []Message, defaultTemp *float64) copilotChatRequest {
+        req := copilotChatRequest{Model: o.Model}
+        req.Messages = make([]copilotMessage, len(messages))
+        for i, m := range messages {
+                req.Messages[i] = copilotMessage{Role: m.Role, Content: m.Content}
+        }
+        if o.Temperature != 0 {
+                req.Temperature = &o.Temperature
+        } else if defaultTemp != nil {
+                t := *defaultTemp
+                req.Temperature = &t
+        }
+        if o.MaxTokens > 0 {
+                req.MaxTokens = &o.MaxTokens
+        }
+        if len(o.Stop) > 0 {
+                req.Stop = o.Stop
+        }
+        return req
+}
+
+func (c copilotClient) postJSON(ctx context.Context, url string, body []byte, headers map[string]string) (*http.Response, error) {
+    req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+    if err != nil { return nil, err }
+    for k, v := range headers { req.Header.Set(k, v) }
+    return c.httpClient.Do(req)
+}
+
+func handleCopilotNon2xx(resp *http.Response, start time.Time) error {
+        if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+                return nil
+        }
+        var apiErr copilotChatResponse
+        _ = json.NewDecoder(resp.Body).Decode(&apiErr)
+        if apiErr.Error != nil && strings.TrimSpace(apiErr.Error.Message) != "" {
+                logging.Logf("llm/copilot ", "%sapi error status=%d type=%s msg=%s duration=%s%s", logging.AnsiRed, resp.StatusCode, apiErr.Error.Type, apiErr.Error.Message, time.Since(start), logging.AnsiBase)
+                return fmt.Errorf("copilot error: %s (status %d)", apiErr.Error.Message, resp.StatusCode)
+        }
+        logging.Logf("llm/copilot ", "%shttp non-2xx status=%d duration=%s%s", logging.AnsiRed, resp.StatusCode, time.Since(start), logging.AnsiBase)
+        return fmt.Errorf("copilot http error: status %d", resp.StatusCode)
+}
+
+func decodeCopilotChat(resp *http.Response, start time.Time) (copilotChatResponse, error) {
+        var out copilotChatResponse
+        if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+                logging.Logf("llm/copilot ", "%sdecode error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+                return copilotChatResponse{}, err
+        }
+        return out, nil
+}
+
+// --- Copilot session token management ---
+
+type ghCopilotTokenResp struct {
+    Token string `json:"token"`
+}
+
+func (c *copilotClient) ensureSession(ctx context.Context) error {
+    // If token valid for >60s, reuse
+    if c.sessionToken != "" && time.Now().Add(60*time.Second).Before(c.tokenExpiry) {
+        return nil
+    }
+    if strings.TrimSpace(c.apiKey) == "" {
+        return errors.New("missing Copilot API key")
+    }
+    req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://api.github.com/copilot_internal/v2/token", nil)
+    if err != nil { return err }
+    req.Header.Set("Authorization", "Bearer "+c.apiKey)
+    req.Header.Set("Accept", "application/json")
+    req.Header.Set("User-Agent", "hexai/"+appver.Version)
+    resp, err := c.httpClient.Do(req)
+    if err != nil { return err }
+    defer resp.Body.Close()
+    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+        return fmt.Errorf("copilot token http error: %d", resp.StatusCode)
+    }
+    var out ghCopilotTokenResp
+    if err := json.NewDecoder(resp.Body).Decode(&out); err != nil { return err }
+    if strings.TrimSpace(out.Token) == "" { return errors.New("empty copilot session token") }
+    // Parse JWT exp
+    exp := parseJWTExp(out.Token)
+    if exp.IsZero() { exp = time.Now().Add(10 * time.Minute) }
+    c.sessionToken = out.Token
+    c.tokenExpiry = exp
+    return nil
+}
+
+var jwtExpRe = regexp.MustCompile(`"exp"\s*:\s*([0-9]+)`) // fallback if we can't base64 decode
+
+func parseJWTExp(token string) time.Time {
+    parts := strings.Split(token, ".")
+    if len(parts) < 2 { return time.Time{} }
+    b, err := base64.RawURLEncoding.DecodeString(parts[1])
+    if err != nil {
+        if m := jwtExpRe.FindStringSubmatch(token); len(m) == 2 {
+            if n, err2 := parseInt64(m[1]); err2 == nil { return time.Unix(n, 0) }
+        }
+        return time.Time{}
+    }
+    var payload struct{ Exp int64 `json:"exp"` }
+    _ = json.Unmarshal(b, &payload)
+    if payload.Exp == 0 { return time.Time{} }
+    return time.Unix(payload.Exp, 0)
+}
+
+func parseInt64(s string) (int64, error) { var n int64; _, err := fmt.Sscan(s, &n); return n, err }
+
+// --- Copilot headers ---
+
+func (c *copilotClient) headersChat() map[string]string {
+    _ = c.ensureSession(context.Background())
+    h := map[string]string{
+        "Content-Type": "application/json; charset=utf-8",
+        "Accept":       "application/json",
+        "Authorization": "Bearer " + c.sessionToken,
+        "User-Agent":  "GitHubCopilotChat/0.8.0",
+        "Editor-Plugin-Version": "copilot-chat/0.8.0",
+        "Editor-Version":        "vscode/1.85.1",
+        "Openai-Intent":         "conversation-panel",
+        "Openai-Organization":   "github-copilot",
+        "VScode-MachineId":      randHex(64),
+        "VScode-SessionId":      randHex(8) + "-" + randHex(4) + "-" + randHex(4) + "-" + randHex(4) + "-" + randHex(12),
+        "X-Request-Id":          randHex(8) + "-" + randHex(4) + "-" + randHex(4) + "-" + randHex(4) + "-" + randHex(12),
+    }
+    return h
+}
+
+func (c *copilotClient) headersGhost() map[string]string {
+    _ = c.ensureSession(context.Background())
+    h := map[string]string{
+        "Content-Type": "application/json; charset=utf-8",
+        "Accept":       "*/*",
+        "Authorization": "Bearer " + c.sessionToken,
+        "User-Agent":  "GithubCopilot/1.155.0",
+        "Editor-Plugin-Version": "copilot/1.155.0",
+        "Editor-Version":        "vscode/1.85.1",
+        "Openai-Intent":         "copilot-ghost",
+        "Openai-Organization":   "github-copilot",
+        "VScode-MachineId":      randHex(64),
+        "VScode-SessionId":      randHex(8) + "-" + randHex(4) + "-" + randHex(4) + "-" + randHex(4) + "-" + randHex(12),
+        "X-Request-Id":          randHex(8) + "-" + randHex(4) + "-" + randHex(4) + "-" + randHex(4) + "-" + randHex(12),
+    }
+    return h
+}
+
+func randHex(n int) string {
+    const hex = "0123456789abcdef"
+    b := make([]byte, n)
+    for i := range b {
+        b[i] = hex[int(time.Now().UnixNano()+int64(i))%len(hex)]
+    }
+    return string(b)
+}
+
+// --- Codex-style code completion ---
+
+// CodeCompletion implements CodeCompleter; returns up to n suggestions.
+func (c copilotClient) CodeCompletion(ctx context.Context, prompt string, suffix string, n int, language string, temperature float64) ([]string, error) {
+    if strings.TrimSpace(c.apiKey) == "" { return nil, errors.New("missing Copilot API key") }
+    if err := c.ensureSession(ctx); err != nil { return nil, err }
+    if n <= 0 { n = 1 }
+    maxTokens := 500
+    body := map[string]any{
+        "extra": map[string]any{
+            "language": language,
+            "next_indent": 0,
+            "prompt_tokens": 500,
+            "suffix_tokens": 400,
+            "trim_by_indentation": true,
+        },
+        "max_tokens": maxTokens,
+        "n": n,
+        "nwo": "hexai",
+        "prompt": prompt,
+        "stop": []string{"\n\n"},
+        "stream": true,
+        "suffix": suffix,
+        "temperature": temperature,
+        "top_p": 1,
+    }
+    buf, _ := json.Marshal(body)
+    url := "https://copilot-proxy.githubusercontent.com/v1/engines/copilot-codex/completions"
+    resp, err := c.postJSON(ctx, url, buf, c.headersGhost())
+    if err != nil { return nil, err }
+    defer resp.Body.Close()
+    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+        return nil, fmt.Errorf("copilot codex http error: %d", resp.StatusCode)
+    }
+    // Read all and parse lines that start with "data: " accumulating by index
+    raw, _ := io.ReadAll(resp.Body)
+    byIndex := make(map[int]string)
+    lines := strings.Split(string(raw), "\n")
+    for _, ln := range lines {
+        if !strings.HasPrefix(ln, "data: ") { continue }
+        var evt struct{ Choices []struct{ Index int `json:"index"`; Text string `json:"text"` } `json:"choices"` }
+        if err := json.Unmarshal([]byte(strings.TrimPrefix(ln, "data: ")), &evt); err != nil { continue }
+        for _, ch := range evt.Choices { byIndex[ch.Index] += ch.Text }
+    }
+    out := make([]string, 0, len(byIndex))
+    for i := 0; i < n; i++ {
+        if s, ok := byIndex[i]; ok && strings.TrimSpace(s) != "" { out = append(out, s) }
+    }
+    return out, nil
+}
+
+// newLineDataReader wraps a streaming body and exposes a JSON decoder that
+// decodes successive objects from lines prefixed by "data: ".
+// (no streaming decoder needed; we parse whole body lines)
+

+ +

// Summary: Ollama client against a local server; supports chat responses and streaming via /api/chat.
+package llm
+
+import (
+        "bytes"
+        "context"
+        "encoding/json"
+        "errors"
+        "fmt"
+        "io"
+        "net/http"
+        "strings"
+        "time"
+
+        "codeberg.org/snonux/hexai/internal/logging"
+)
+
+// ollamaClient implements Client against a local Ollama server.
+type ollamaClient struct {
+        httpClient         *http.Client
+        baseURL            string
+        defaultModel       string
+        chatLogger         logging.ChatLogger
+        defaultTemperature *float64
+}
+
+type ollamaChatRequest struct {
+        Model    string      `json:"model"`
+        Messages []oaMessage `json:"messages"`
+        Stream   bool        `json:"stream"`
+        Options  any         `json:"options,omitempty"`
+}
+
+type ollamaChatResponse struct {
+        Message struct {
+                Role    string `json:"role"`
+                Content string `json:"content"`
+        } `json:"message"`
+        Done  bool   `json:"done"`
+        Error string `json:"error,omitempty"`
+}
+
+// Constructor (kept among the first functions by convention)
+func newOllama(baseURL, model string, defaultTemp *float64) Client {
+        if strings.TrimSpace(baseURL) == "" {
+                baseURL = "http://localhost:11434"
+        }
+        if strings.TrimSpace(model) == "" {
+                model = "qwen3-coder:30b-a3b-q4_K_M`"
+        }
+        return ollamaClient{
+                httpClient:         &http.Client{Timeout: 30 * time.Second},
+                baseURL:            strings.TrimRight(baseURL, "/"),
+                defaultModel:       model,
+                chatLogger:         logging.NewChatLogger("ollama"),
+                defaultTemperature: defaultTemp,
+        }
+}
+
+func (c ollamaClient) Chat(ctx context.Context, messages []Message, opts ...RequestOption) (string, error) {
+        o := Options{Model: c.defaultModel}
+        for _, opt := range opts {
+                opt(&o)
+        }
+        if o.Model == "" {
+                o.Model = c.defaultModel
+        }
+
+        start := time.Now()
+        c.logStart(false, o, messages)
+        req := buildOllamaRequest(o, messages, c.defaultTemperature, false)
+        body, err := json.Marshal(req)
+        if err != nil {
+                return "", err
+        }
+
+        endpoint := c.baseURL + "/api/chat"
+        logging.Logf("llm/ollama ", "POST %s", endpoint)
+        resp, err := c.doJSON(ctx, endpoint, body)
+        if err != nil {
+                logging.Logf("llm/ollama ", "%shttp error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+                return "", err
+        }
+        defer resp.Body.Close()
+        if err := handleOllamaNon2xx(resp, start); err != nil {
+                return "", err
+        }
+
+        var out ollamaChatResponse
+        if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+                logging.Logf("llm/ollama ", "%sdecode error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+                return "", err
+        }
+        if strings.TrimSpace(out.Message.Content) == "" {
+                logging.Logf("llm/ollama ", "%sempty content returned duration=%s%s", logging.AnsiRed, time.Since(start), logging.AnsiBase)
+                return "", errors.New("ollama: empty content")
+        }
+        content := out.Message.Content
+        logging.Logf("llm/ollama ", "success size=%d preview=%s%s%s duration=%s", len(content), logging.AnsiGreen, logging.PreviewForLog(content), logging.AnsiBase, time.Since(start))
+        return content, nil
+}
+
+// Provider metadata
+func (c ollamaClient) Name() string         { return "ollama" }
+func (c ollamaClient) DefaultModel() string { return c.defaultModel }
+
+// Streaming support (optional)
+func (c ollamaClient) ChatStream(ctx context.Context, messages []Message, onDelta func(string), opts ...RequestOption) error {
+        o := Options{Model: c.defaultModel}
+        for _, opt := range opts {
+                opt(&o)
+        }
+        if o.Model == "" {
+                o.Model = c.defaultModel
+        }
+
+        start := time.Now()
+        c.logStart(true, o, messages)
+        req := buildOllamaRequest(o, messages, c.defaultTemperature, true)
+        body, err := json.Marshal(req)
+        if err != nil {
+                return err
+        }
+
+        endpoint := c.baseURL + "/api/chat"
+        logging.Logf("llm/ollama ", "POST %s (stream)", endpoint)
+        resp, err := c.doJSON(ctx, endpoint, body)
+        if err != nil {
+                logging.Logf("llm/ollama ", "%shttp error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+                return err
+        }
+        defer resp.Body.Close()
+        if err := handleOllamaNon2xx(resp, start); err != nil {
+                return err
+        }
+
+        dec := json.NewDecoder(resp.Body)
+        for {
+                var ev ollamaChatResponse
+                if err := dec.Decode(&ev); err != nil {
+                        if errors.Is(err, io.EOF) {
+                                break
+                        }
+                        logging.Logf("llm/ollama ", "%sdecode stream error after %s: %v%s", logging.AnsiRed, time.Since(start), err, logging.AnsiBase)
+                        return err
+                }
+                if strings.TrimSpace(ev.Error) != "" {
+                        logging.Logf("llm/ollama ", "%sstream event error: %s%s", logging.AnsiRed, ev.Error, logging.AnsiBase)
+                        return fmt.Errorf("ollama stream error: %s", ev.Error)
+                }
+                if s := ev.Message.Content; strings.TrimSpace(s) != "" {
+                        onDelta(s)
+                }
+                if ev.Done {
+                        break
+                }
+        }
+        logging.Logf("llm/ollama ", "stream end duration=%s", time.Since(start))
+        return nil
+}
+
+// helpers to keep methods small
+func (c ollamaClient) logStart(stream bool, o Options, messages []Message) {
+        logMessages := make([]struct{ Role, Content string }, len(messages))
+        for i, m := range messages {
+                logMessages[i] = struct{ Role, Content string }{m.Role, m.Content}
+        }
+        c.chatLogger.LogStart(stream, o.Model, o.Temperature, o.MaxTokens, o.Stop, logMessages)
+}
+
+func buildOllamaRequest(o Options, messages []Message, defaultTemp *float64, stream bool) ollamaChatRequest {
+        req := ollamaChatRequest{Model: o.Model, Stream: stream}
+        req.Messages = make([]oaMessage, len(messages))
+        for i, m := range messages {
+                req.Messages[i] = oaMessage{Role: m.Role, Content: m.Content}
+        }
+        optsMap := map[string]any{}
+        if o.Temperature != 0 {
+                optsMap["temperature"] = o.Temperature
+        } else if defaultTemp != nil {
+                optsMap["temperature"] = *defaultTemp
+        }
+        if o.MaxTokens > 0 {
+                optsMap["num_predict"] = o.MaxTokens
+        }
+        if len(o.Stop) > 0 {
+                optsMap["stop"] = o.Stop
+        }
+        if len(optsMap) > 0 {
+                req.Options = optsMap
+        }
+        return req
+}
+
+func (c ollamaClient) doJSON(ctx context.Context, url string, body []byte) (*http.Response, error) {
+        req, err := http.NewRequestWithContext(ctx, http.MethodPo