@@ -13,168 +13,149 @@ import (
1313 "github.com/xonecas/symb/internal/config"
1414 "github.com/xonecas/symb/internal/lsp"
1515 "github.com/xonecas/symb/internal/mcp"
16- "github.com/xonecas/symb/internal/mcp_tools"
16+ "github.com/xonecas/symb/internal/mcptools"
1717 "github.com/xonecas/symb/internal/provider"
1818 "github.com/xonecas/symb/internal/store"
1919 "github.com/xonecas/symb/internal/tui"
2020 )
2121
2222 func main() {
23- // Configure zerolog to write to file (TUI uses stdout)
2423 if err := setupFileLogging(); err != nil {
2524 fmt.Fprintf(os.Stderr, "Warning: failed to setup logging: %v\n", err)
2625 }
27- // Load configuration
28- configPath := filepath.Join(".", "config.toml")
29- cfg, err := config.Load(configPath)
26+
27+ cfg, err := config.Load(filepath.Join(".", "config.toml"))
3028 if err != nil {
3129 fmt.Printf("Error loading config: %v\n", err)
3230 os.Exit(1)
3331 }
3432
35- // Load credentials
3633 creds, err := config.LoadCredentials()
3734 if err != nil {
3835 fmt.Printf("Error loading credentials: %v\n", err)
3936 os.Exit(1)
4037 }
4138
42- // Create provider registry
43- registry := provider.NewRegistry()
39+ registry := buildRegistry(cfg, creds)
4440
45- // Register all providers from config
46- for name, providerCfg := range cfg.Providers {
47- var factory provider.ProviderFactory
41+ providerName, providerCfg := resolveProvider(cfg, registry)
42+
43+ prov, err := registry.Create(providerName, providerCfg.Model, providerCfg.Temperature)
44+ if err != nil {
45+ fmt.Printf("Error creating provider: %v\n", err)
46+ os.Exit(1)
47+ }
48+ defer prov.Close()
49+
50+ proxy, lspManager, showHandler, webCache := setupServices(cfg, creds)
51+ defer proxy.Close()
52+ defer lspManager.StopAll(context.Background())
53+ if webCache != nil {
54+ defer webCache.Close()
55+ }
56+
57+ tools, err := proxy.ListTools(context.Background())
58+ if err != nil {
59+ fmt.Printf("Warning: Failed to list tools: %v\n", err)
60+ tools = []mcp.Tool{}
61+ }
4862
63+ p := tea.NewProgram(
64+ tui.New(prov, proxy, tools, providerCfg.Model),
65+ tea.WithFilter(tui.MouseEventFilter),
66+ )
67+ showHandler.SetProgram(p)
68+ lspManager.SetCallback(func(absPath string, lines map[int]int) {
69+ p.Send(tui.LSPDiagnosticsMsg{FilePath: absPath, Lines: lines})
70+ })
71+
72+ if _, err := p.Run(); err != nil {
73+ fmt.Printf("Error running symb: %v\n", err)
74+ os.Exit(1)
75+ }
76+}
77+
78+func buildRegistry(cfg *config.Config, creds *config.Credentials) *provider.Registry {
79+ registry := provider.NewRegistry()
80+ for name, providerCfg := range cfg.Providers {
81+ var factory provider.Factory
4982 if providerCfg.APIKeyName != "" {
50- apiKey := creds.GetAPIKey(providerCfg.APIKeyName)
51- factory = provider.NewOpenCodeFactory(name, providerCfg.Endpoint, apiKey)
83+ factory = provider.NewOpenCodeFactory(name, providerCfg.Endpoint, creds.GetAPIKey(providerCfg.APIKeyName))
5284 } else {
5385 factory = provider.NewOllamaFactory(name, providerCfg.Endpoint)
5486 }
55-
5687 registry.RegisterFactory(name, factory)
5788 }
89+ return registry
90+}
5891
59- // Get default provider
60- providerName := cfg.DefaultProvider
61- if providerName == "" {
92+func resolveProvider(cfg *config.Config, registry *provider.Registry) (string, config.ProviderConfig) {
93+ name := cfg.DefaultProvider
94+ if name == "" {
6295 providers := registry.List()
6396 if len(providers) == 0 {
6497 fmt.Println("Error: No providers configured")
6598 os.Exit(1)
6699 }
67- providerName = providers[0]
100+ name = providers[0]
68101 }
69-
70- providerCfg, ok := cfg.Providers[providerName]
102+ pcfg, ok := cfg.Providers[name]
71103 if !ok {
72- fmt.Printf("Error: Provider %q not found\n", providerName)
104+ fmt.Printf("Error: Provider %q not found\n", name)
73105 os.Exit(1)
74106 }
107+ return name, pcfg
108+}
75109
76- // Create provider
77- prov, err := registry.Create(providerName, providerCfg.Model, providerCfg.Temperature)
78- if err != nil {
79- fmt.Printf("Error creating provider: %v\n", err)
80- os.Exit(1)
81- }
82- defer prov.Close()
83-
84- // Create MCP proxy
110+func setupServices(cfg *config.Config, creds *config.Credentials) (*mcp.Proxy, *lsp.Manager, *mcptools.ShowHandler, *store.Cache) {
85111 var mcpClient mcp.UpstreamClient
86112 if cfg.MCP.Upstream != "" {
87113 mcpClient = mcp.NewClient(cfg.MCP.Upstream)
88114 }
89-
90115 proxy := mcp.NewProxy(mcpClient)
91116 if err := proxy.Initialize(context.Background()); err != nil {
92117 fmt.Printf("Warning: MCP init failed: %v\n", err)
93118 }
94- defer proxy.Close()
95119
96- // Create LSP manager
97120 lspManager := lsp.NewManager()
98- defer lspManager.StopAll(context.Background())
121+ fileTracker := mcptools.NewFileReadTracker()
99122
100- // Register local tools
101- fileTracker := mcp_tools.NewFileReadTracker()
123+ readHandler := mcptools.NewReadHandler(fileTracker, lspManager)
124+ proxy.RegisterTool(mcptools.NewReadTool(), readHandler.Handle)
102125
103- readTool := mcp_tools.NewReadTool()
104- readHandler := mcp_tools.NewReadHandler(fileTracker, lspManager)
105- proxy.RegisterTool(readTool, readHandler.Handle)
126+ showHandler := mcptools.NewShowHandler()
127+ proxy.RegisterTool(mcptools.NewShowTool(), showHandler.Handle)
106128
107- showTool := mcp_tools.NewShowTool()
108- showHandler := mcp_tools.NewShowHandler()
109- proxy.RegisterTool(showTool, showHandler.Handle)
129+ proxy.RegisterTool(mcptools.NewGrepTool(), mcptools.MakeGrepHandler())
110130
111- grepTool := mcp_tools.NewGrepTool()
112- grepHandler := mcp_tools.MakeGrepHandler()
113- proxy.RegisterTool(grepTool, grepHandler)
131+ editHandler := mcptools.NewEditHandler(fileTracker, lspManager)
132+ proxy.RegisterTool(mcptools.NewEditTool(), editHandler.Handle)
114133
115- editTool := mcp_tools.NewEditTool()
116- editHandler := mcp_tools.NewEditHandler(fileTracker, lspManager)
117- proxy.RegisterTool(editTool, editHandler.Handle)
134+ webCache := openWebCache(cfg)
118135
119- // Open web cache (SQLite-backed, persisted across sessions).
120- // If data dir or db open fails, webCache stays nil — handlers degrade gracefully.
121- var webCache *store.Cache
122- if cacheDir, err := config.EnsureDataDir(); err != nil {
123- fmt.Printf("Warning: cache dir failed: %v\n", err)
124- } else {
125- cacheTTL := time.Duration(cfg.Cache.CacheTTLOrDefault()) * time.Hour
126- webCache, err = store.Open(filepath.Join(cacheDir, "cache.db"), cacheTTL)
127- if err != nil {
128- fmt.Printf("Warning: cache open failed: %v\n", err)
129- }
130- }
131- if webCache != nil {
132- defer webCache.Close()
133- }
134-
135- // Register git tools
136- gitStatusTool := mcp_tools.NewGitStatusTool()
137- proxy.RegisterTool(gitStatusTool, mcp_tools.MakeGitStatusHandler())
138-
139- gitDiffTool := mcp_tools.NewGitDiffTool()
140- proxy.RegisterTool(gitDiffTool, mcp_tools.MakeGitDiffHandler())
141-
142- // Register web tools
143- webFetchTool := mcp_tools.NewWebFetchTool()
144- webFetchHandler := mcp_tools.MakeWebFetchHandler(webCache)
145- proxy.RegisterTool(webFetchTool, webFetchHandler)
136+ proxy.RegisterTool(mcptools.NewGitStatusTool(), mcptools.MakeGitStatusHandler())
137+ proxy.RegisterTool(mcptools.NewGitDiffTool(), mcptools.MakeGitDiffHandler())
138+ proxy.RegisterTool(mcptools.NewWebFetchTool(), mcptools.MakeWebFetchHandler(webCache))
146139
147140 exaKey := creds.GetAPIKey("exa_ai")
148- webSearchTool := mcp_tools.NewWebSearchTool()
149- webSearchHandler := mcp_tools.MakeWebSearchHandler(webCache, exaKey, "")
150- proxy.RegisterTool(webSearchTool, webSearchHandler)
141+ proxy.RegisterTool(mcptools.NewWebSearchTool(), mcptools.MakeWebSearchHandler(webCache, exaKey, ""))
151142
152- // List all tools (local + upstream)
153- tools, err := proxy.ListTools(context.Background())
143+ return proxy, lspManager, showHandler, webCache
144+}
145+
146+func openWebCache(cfg *config.Config) *store.Cache {
147+ cacheDir, err := config.EnsureDataDir()
154148 if err != nil {
155- fmt.Printf("Warning: Failed to list tools: %v\n", err)
156- tools = []mcp.Tool{}
149+ fmt.Printf("Warning: cache dir failed: %v\n", err)
150+ return nil
157151 }
158-
159- // Create the BubbleTea program with model-specific prompt
160- p := tea.NewProgram(
161- tui.New(prov, proxy, tools, providerCfg.Model),
162- tea.WithFilter(tui.MouseEventFilter),
163- )
164-
165- // Set program reference for tools that need it
166- showHandler.SetProgram(p)
167-
168- // Wire LSP diagnostics callback to TUI
169- lspManager.SetCallback(func(absPath string, lines map[int]int) {
170- p.Send(tui.LSPDiagnosticsMsg{FilePath: absPath, Lines: lines})
171- })
172-
173- // Run the program
174- if _, err := p.Run(); err != nil {
175- fmt.Printf("Error running symb: %v\n", err)
176- os.Exit(1)
152+ cacheTTL := time.Duration(cfg.Cache.CacheTTLOrDefault()) * time.Hour
153+ cache, err := store.Open(filepath.Join(cacheDir, "cache.db"), cacheTTL)
154+ if err != nil {
155+ fmt.Printf("Warning: cache open failed: %v\n", err)
156+ return nil
177157 }
158+ return cache
178159 }
179160
180161 func setupFileLogging() error {