MuyueWorkspace/internal/api/handlers.go

package api

import (
	"encoding/json"
	"net/http"
	"os/exec"

	"github.com/muyue/muyue/internal/config"
	"github.com/muyue/muyue/internal/lsp"
	"github.com/muyue/muyue/internal/mcp"
	"github.com/muyue/muyue/internal/orchestrator"
	"github.com/muyue/muyue/internal/scanner"
	"github.com/muyue/muyue/internal/skills"
	"github.com/muyue/muyue/internal/updater"
	"github.com/muyue/muyue/internal/version"
)

const summarizePrompt = `Résume la conversation suivante de manière concise et structurée. Garde les points clés, les décisions prises, le contexte technique important. Le résumé doit permettre de continuer la conversation sans perte de contexte. Réponds uniquement avec le résumé, sans meta-commentaire.`

func writeJSON(w http.ResponseWriter, data interface{}) {
	json.NewEncoder(w).Encode(data)
}

func writeError(w http.ResponseWriter, msg string, code int) {
	w.WriteHeader(code)
	json.NewEncoder(w).Encode(map[string]string{"error": msg})
}

func (s *Server) handleInfo(w http.ResponseWriter, r *http.Request) {
	writeJSON(w, map[string]interface{}{
		"name":    version.Name,
		"version": version.Version,
		"author":  version.Author,
	})
}

func (s *Server) handleSystem(w http.ResponseWriter, r *http.Request) {
	if s.scanResult == nil {
		s.scanResult = scanner.ScanSystem()
	}
	writeJSON(w, map[string]interface{}{
		"system": s.scanResult.System,
	})
}

func (s *Server) handleTools(w http.ResponseWriter, r *http.Request) {
	if s.scanResult == nil {
		s.scanResult = scanner.ScanSystem()
	}
	type toolInfo struct {
		Name      string `json:"name"`
		Installed bool   `json:"installed"`
		Version   string `json:"version"`
		Path      string `json:"path"`
	}
	tools := make([]toolInfo, len(s.scanResult.Tools))
	for i, t := range s.scanResult.Tools {
		tools[i] = toolInfo{
			Name:      t.Name,
			Installed: t.Installed,
			Version:   t.Version,
			Path:      t.Path,
		}
	}
	writeJSON(w, map[string]interface{}{
		"tools": tools,
		"total": len(tools),
	})
}

func (s *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
	if s.config == nil {
		writeError(w, "no config", http.StatusNotFound)
		return
	}
	writeJSON(w, map[string]interface{}{
		"profile":  s.config.Profile,
		"terminal": s.config.Terminal,
		"bmad":     s.config.BMAD,
	})
}

func (s *Server) handleProviders(w http.ResponseWriter, r *http.Request) {
	if s.config == nil {
		writeError(w, "no config", http.StatusNotFound)
		return
	}
	writeJSON(w, map[string]interface{}{
		"providers": s.config.AI.Providers,
	})
}

func (s *Server) handleSkills(w http.ResponseWriter, r *http.Request) {
	list, err := skills.List()
	if err != nil {
		writeError(w, err.Error(), http.StatusInternalServerError)
		return
	}
	writeJSON(w, map[string]interface{}{
		"skills": list,
		"count":  len(list),
	})
}

func (s *Server) handleLSP(w http.ResponseWriter, r *http.Request) {
	servers := lsp.ScanServers()
	writeJSON(w, map[string]interface{}{
		"servers": servers,
	})
}

func (s *Server) handleMCP(w http.ResponseWriter, r *http.Request) {
	servers := mcp.ScanServers()
	writeJSON(w, map[string]interface{}{
		"servers":    servers,
		"configured": true,
	})
}

func (s *Server) handleMCPConfigure(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		writeError(w, "POST only", http.StatusMethodNotAllowed)
		return
	}
	if err := mcp.ConfigureAll(s.config); err != nil {
		writeError(w, err.Error(), http.StatusInternalServerError)
		return
	}
	writeJSON(w, map[string]string{"status": "ok"})
}

func (s *Server) handleUpdates(w http.ResponseWriter, r *http.Request) {
	result := scanner.ScanSystem()
	statuses := updater.CheckUpdates(result)
	type updateInfo struct {
		Tool        string `json:"tool"`
		Current     string `json:"current"`
		Latest      string `json:"latest"`
		NeedsUpdate bool   `json:"needsUpdate"`
		Error       string `json:"error,omitempty"`
	}
	updates := make([]updateInfo, len(statuses))
	for i, u := range statuses {
		updates[i] = updateInfo{
			Tool:        u.Tool,
			Current:     u.Current,
			Latest:      u.Latest,
			NeedsUpdate: u.NeedsUpdate,
			Error:       u.Error,
		}
	}
	writeJSON(w, map[string]interface{}{
		"updates": updates,
	})
}

func (s *Server) handleInstall(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		writeError(w, "POST only", http.StatusMethodNotAllowed)
		return
	}
	var body struct {
		Tools []string `json:"tools"`
	}
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		writeError(w, err.Error(), http.StatusBadRequest)
		return
	}
	if len(body.Tools) == 0 {
		writeError(w, "no tools specified", http.StatusBadRequest)
		return
	}
	writeJSON(w, map[string]string{"status": "installing"})
}

func (s *Server) handleScan(w http.ResponseWriter, r *http.Request) {
	s.scanResult = scanner.ScanSystem()
	writeJSON(w, map[string]string{"status": "ok"})
}

func (s *Server) handleUpdatePreferences(w http.ResponseWriter, r *http.Request) {
	if r.Method != "PUT" {
		writeError(w, "PUT only", http.StatusMethodNotAllowed)
		return
	}
	if s.config == nil {
		writeError(w, "no config", http.StatusNotFound)
		return
	}
	var body struct {
		Language       string `json:"language"`
		KeyboardLayout string `json:"keyboard_layout"`
	}
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		writeError(w, err.Error(), http.StatusBadRequest)
		return
	}
	if body.Language != "" {
		s.config.Profile.Preferences.Language = body.Language
	}
	if body.KeyboardLayout != "" {
		s.config.Profile.Preferences.KeyboardLayout = body.KeyboardLayout
	}
	if err := config.Save(s.config); err != nil {
		writeError(w, err.Error(), http.StatusInternalServerError)
		return
	}
	writeJSON(w, map[string]string{"status": "ok"})
}

func (s *Server) handleTerminal(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		writeError(w, "POST only", http.StatusMethodNotAllowed)
		return
	}
	var body struct {
		Command string `json:"command"`
		Cwd     string `json:"cwd"`
	}
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		writeError(w, err.Error(), http.StatusBadRequest)
		return
	}
	if body.Command == "" {
		writeError(w, "no command", http.StatusBadRequest)
		return
	}

	shell := "/bin/sh"
	if s, err := exec.LookPath("bash"); err == nil {
		shell = s
	}

	cmd := exec.Command(shell, "-c", body.Command)
	if body.Cwd != "" {
		cmd.Dir = body.Cwd
	}
	out, err := cmd.CombinedOutput()

	type termResult struct {
		Output string `json:"output"`
		Error  string `json:"error,omitempty"`
	}
	result := termResult{Output: string(out)}
	if err != nil {
		result.Error = err.Error()
	}
	writeJSON(w, result)
}

func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		writeError(w, "POST only", http.StatusMethodNotAllowed)
		return
	}
	var body struct {
		Message string `json:"message"`
		Stream  bool   `json:"stream"`
	}
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		writeError(w, err.Error(), http.StatusBadRequest)
		return
	}
	if body.Message == "" {
		writeError(w, "no message", http.StatusBadRequest)
		return
	}

	s.convStore.Add("user", body.Message)

	if s.convStore.NeedsSummarization() {
		s.autoSummarize()
	}

	orb, err := orchestrator.New(s.config)
	if err != nil {
		writeError(w, err.Error(), http.StatusServiceUnavailable)
		return
	}
	orb.SetSystemPrompt(`Tu es l'orchestrateur IA de Muyue Studio. Tu aides l'utilisateur dans ses tâches de développement logiciel. Tu peux :
- Créer et gérer des plans de développement étape par étape
- Proposer des agents (outils comme Crush, Claude Code, etc.) pour exécuter des tâches spécifiques
- Suivre la progression de tâches multi-étapes
- Suggérer des modifications de fichiers, des revues de code, et des décisions d'architecture

Sois concis, actionnable, et structuré. Quand tu proposes un plan, utilise des étapes numérotées claires. Quand tu références des fichiers, utilise des chemins relatifs. Tu es intégré dans l'application desktop Muyue.`)

	if body.Stream {
		w.Header().Set("Content-Type", "text/event-stream")
		w.Header().Set("Cache-Control", "no-cache")
		w.Header().Set("Connection", "keep-alive")
		w.Header().Set("Access-Control-Allow-Origin", "*")
		w.WriteHeader(http.StatusOK)
		flusher, canFlush := w.(http.Flusher)

		result, err := orb.Send(body.Message)
		if err != nil {
			data, _ := json.Marshal(map[string]string{"error": err.Error()})
			w.Write([]byte("data: " + string(data) + "\n\n"))
			if canFlush {
				flusher.Flush()
			}
			return
		}

		s.convStore.Add("assistant", result)

		chunkSize := 8
		runes := []rune(result)
		for i := 0; i < len(runes); i += chunkSize {
			end := i + chunkSize
			if end > len(runes) {
				end = len(runes)
			}
			chunk := string(runes[i:end])
			data, _ := json.Marshal(map[string]string{"content": chunk})
			w.Write([]byte("data: " + string(data) + "\n\n"))
			if canFlush {
				flusher.Flush()
			}
		}

		data, _ := json.Marshal(map[string]string{"done": "true"})
		w.Write([]byte("data: " + string(data) + "\n\n"))
		if canFlush {
			flusher.Flush()
		}
		return
	}

	result, err := orb.Send(body.Message)
	if err != nil {
		writeError(w, err.Error(), http.StatusInternalServerError)
		return
	}
	s.convStore.Add("assistant", result)
	writeJSON(w, map[string]string{"content": result})
}

func (s *Server) autoSummarize() {
	messages := s.convStore.Get()
	if len(messages) < 10 {
		return
	}

	half := len(messages) / 2
	var oldText string
	for _, m := range messages[:half] {
		oldText += m.Role + ": " + m.Content + "\n\n"
	}

	summary := s.convStore.GetSummary()
	if summary != "" {
		oldText = "Résumé précédent:\n" + summary + "\n\nNouveaux échanges:\n" + oldText
	}

	orb, err := orchestrator.New(s.config)
	if err != nil {
		return
	}
	orb.SetSystemPrompt(summarizePrompt)

	result, err := orb.Send(oldText)
	if err != nil {
		return
	}

	s.convStore.SetSummary(result)
	s.convStore.TrimOld(len(messages) - half)
	s.convStore.Add("system", "[Conversation résumée automatiquement]")
}

func (s *Server) handleChatHistory(w http.ResponseWriter, r *http.Request) {
	if r.Method != "GET" {
		writeError(w, "GET only", http.StatusMethodNotAllowed)
		return
	}
	messages := s.convStore.Get()
	writeJSON(w, map[string]interface{}{
		"messages": messages,
		"tokens":   s.convStore.ApproxTokenCount(),
	})
}

func (s *Server) handleChatClear(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		writeError(w, "POST only", http.StatusMethodNotAllowed)
		return
	}
	s.convStore.Clear()
	writeJSON(w, map[string]string{"status": "ok"})
}

func (s *Server) handleSaveProfile(w http.ResponseWriter, r *http.Request) {
	if r.Method != "PUT" {
		writeError(w, "PUT only", http.StatusMethodNotAllowed)
		return
	}
	if s.config == nil {
		writeError(w, "no config", http.StatusNotFound)
		return
	}
	var body struct {
		Name     string `json:"name"`
		Pseudo   string `json:"pseudo"`
		Email    string `json:"email"`
		Editor   string `json:"editor"`
		Shell    string `json:"shell"`
	}
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		writeError(w, err.Error(), http.StatusBadRequest)
		return
	}
	if body.Name != "" {
		s.config.Profile.Name = body.Name
	}
	if body.Pseudo != "" {
		s.config.Profile.Pseudo = body.Pseudo
	}
	if body.Email != "" {
		s.config.Profile.Email = body.Email
	}
	if body.Editor != "" {
		s.config.Profile.Preferences.Editor = body.Editor
	}
	if body.Shell != "" {
		s.config.Profile.Preferences.Shell = body.Shell
	}
	if err := config.Save(s.config); err != nil {
		writeError(w, err.Error(), http.StatusInternalServerError)
		return
	}
	writeJSON(w, map[string]string{"status": "ok"})
}

func (s *Server) handleSaveProvider(w http.ResponseWriter, r *http.Request) {
	if r.Method != "PUT" {
		writeError(w, "PUT only", http.StatusMethodNotAllowed)
		return
	}
	if s.config == nil {
		writeError(w, "no config", http.StatusNotFound)
		return
	}
	var body struct {
		Name    string `json:"name"`
		APIKey  string `json:"api_key"`
		Model   string `json:"model"`
		BaseURL string `json:"base_url"`
		Active  *bool  `json:"active"`
	}
	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
		writeError(w, err.Error(), http.StatusBadRequest)
		return
	}
	if body.Name == "" {
		writeError(w, "name required", http.StatusBadRequest)
		return
	}
	found := false
	for i := range s.config.AI.Providers {
		if s.config.AI.Providers[i].Name == body.Name {
			if body.APIKey != "" {
				s.config.AI.Providers[i].APIKey = body.APIKey
			}
			if body.Model != "" {
				s.config.AI.Providers[i].Model = body.Model
			}
			if body.BaseURL != "" {
				s.config.AI.Providers[i].BaseURL = body.BaseURL
			}
			if body.Active != nil {
				if *body.Active {
					for j := range s.config.AI.Providers {
						s.config.AI.Providers[j].Active = false
					}
				}
				s.config.AI.Providers[i].Active = *body.Active
			}
			found = true
			break
		}
	}
	if !found {
		writeError(w, "provider not found", http.StatusNotFound)
		return
	}
	if err := config.Save(s.config); err != nil {
		writeError(w, err.Error(), http.StatusInternalServerError)
		return
	}
	writeJSON(w, map[string]string{"status": "ok"})
}

func (s *Server) handleRunUpdate(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		writeError(w, "POST only", http.StatusMethodNotAllowed)
		return
	}
	var body struct {
		Tool string `json:"tool"`
	}
	json.NewDecoder(r.Body).Decode(&body)

	result := scanner.ScanSystem()
	statuses := updater.CheckUpdates(result)

	if body.Tool != "" {
		for _, u := range statuses {
			if u.Tool == body.Tool && u.NeedsUpdate {
				updater.RunAutoUpdate([]updater.UpdateStatus{u})
			}
		}
		writeJSON(w, map[string]string{"status": "ok", "tool": body.Tool})
		return
	}

	needsUpdate := make([]updater.UpdateStatus, 0)
	for _, u := range statuses {
		if u.NeedsUpdate {
			needsUpdate = append(needsUpdate, u)
		}
	}
	if len(needsUpdate) > 0 {
		updater.RunAutoUpdate(needsUpdate)
	}
	writeJSON(w, map[string]interface{}{
		"status":  "ok",
		"updated": len(needsUpdate),
	})
}