Merge pull request #25 from kujtimiihoxha/cleanup-logs-status

Cleanup Logs and Status

Author: kujtimiihoxha

cmd/root.go

@@ -107,16 +107,6 @@ func setupSubscriptions(app *app.App) (chan tea.Msg, func()) {
 wg.Done()
 }()
 }
-{
-sub := app.Status.Subscribe(ctx)
-wg.Add(1)
-go func() {
-for ev := range sub {
-ch <- ev
-}
-wg.Done()
-}()
-}
 return ch, func() {
 cancel()
 wg.Wait()

internal/app/services.go

@@ -11,9 +11,7 @@ import (
 "github.com/kujtimiihoxha/termai/internal/lsp/watcher"
 "github.com/kujtimiihoxha/termai/internal/message"
 "github.com/kujtimiihoxha/termai/internal/permission"
-"github.com/kujtimiihoxha/termai/internal/pubsub"
 "github.com/kujtimiihoxha/termai/internal/session"
-"github.com/kujtimiihoxha/termai/internal/tui/util"
 )
 
 type App struct {
@@ -27,16 +25,14 @@ type App struct {
 
 Logger logging.Interface
 
-Status *pubsub.Broker[util.InfoMsg]
 ceanups []func()
 }
 
 func New(ctx context.Context, conn *sql.DB) *App {
 cfg := config.Get()
 q := db.New(conn)
-log := logging.NewLogger(logging.Options{
-Level: cfg.Log.Level,
-})
+log := logging.Get()
+log.SetLevel(cfg.Log.Level)
 sessions := session.NewService(ctx, q)
 messages := message.NewService(ctx, q)
 
@@ -46,7 +42,6 @@ func New(ctx context.Context, conn *sql.DB) *App {
 Messages: messages,
 Permissions: permission.NewPermissionService(),
 Logger: log,
-Status: pubsub.NewBroker[util.InfoMsg](),
 LSPClients: make(map[string]*lsp.Client),
 }
 

internal/config/config.go

@@ -70,6 +70,8 @@ type Config struct {
 LSP map[string]LSPConfig `json:"lsp,omitempty"`
 
 Model *Model `json:"model,omitempty"`
+
+Debug bool `json:"debug,omitempty"`
 }
 
 var cfg *Config
@@ -95,8 +97,10 @@ func Load(debug bool) error {
 // Add defaults
 viper.SetDefault("data.directory", defaultDataDirectory)
 if debug {
+viper.SetDefault("debug", true)
 viper.Set("log.level", "debug")
 } else {
+viper.SetDefault("debug", false)
 viper.SetDefault("log.level", defaultLogLevel)
 }
 

internal/llm/agent/agent.go

@@ -4,7 +4,6 @@ import (
 "context"
 "errors"
 "fmt"
-"log"
 "strings"
 "sync"
 
@@ -15,8 +14,6 @@ import (
 "github.com/kujtimiihoxha/termai/internal/llm/provider"
 "github.com/kujtimiihoxha/termai/internal/llm/tools"
 "github.com/kujtimiihoxha/termai/internal/message"
-"github.com/kujtimiihoxha/termai/internal/pubsub"
-"github.com/kujtimiihoxha/termai/internal/tui/util"
 )
 
 type Agent interface {
@@ -94,24 +91,13 @@ func (c *agent) processEvent(
 assistantMsg.AppendContent(event.Content)
 return c.Messages.Update(*assistantMsg)
 case provider.EventError:
-// TODO: remove when realease
-log.Println("error", event.Error)
-c.App.Status.Publish(pubsub.UpdatedEvent, util.InfoMsg{
-Type: util.InfoTypeError,
-Msg: event.Error.Error(),
-})
+c.App.Logger.PersistError(event.Error.Error())
 return event.Error
 case provider.EventWarning:
-c.App.Status.Publish(pubsub.UpdatedEvent, util.InfoMsg{
-Type: util.InfoTypeWarn,
-Msg: event.Info,
-})
+c.App.Logger.PersistWarn(event.Info)
 return nil
 case provider.EventInfo:
-c.App.Status.Publish(pubsub.UpdatedEvent, util.InfoMsg{
-Type: util.InfoTypeInfo,
-Msg: event.Info,
-})
+c.App.Logger.PersistInfo(event.Info)
 case provider.EventComplete:
 assistantMsg.SetToolCalls(event.Response.ToolCalls)
 assistantMsg.AddFinish(event.Response.FinishReason)

internal/llm/agent/mcp-tools.go

@@ -4,10 +4,10 @@ import (
 "context"
 "encoding/json"
 "fmt"
-"log"
 
 "github.com/kujtimiihoxha/termai/internal/config"
 "github.com/kujtimiihoxha/termai/internal/llm/tools"
+"github.com/kujtimiihoxha/termai/internal/logging"
 "github.com/kujtimiihoxha/termai/internal/permission"
 "github.com/kujtimiihoxha/termai/internal/version"
 
@@ -22,6 +22,8 @@ type mcpTool struct {
 permissions permission.Service
 }
 
+var logger = logging.Get()
+
 type MCPClient interface {
 Initialize(
 ctx context.Context,
@@ -141,13 +143,13 @@ func getTools(ctx context.Context, name string, m config.MCPServer, permissions
 
 _, err := c.Initialize(ctx, initRequest)
 if err != nil {
-log.Printf("error initializing mcp client: %s", err)
+logger.Error("error initializing mcp client", "error", err)
 return stdioTools
 }
 toolsRequest := mcp.ListToolsRequest{}
 tools, err := c.ListTools(ctx, toolsRequest)
 if err != nil {
-log.Printf("error listing tools: %s", err)
+logger.Error("error listing tools", "error", err)
 return stdioTools
 }
 for _, t := range tools.Tools {
@@ -170,7 +172,7 @@ func GetMcpTools(ctx context.Context, permissions permission.Service) []tools.Ba
 m.Args...,
 )
 if err != nil {
-log.Printf("error creating mcp client: %s", err)
+logger.Error("error creating mcp client", "error", err)
 continue
 }
 
@@ -181,7 +183,7 @@ func GetMcpTools(ctx context.Context, permissions permission.Service) []tools.Ba
 client.WithHeaders(m.Headers),
 )
 if err != nil {
-log.Printf("error creating mcp client: %s", err)
+logger.Error("error creating mcp client", "error", err)
 continue
 }
 mcpTools = append(mcpTools, getTools(ctx, name, m, permissions, c)...)

internal/llm/provider/anthropic.go

@@ -159,40 +159,9 @@ func (a *anthropicProvider) StreamResponse(ctx context.Context, messages []messa
 attempts := 0
 
 for {
-// If this isn't the first attempt, we're retrying
-if attempts > 0 {
-if attempts > maxRetries {
-eventChan <- ProviderEvent{
-Type: EventError,
-Error: errors.New("maximum retry attempts reached for rate limit (429)"),
-}
-return
-}
-
-// Inform user we're retrying with attempt number
-eventChan <- ProviderEvent{
-Type: EventWarning,
-Info: fmt.Sprintf("[Retrying due to rate limit... attempt %d of %d]", attempts, maxRetries),
-}
-
-// Calculate backoff with exponential backoff and jitter
-backoffMs := 2000 * (1 << (attempts - 1)) // 2s, 4s, 8s, 16s, 32s
-jitterMs := int(float64(backoffMs) * 0.2)
-totalBackoffMs := backoffMs + jitterMs
-
-// Sleep with backoff, respecting context cancellation
-select {
-case <-ctx.Done():
-eventChan <- ProviderEvent{Type: EventError, Error: ctx.Err()}
-return
-case <-time.After(time.Duration(totalBackoffMs) * time.Millisecond):
-// Continue with retry
-}
-}
 
 attempts++
 
-// Create new streaming request
 stream := a.client.Messages.NewStreaming(
 ctx,
 anthropic.MessageNewParams{
@@ -213,11 +182,8 @@ func (a *anthropicProvider) StreamResponse(ctx context.Context, messages []messa
 },
 )
 
-// Process stream events
 accumulatedMessage := anthropic.Message{}
-streamSuccess := false
 
-// Process the stream until completion or error
 for stream.Next() {
 event := stream.Current()
 err := accumulatedMessage.Accumulate(event)
@@ -247,7 +213,6 @@ func (a *anthropicProvider) StreamResponse(ctx context.Context, messages []messa
 eventChan <- ProviderEvent{Type: EventContentStop}
 
 case anthropic.MessageStopEvent:
-streamSuccess = true
 content := ""
 for _, block := range accumulatedMessage.Content {
 if text, ok := block.AsAny().(anthropic.TextBlock); ok {
@@ -270,51 +235,59 @@ func (a *anthropicProvider) StreamResponse(ctx context.Context, messages []messa
 }
 }
 
-// If the stream completed successfully, we're done
-if streamSuccess {
+err := stream.Err()
+if err == nil {
 return
 }
 
-// Check for stream errors
-err := stream.Err()
-if err != nil {
-var apierr *anthropic.Error
-if errors.As(err, &apierr) {
-if apierr.StatusCode == 429 || apierr.StatusCode == 529 {
-// Check for Retry-After header
-if retryAfterValues := apierr.Response.Header.Values("Retry-After"); len(retryAfterValues) > 0 {
-// Parse the retry after value (seconds)
-var retryAfterSec int
-if _, err := fmt.Sscanf(retryAfterValues[0], "%d", &retryAfterSec); err == nil {
-retryMs := retryAfterSec * 1000
-
-// Inform user of retry with specific wait time
-eventChan <- ProviderEvent{
-Type: EventWarning,
-Info: fmt.Sprintf("[Rate limited: waiting %d seconds as specified by API]", retryAfterSec),
-}
-
-// Sleep respecting context cancellation
-select {
-case <-ctx.Done():
-eventChan <- ProviderEvent{Type: EventError, Error: ctx.Err()}
-return
-case <-time.After(time.Duration(retryMs) * time.Millisecond):
-// Continue with retry after specified delay
-continue
-}
-}
-}
+var apierr *anthropic.Error
+if !errors.As(err, &apierr) {
+eventChan <- ProviderEvent{Type: EventError, Error: err}
+return
+}
 
-// Fall back to exponential backoff if Retry-After parsing failed
-continue
+if apierr.StatusCode != 429 && apierr.StatusCode != 529 {
+eventChan <- ProviderEvent{Type: EventError, Error: err}
+return
+}
+
+if attempts > maxRetries {
+eventChan <- ProviderEvent{
+Type: EventError,
+Error: errors.New("maximum retry attempts reached for rate limit (429)"),
+}
+return
+}
+
+retryMs := 0
+retryAfterValues := apierr.Response.Header.Values("Retry-After")
+if len(retryAfterValues) > 0 {
+var retryAfterSec int
+if _, err := fmt.Sscanf(retryAfterValues[0], "%d", &retryAfterSec); err == nil {
+retryMs = retryAfterSec * 1000
+eventChan <- ProviderEvent{
+Type: EventWarning,
+Info: fmt.Sprintf("[Rate limited: waiting %d seconds as specified by API]", retryAfterSec),
 }
 }
+} else {
+eventChan <- ProviderEvent{
+Type: EventWarning,
+Info: fmt.Sprintf("[Retrying due to rate limit... attempt %d of %d]", attempts, maxRetries),
+}
 
-// For non-rate limit errors, report and exit
-eventChan <- ProviderEvent{Type: EventError, Error: err}
+backoffMs := 2000 * (1 << (attempts - 1))
+jitterMs := int(float64(backoffMs) * 0.2)
+retryMs = backoffMs + jitterMs
+}
+select {
+case <-ctx.Done():
+eventChan <- ProviderEvent{Type: EventError, Error: ctx.Err()}
 return
+case <-time.After(time.Duration(retryMs) * time.Millisecond):
+continue
 }
+
 }
 }()
 
@@ -412,7 +385,6 @@ func (a *anthropicProvider) convertToAnthropicMessages(messages []message.Messag
 blocks = append(blocks, anthropic.ContentBlockParamOfRequestToolUseBlock(toolCall.ID, inputMap, toolCall.Name))
 }
 
-// Skip empty assistant messages completely
 if len(blocks) > 0 {
 anthropicMessages = append(anthropicMessages, anthropic.NewAssistantMessage(blocks...))
 }

internal/llm/provider/gemini.go

@@ -4,14 +4,12 @@ import (
 "context"
 "encoding/json"
 "errors"
-"log"
 
 "github.com/google/generative-ai-go/genai"
 "github.com/google/uuid"
 "github.com/kujtimiihoxha/termai/internal/llm/models"
 "github.com/kujtimiihoxha/termai/internal/llm/tools"
 "github.com/kujtimiihoxha/termai/internal/message"
-"google.golang.org/api/googleapi"
 "google.golang.org/api/iterator"
 "google.golang.org/api/option"
 )
@@ -242,10 +240,6 @@ func (p *geminiProvider) StreamResponse(ctx context.Context, messages []message.
 break
 }
 if err != nil {
-var apiErr *googleapi.Error
-if errors.As(err, &apiErr) {
-log.Printf("%s", apiErr.Body)
-}
 eventChan <- ProviderEvent{
 Type: EventError,
 Error: err,

internal/llm/tools/fetch.go

@@ -121,11 +121,7 @@ func (t *fetchTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error
 ToolName: FetchToolName,
 Action: "fetch",
 Description: fmt.Sprintf("Fetch content from URL: %s", params.URL),
-Params: FetchPermissionsParams{
-URL: params.URL,
-Format: params.Format,
-Timeout: params.Timeout,
-},
+Params: FetchPermissionsParams(params),
 },
 )