@@ -1,12 +1,20 @@
11 package main
22
33 import (
4+ "bufio"
5+ "context"
6+ "encoding/json"
47 "flag"
58 "fmt"
69 "os"
10+ "strings"
711
812 "github.com/rs/zerolog"
913 "github.com/rs/zerolog/log"
14+ "github.com/xonecas/mysis/internal/config"
15+ "github.com/xonecas/mysis/internal/mcp"
16+ "github.com/xonecas/mysis/internal/provider"
17+ "github.com/xonecas/mysis/internal/styles"
1018 )
1119
1220 // Version is set at build time via ldflags.
@@ -15,9 +23,10 @@ var Version = "dev"
1523 func main() {
1624 // Parse flags
1725 var (
18- showVersion = flag.Bool("version", false, "Show version and exit")
19- configPath = flag.String("config", "config.toml", "Path to config file")
20- debug = flag.Bool("debug", false, "Enable debug logging")
26+ showVersion = flag.Bool("version", false, "Show version and exit")
27+ configPath = flag.String("config", "", "Path to config file")
28+ debug = flag.Bool("debug", false, "Enable debug logging")
29+ providerName = flag.String("p", "", "Provider name (overrides default from config)")
2130 )
2231 flag.Parse()
2332
@@ -27,18 +36,346 @@ func main() {
2736 }
2837
2938 // Initialize logging
39+ zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
40+ log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
3041 if *debug {
3142 zerolog.SetGlobalLevel(zerolog.DebugLevel)
3243 } else {
3344 zerolog.SetGlobalLevel(zerolog.InfoLevel)
3445 }
3546
36- // TODO: Initialize application
47+ // Find config file
48+ if *configPath == "" {
49+ // Try current directory first, then ~/.config/mysis/
50+ if _, err := os.Stat("config.toml"); err == nil {
51+ *configPath = "config.toml"
52+ } else {
53+ dataDir, err := config.DataDir()
54+ if err == nil {
55+ *configPath = dataDir + "/config.toml"
56+ }
57+ }
58+ }
59+
60+ if *configPath == "" {
61+ fmt.Fprintln(os.Stderr, styles.Error.Render("Error: config file not found"))
62+ fmt.Fprintln(os.Stderr, "Tried: ./config.toml and ~/.config/mysis/config.toml")
63+ os.Exit(1)
64+ }
65+
3766 log.Info().
3867 Str("version", Version).
3968 Str("config", *configPath).
4069 Msg("Starting Mysis")
4170
42- fmt.Println("Mysis - SpaceMolt Client")
43- fmt.Println("TODO: Initialize application")
71+ // Load config
72+ cfg, err := config.Load(*configPath)
73+ if err != nil {
74+ fmt.Fprintln(os.Stderr, styles.Error.Render("Failed to load config: "+err.Error()))
75+ os.Exit(1)
76+ }
77+
78+ // Load credentials
79+ creds, err := config.LoadCredentials()
80+ if err != nil {
81+ log.Warn().Err(err).Msg("Failed to load credentials, using empty credentials")
82+ creds = &config.Credentials{}
83+ }
84+
85+ // Initialize provider registry
86+ registry := initializeProviders(cfg, creds)
87+
88+ // Select provider
89+ selectedProvider := *providerName
90+ if selectedProvider == "" {
91+ // Use first provider from config
92+ for name := range cfg.Providers {
93+ selectedProvider = name
94+ break
95+ }
96+ }
97+
98+ if selectedProvider == "" {
99+ fmt.Fprintln(os.Stderr, styles.Error.Render("Error: no provider configured"))
100+ os.Exit(1)
101+ }
102+
103+ providerCfg, ok := cfg.Providers[selectedProvider]
104+ if !ok {
105+ fmt.Fprintln(os.Stderr, styles.Error.Render(fmt.Sprintf("Error: provider '%s' not found in config", selectedProvider)))
106+ os.Exit(1)
107+ }
108+
109+ prov, err := registry.Create(selectedProvider, providerCfg.Model, providerCfg.Temperature)
110+ if err != nil {
111+ fmt.Fprintln(os.Stderr, styles.Error.Render("Failed to create provider: "+err.Error()))
112+ os.Exit(1)
113+ }
114+ defer prov.Close()
115+
116+ log.Info().
117+ Str("provider", selectedProvider).
118+ Str("model", providerCfg.Model).
119+ Msg("Provider initialized")
120+
121+ // Initialize MCP client
122+ ctx := context.Background()
123+ mcpClient := mcp.NewClient(cfg.MCP.Upstream)
124+ proxy := mcp.NewProxy(mcpClient)
125+
126+ if err := proxy.Initialize(ctx); err != nil {
127+ log.Warn().Err(err).Msg("Failed to initialize MCP - continuing without game tools")
128+ } else {
129+ log.Info().Str("upstream", cfg.MCP.Upstream).Msg("MCP proxy initialized")
130+ }
131+ defer proxy.Close()
132+
133+ // Get available tools
134+ tools, err := proxy.ListTools(ctx)
135+ if err != nil {
136+ log.Warn().Err(err).Msg("Failed to list tools - continuing without tools")
137+ tools = []mcp.Tool{}
138+ } else {
139+ log.Info().Int("count", len(tools)).Msg("Tools available")
140+ }
141+
142+ // Print welcome message
143+ fmt.Println(styles.Brand.Render("╔══════════════════════════════════════╗"))
144+ fmt.Println(styles.Brand.Render("║") + " " + styles.BrandBold.Render("Mysis") + " - SpaceMolt Agent CLI " + styles.Brand.Render("║"))
145+ fmt.Println(styles.Brand.Render("╚══════════════════════════════════════╝"))
146+ fmt.Println()
147+ fmt.Println(styles.Muted.Render(fmt.Sprintf("Provider: %s (%s)", selectedProvider, providerCfg.Model)))
148+ fmt.Println(styles.Muted.Render(fmt.Sprintf("Tools: %d available", len(tools))))
149+ fmt.Println()
150+
151+ // Start conversation loop
152+ app := &App{
153+ provider: prov,
154+ proxy: proxy,
155+ tools: tools,
156+ history: []provider.Message{},
157+ }
158+
159+ if err := app.Run(ctx); err != nil {
160+ fmt.Fprintln(os.Stderr, styles.Error.Render("Error: "+err.Error()))
161+ os.Exit(1)
162+ }
163+}
164+
165+// App holds the application state
166+type App struct {
167+ provider provider.Provider
168+ proxy *mcp.Proxy
169+ tools []mcp.Tool
170+ history []provider.Message
171+}
172+
173+// Run starts the conversation loop
174+func (app *App) Run(ctx context.Context) error {
175+ scanner := bufio.NewScanner(os.Stdin)
176+
177+ for {
178+ // Display prompt
179+ fmt.Print(styles.Brand.Render("> "))
180+
181+ // Read user input
182+ if !scanner.Scan() {
183+ break
184+ }
185+
186+ input := strings.TrimSpace(scanner.Text())
187+ if input == "" {
188+ continue
189+ }
190+
191+ // Check for exit commands
192+ if input == "exit" || input == "quit" {
193+ fmt.Println(styles.Muted.Render("Goodbye!"))
194+ break
195+ }
196+
197+ // Add user message to history
198+ app.history = append(app.history, provider.Message{
199+ Role: "user",
200+ Content: input,
201+ })
202+
203+ // Process turn (may involve multiple LLM calls if tools are used)
204+ if err := app.processTurn(ctx); err != nil {
205+ fmt.Fprintln(os.Stderr, styles.Error.Render("Error: "+err.Error()))
206+ continue
207+ }
208+
209+ fmt.Println() // Blank line after response
210+ }
211+
212+ return scanner.Err()
213+}
214+
215+// processTurn handles one conversation turn, which may involve tool calls
216+func (app *App) processTurn(ctx context.Context) error {
217+ maxToolRounds := 10 // Prevent infinite loops
218+
219+ for round := 0; round < maxToolRounds; round++ {
220+ // Convert MCP tools to provider format
221+ providerTools := make([]provider.Tool, len(app.tools))
222+ for i, t := range app.tools {
223+ providerTools[i] = provider.Tool{
224+ Name: t.Name,
225+ Description: t.Description,
226+ Parameters: t.InputSchema,
227+ }
228+ }
229+
230+ // Call LLM with tools
231+ resp, err := app.provider.ChatWithTools(ctx, app.history, providerTools)
232+ if err != nil {
233+ return fmt.Errorf("LLM call failed: %w", err)
234+ }
235+
236+ // Display reasoning if present
237+ if resp.Reasoning != "" {
238+ fmt.Println(styles.Muted.Render("∴ " + resp.Reasoning))
239+ }
240+
241+ // If no tool calls, display text response and we're done
242+ if len(resp.ToolCalls) == 0 {
243+ if resp.Content != "" {
244+ fmt.Println(resp.Content)
245+ }
246+
247+ // Add assistant response to history
248+ app.history = append(app.history, provider.Message{
249+ Role: "assistant",
250+ Content: resp.Content,
251+ })
252+
253+ return nil
254+ }
255+
256+ // Tool calls present - add assistant message with tool calls to history
257+ app.history = append(app.history, provider.Message{
258+ Role: "assistant",
259+ Content: resp.Content,
260+ ToolCalls: resp.ToolCalls,
261+ })
262+
263+ // Execute each tool call
264+ for _, toolCall := range resp.ToolCalls {
265+ fmt.Print(styles.Secondary.Render(fmt.Sprintf("⚙ %s", toolCall.Name)))
266+
267+ // Show arguments (truncated if long)
268+ var args map[string]interface{}
269+ if err := json.Unmarshal(toolCall.Arguments, &args); err == nil {
270+ argsStr, _ := json.Marshal(args)
271+ if len(argsStr) > 60 {
272+ argsStr = argsStr[:57]
273+ argsStr = append(argsStr, '.', '.', '.')
274+ }
275+ fmt.Print(styles.Muted.Render(string(argsStr)))
276+ }
277+
278+ // Execute tool via MCP proxy
279+ result, err := app.proxy.CallTool(ctx, toolCall.Name, toolCall.Arguments)
280+
281+ if err != nil {
282+ fmt.Println(styles.Error.Render(" ✗"))
283+ fmt.Println(styles.Error.Render(" Error: " + err.Error()))
284+
285+ // Add error result to history
286+ app.history = append(app.history, provider.Message{
287+ Role: "tool",
288+ Content: fmt.Sprintf("Error: %v", err),
289+ ToolCallID: toolCall.ID,
290+ })
291+ continue
292+ }
293+
294+ // Check if result is an error
295+ if result.IsError {
296+ fmt.Println(styles.Error.Render(" ✗"))
297+ // Extract error text from content blocks
298+ var errText string
299+ for _, block := range result.Content {
300+ if block.Type == "text" {
301+ errText += block.Text
302+ }
303+ }
304+ if errText != "" {
305+ fmt.Println(styles.Error.Render(" " + errText))
306+ }
307+
308+ // Add error result to history
309+ app.history = append(app.history, provider.Message{
310+ Role: "tool",
311+ Content: errText,
312+ ToolCallID: toolCall.ID,
313+ })
314+ continue
315+ }
316+
317+ // Success
318+ fmt.Println(styles.Success.Render(" ✓"))
319+
320+ // Extract result content
321+ var resultText string
322+ for _, block := range result.Content {
323+ if block.Type == "text" {
324+ resultText += block.Text
325+ }
326+ }
327+
328+ // Show result preview (truncated)
329+ if len(resultText) > 100 {
330+ preview := resultText[:97] + "..."
331+ fmt.Println(styles.Muted.Render(" " + preview))
332+ } else if resultText != "" {
333+ fmt.Println(styles.Muted.Render(" " + resultText))
334+ }
335+
336+ // Add tool result to history
337+ app.history = append(app.history, provider.Message{
338+ Role: "tool",
339+ Content: resultText,
340+ ToolCallID: toolCall.ID,
341+ })
342+ }
343+
344+ // Continue loop to let LLM process tool results
345+ }
346+
347+ return fmt.Errorf("too many tool call rounds (limit: %d)", maxToolRounds)
348+}
349+
350+// initializeProviders creates and registers all configured providers
351+func initializeProviders(cfg *config.Config, creds *config.Credentials) *provider.Registry {
352+ registry := provider.NewRegistry()
353+
354+ for name, provCfg := range cfg.Providers {
355+ // Detect provider type based on endpoint
356+ if strings.Contains(provCfg.Endpoint, "localhost:11434") || strings.Contains(provCfg.Endpoint, "/ollama") {
357+ // Ollama provider
358+ factory := provider.NewOllamaFactory(name, provCfg.Endpoint)
359+ registry.RegisterFactory(name, factory)
360+ log.Debug().Str("name", name).Str("endpoint", provCfg.Endpoint).Msg("Registered Ollama provider")
361+ } else if strings.Contains(provCfg.Endpoint, "opencode.ai") {
362+ // OpenCode Zen provider
363+ keyName := provCfg.APIKeyName
364+ if keyName == "" {
365+ keyName = name
366+ }
367+ apiKey := creds.GetAPIKey(keyName)
368+ if apiKey == "" {
369+ log.Warn().Str("name", name).Str("key_name", keyName).Msg("No API key found for provider")
370+ continue
371+ }
372+ factory := provider.NewOpenCodeFactory(name, provCfg.Endpoint, apiKey)
373+ registry.RegisterFactory(name, factory)
374+ log.Debug().Str("name", name).Str("endpoint", provCfg.Endpoint).Msg("Registered OpenCode provider")
375+ } else {
376+ log.Warn().Str("name", name).Str("endpoint", provCfg.Endpoint).Msg("Unknown provider type")
377+ }
378+ }
379+
380+ return registry
44381 }