@@ -4,21 +4,17 @@ import (
44 "bufio"
55 "context"
66 "fmt"
7- "io"
87 "os"
9- "path/filepath"
108 "strings"
119 "sync"
1210 "time"
1311
14- "github.com/rs/zerolog"
1512 "github.com/rs/zerolog/log"
16- "github.com/xonecas/mysis/internal/config"
13+ "github.com/xonecas/mysis/internal/features"
1714 "github.com/xonecas/mysis/internal/llm"
1815 "github.com/xonecas/mysis/internal/mcp"
1916 "github.com/xonecas/mysis/internal/provider"
2017 "github.com/xonecas/mysis/internal/session"
21- "github.com/xonecas/mysis/internal/store"
2218 "github.com/xonecas/mysis/internal/styles"
2319 )
2420
@@ -30,179 +26,60 @@ type App struct {
3026 history []provider.Message
3127 sessionMgr *session.Manager
3228 sessionID string
33- autoplayEnabled bool
34- autoplayMessage string
35- autoplayCancel context.CancelFunc
36- mu sync.Mutex // Protects autoplay state and history
29+ autoplayService *features.Service // Autoplay service (display-agnostic)
30+ mu sync.Mutex // Protects history
3731 }
3832
39-// Run initializes and starts the CLI application.
40-func Run(version string) error {
41- // Parse flags
42- flags := ParseFlags(version)
43-
44- // Initialize logging
45- zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
46-
47- // In TUI mode, log to file instead of stderr to avoid collision
48- if flags.TUI {
49- if err := setupFileLogging(flags.Debug); err != nil {
50- return fmt.Errorf("failed to setup file logging: %w", err)
51- }
52- } else {
53- // CLI mode: log to stderr
54- log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
55- if flags.Debug {
56- zerolog.SetGlobalLevel(zerolog.DebugLevel)
57- } else {
58- zerolog.SetGlobalLevel(zerolog.InfoLevel)
59- }
60- }
61-
62- // Check config path
63- if flags.ConfigPath == "" {
64- fmt.Fprintln(os.Stderr, styles.Error.Render("Error: config file not found"))
65- fmt.Fprintln(os.Stderr, "Tried: ./config.toml and ~/.config/mysis/config.toml")
66- return fmt.Errorf("config file not found")
67- }
68-
69- log.Info().
70- Str("version", version).
71- Str("config", flags.ConfigPath).
72- Msg("Starting Mysis")
73-
74- // Load config
75- cfg, err := config.Load(flags.ConfigPath)
76- if err != nil {
77- return fmt.Errorf("failed to load config: %w", err)
78- }
79-
80- // Open database
81- db, err := store.Open()
82- if err != nil {
83- return fmt.Errorf("failed to open database: %w", err)
84- }
85- defer db.Close()
86-
87- // Create session manager
88- sessionMgr := session.NewManager(db)
89-
90- // Handle --list-sessions flag
91- if flags.ListSessions {
92- return listSessionsCmd(sessionMgr)
93- }
94-
95- // Handle --delete-session flag
96- if flags.DeleteSession != "" {
97- return deleteSessionCmd(sessionMgr, flags.DeleteSession)
98- }
99-
100- // Load credentials
101- creds, err := config.LoadCredentials()
102- if err != nil {
103- log.Warn().Err(err).Msg("Failed to load credentials, using empty credentials")
104- creds = &config.Credentials{}
105- }
106-
107- // Initialize provider registry
108- registry := initializeProviders(cfg, creds)
109-
110- // Determine provider and model
111- providerResult, err := sessionMgr.SelectProvider(cfg, flags.SessionName, flags.ProviderName)
112- if err != nil {
113- return err
114- }
115- selectedProvider := providerResult.Provider
116- selectedModel := providerResult.Model
117-
118- // Verify provider exists in config
119- providerCfg, ok := cfg.Providers[selectedProvider]
120- if !ok {
121- return fmt.Errorf("provider '%s' not found in config", selectedProvider)
122- }
123-
124- // Create provider instance
125- prov, err := registry.Create(selectedProvider, selectedModel, providerCfg.Temperature)
126- if err != nil {
127- return fmt.Errorf("failed to create provider: %w", err)
128- }
129- defer prov.Close()
130-
131- log.Info().
132- Str("provider", selectedProvider).
133- Str("model", selectedModel).
134- Msg("Provider initialized")
135-
136- // Initialize MCP client
137- ctx := context.Background()
138- mcpClient := mcp.NewClient(cfg.MCP.Upstream)
139- proxy := mcp.NewProxy(mcpClient)
140-
141- if err := proxy.Initialize(ctx); err != nil {
142- log.Warn().Err(err).Msg("Failed to initialize MCP - continuing without game tools")
143- } else {
144- log.Info().Str("upstream", cfg.MCP.Upstream).Msg("MCP proxy initialized")
145- }
146- defer proxy.Close()
147-
148- // Initialize or resume session
149- sessionResult, err := sessionMgr.Initialize(flags.SessionName, selectedProvider, selectedModel)
150- if err != nil {
151- return err
152- }
153- sessionID := sessionResult.SessionID
154- sessionInfo := sessionResult.SessionInfo
155-
156- // Register credential tools (session-scoped)
157- proxy.RegisterTool(
158- mcp.NewSaveCredentialsTool(),
159- mcp.MakeSaveCredentialsHandler(db, sessionID),
160- )
161- proxy.RegisterTool(
162- mcp.NewGetCredentialsTool(),
163- mcp.MakeGetCredentialsHandler(db, sessionID),
164- )
165- log.Debug().
166- Str("session_id", sessionID).
167- Int("local_tools", proxy.LocalToolCount()).
168- Msg("Registered local credential tools")
169-
170- // Get available tools (includes upstream + local credential tools)
171- tools, err := proxy.ListTools(ctx)
172- if err != nil {
173- log.Warn().Err(err).Msg("Failed to list tools - continuing without tools")
174- tools = []mcp.Tool{}
175- } else {
176- log.Info().Int("count", len(tools)).Msg("Tools available")
177- }
178-
179- // Load message history
180- history, err := sessionMgr.LoadHistory(sessionID)
181- if err != nil {
182- return err
183- }
184-
185- // Load system prompt from markdown file if provided
186- if flags.SystemFile != "" {
187- systemPrompt, err := loadSystemPromptFromFile(flags.SystemFile)
188- if err != nil {
189- return err
190- }
191- if !historyHasSystemPrompt(history, systemPrompt) {
192- history = prependSystemPrompt(history, systemPrompt)
193- }
194- }
195-
196- // Check if TUI mode requested
197- if flags.TUI {
198- // Use TUI mode
199- return runTUI(ctx, sessionMgr, sessionID, prov, proxy, tools, history)
200- }
33+// printWelcome displays the welcome banner.
34+func printWelcome(provider, model string, toolCount int, sessionInfo string) {
35+ fmt.Println(styles.Brand.Render("╔══════════════════════════════════════╗"))
36+ fmt.Println(styles.Brand.Render("║") + " " + styles.BrandBold.Render("Mysis") + " - SpaceMolt Agent CLI " + styles.Brand.Render("║"))
37+ fmt.Println(styles.Brand.Render("╚══════════════════════════════════════╝"))
38+ fmt.Println()
39+ fmt.Println(styles.Muted.Render(fmt.Sprintf("Provider: %s (%s)", provider, model)))
40+ fmt.Println(styles.Muted.Render(fmt.Sprintf("Tools: %d available", toolCount)))
41+ fmt.Println(styles.Muted.Render(sessionInfo))
42+ fmt.Println()
43+}
20144
202- // Print welcome message (CLI mode only)
45+// Start initializes and starts the CLI application (without orchestration).
46+// This is the main entry point for CLI mode after all initialization is done.
47+func Start(
48+ ctx context.Context,
49+ sessionMgr *session.Manager,
50+ sessionID string,
51+ sessionInfo string,
52+ prov provider.Provider,
53+ proxy *mcp.Proxy,
54+ tools []mcp.Tool,
55+ history []provider.Message,
56+ autoplayMsg string,
57+ selectedProvider string,
58+ selectedModel string,
59+) error {
60+ // Nil checks for required dependencies
61+ if prov == nil {
62+ return fmt.Errorf("provider cannot be nil")
63+ }
64+ if proxy == nil {
65+ return fmt.Errorf("MCP proxy cannot be nil")
66+ }
67+ if sessionMgr == nil {
68+ return fmt.Errorf("session manager cannot be nil")
69+ }
70+
71+ // Input validation
72+ if sessionID == "" {
73+ return fmt.Errorf("sessionID cannot be empty")
74+ }
75+ if sessionInfo == "" {
76+ return fmt.Errorf("sessionInfo cannot be empty")
77+ }
78+
79+ // Print welcome message
20380 printWelcome(selectedProvider, selectedModel, len(tools), sessionInfo)
20481
205- // Start conversation loop (CLI mode)
82+ // Start conversation loop
20683 app := &App{
20784 provider: prov,
20885 proxy: proxy,
@@ -212,9 +89,12 @@ func Run(version string) error {
21289 sessionID: sessionID,
21390 }
21491
215- // Start autoplay if flag provided
216- if flags.Autoplay != "" {
217- if err := app.startAutoplayFromFlag(ctx, flags.Autoplay); err != nil {
92+ // Initialize autoplay service
93+ app.initAutoplayService()
94+
95+ // Start autoplay if requested
96+ if autoplayMsg != "" {
97+ if err := app.startAutoplayFromFlag(ctx, autoplayMsg); err != nil {
21898 return fmt.Errorf("failed to start autoplay: %w", err)
21999 }
220100 }
@@ -222,18 +102,6 @@ func Run(version string) error {
222102 return app.runLoop(ctx)
223103 }
224104
225-// printWelcome displays the welcome banner.
226-func printWelcome(provider, model string, toolCount int, sessionInfo string) {
227- fmt.Println(styles.Brand.Render("╔══════════════════════════════════════╗"))
228- fmt.Println(styles.Brand.Render("║") + " " + styles.BrandBold.Render("Mysis") + " - SpaceMolt Agent CLI " + styles.Brand.Render("║"))
229- fmt.Println(styles.Brand.Render("╚══════════════════════════════════════╝"))
230- fmt.Println()
231- fmt.Println(styles.Muted.Render(fmt.Sprintf("Provider: %s (%s)", provider, model)))
232- fmt.Println(styles.Muted.Render(fmt.Sprintf("Tools: %d available", toolCount)))
233- fmt.Println(styles.Muted.Render(sessionInfo))
234- fmt.Println()
235-}
236-
237105 // runLoop runs the main conversation loop.
238106 func (app *App) runLoop(ctx context.Context) error {
239107 scanner := bufio.NewScanner(os.Stdin)
@@ -322,7 +190,8 @@ func (app *App) addMessage(msg provider.Message) {
322190 }
323191
324192 // listSessionsCmd lists recent sessions.
325-func listSessionsCmd(mgr *session.Manager) error {
193+// ListSessionsCmd lists all recent sessions.
194+func ListSessionsCmd(mgr *session.Manager) error {
326195 sessions, err := mgr.List(20)
327196 if err != nil {
328197 return err
@@ -356,7 +225,8 @@ func listSessionsCmd(mgr *session.Manager) error {
356225 }
357226
358227 // deleteSessionCmd deletes a session by name.
359-func deleteSessionCmd(mgr *session.Manager, name string) error {
228+// DeleteSessionCmd deletes a session by name.
229+func DeleteSessionCmd(mgr *session.Manager, name string) error {
360230 // Get session to show info before deletion
361231 sess, err := mgr.GetByName(name)
362232 if err != nil {
@@ -390,124 +260,3 @@ func deleteSessionCmd(mgr *session.Manager, name string) error {
390260 }
391261
392262 // initializeProviders creates and registers all configured providers
393-func initializeProviders(cfg *config.Config, creds *config.Credentials) *provider.Registry {
394- registry := provider.NewRegistry()
395-
396- for name, provCfg := range cfg.Providers {
397- // Detect provider type based on endpoint
398- if strings.Contains(provCfg.Endpoint, "localhost:11434") || strings.Contains(provCfg.Endpoint, "/ollama") {
399- // Ollama provider
400- factory := provider.NewOllamaFactory(name, provCfg.Endpoint)
401- registry.RegisterFactory(name, factory)
402- log.Debug().Str("name", name).Str("endpoint", provCfg.Endpoint).Msg("Registered Ollama provider")
403- } else if strings.Contains(provCfg.Endpoint, "opencode.ai") {
404- // OpenCode Zen provider
405- keyName := provCfg.APIKeyName
406- if keyName == "" {
407- keyName = name
408- }
409- apiKey := creds.GetAPIKey(keyName)
410- if apiKey == "" {
411- log.Warn().Str("name", name).Str("key_name", keyName).Msg("No API key found for provider")
412- continue
413- }
414- factory := provider.NewOpenCodeFactory(name, provCfg.Endpoint, apiKey)
415- registry.RegisterFactory(name, factory)
416- log.Debug().Str("name", name).Str("endpoint", provCfg.Endpoint).Msg("Registered OpenCode provider")
417- } else {
418- log.Warn().Str("name", name).Str("endpoint", provCfg.Endpoint).Msg("Unknown provider type")
419- }
420- }
421-
422- return registry
423-}
424-
425-func loadSystemPromptFromFile(path string) (string, error) {
426- ext := strings.ToLower(filepath.Ext(path))
427- if ext != ".md" && ext != ".markdown" {
428- return "", fmt.Errorf("system prompt file must be markdown (.md or .markdown): %s", path)
429- }
430-
431- data, err := os.ReadFile(path)
432- if err != nil {
433- return "", fmt.Errorf("read system prompt file: %w", err)
434- }
435-
436- content := strings.TrimSpace(string(data))
437- if content == "" {
438- return "", fmt.Errorf("system prompt file is empty: %s", path)
439- }
440-
441- return content, nil
442-}
443-
444-func historyHasSystemPrompt(history []provider.Message, content string) bool {
445- for _, msg := range history {
446- if msg.Role == "system" && msg.Content == content {
447- return true
448- }
449- }
450- return false
451-}
452-
453-func prependSystemPrompt(history []provider.Message, content string) []provider.Message {
454- systemMsg := provider.Message{Role: "system", Content: content}
455- return append([]provider.Message{systemMsg}, history...)
456-}
457-
458-// setupFileLogging configures zerolog to write to a file in the config directory.
459-func setupFileLogging(debug bool) error {
460- // Get data directory
461- dataDir, err := config.DataDir()
462- if err != nil {
463- return fmt.Errorf("get data directory: %w", err)
464- }
465-
466- // Create logs directory
467- logDir := filepath.Join(dataDir, "logs")
468- if err := os.MkdirAll(logDir, 0755); err != nil {
469- return fmt.Errorf("create logs directory: %w", err)
470- }
471-
472- // Create log file with timestamp
473- logFile := filepath.Join(logDir, "mysis.log")
474- file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
475- if err != nil {
476- return fmt.Errorf("open log file: %w", err)
477- }
478-
479- // Set up multi-writer: file (JSON) + console writer for debugging
480- var writers []io.Writer
481-
482- // Always write JSON to file
483- writers = append(writers, file)
484-
485- // In debug mode, also write human-readable logs to a separate debug file
486- if debug {
487- debugFile := filepath.Join(logDir, "mysis-debug.log")
488- debugFileWriter, err := os.OpenFile(debugFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
489- if err != nil {
490- return fmt.Errorf("open debug log file: %w", err)
491- }
492- consoleWriter := zerolog.ConsoleWriter{Out: debugFileWriter, TimeFormat: time.RFC3339}
493- writers = append(writers, consoleWriter)
494- }
495-
496- // Configure logger
497- multi := io.MultiWriter(writers...)
498- log.Logger = zerolog.New(multi).With().Timestamp().Logger()
499-
500- // Set log level
501- if debug {
502- zerolog.SetGlobalLevel(zerolog.DebugLevel)
503- } else {
504- zerolog.SetGlobalLevel(zerolog.InfoLevel)
505- }
506-
507- log.Info().
508- Str("log_file", logFile).
509- Bool("debug", debug).
510- Msg("File logging initialized for TUI mode")
511-
512- return nil
513-}