feat: add Cobra CLI, LSP/MCP registries, workflow engine, and enriched dashboard

Major changes:
- Refactor CLI entry point to Cobra commands (root, setup, scan, doctor, install, update, lsp, mcp, skills, config, version)
- Add LSP registry with health checks, auto-install, and editor config generation
- Add MCP registry with editor detection, status tracking, and per-editor configuration
- Add workflow engine with planner and step execution for automated task chains
- Add conversation search, export (Markdown/JSON), and detailed token counting
- Add streaming shell chat handler with tool call/result events
- Add skill validation, dry-run testing, and export endpoints
- Enrich dashboard with Tools/Activity/Status tabs and tool cards grid
- Add PRD documentation
- Complete i18n for both EN and FR

💘 Generated with Crush

Assisted-by: GLM-5.1 via Crush <crush@charm.land>
This commit is contained in:
Augustin
2026-04-22 22:22:05 +02:00
parent 61da8039bc
commit 485e085bb0
42 changed files with 6779 additions and 319 deletions

View File

@@ -1,9 +1,13 @@
package lsp
import (
"encoding/json"
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
)
type LSPServer struct {
@@ -12,6 +16,10 @@ type LSPServer struct {
Command string `json:"command"`
InstallCmd string `json:"install_cmd"`
Installed bool `json:"installed"`
Version string `json:"version,omitempty"`
Healthy bool `json:"healthy,omitempty"`
Description string `json:"description,omitempty"`
Category string `json:"category,omitempty"`
}
var knownServers = []LSPServer{
@@ -39,27 +47,131 @@ func ScanServers() []LSPServer {
servers[i] = s
_, err := exec.LookPath(s.Command)
servers[i].Installed = err == nil
servers[i].Version = getInstalledLSPVersion(s.Name)
}
regServers, err := scanLSPRegistryServers()
if err == nil {
servers = append(servers, regServers...)
}
return servers
}
func scanLSPRegistryServers() ([]LSPServer, error) {
reg, err := LoadLSPRegistry()
if err != nil {
return nil, err
}
knownNames := map[string]bool{}
for _, s := range knownServers {
knownNames[s.Name] = true
}
var servers []LSPServer
for _, rs := range reg.Servers {
if knownNames[rs.Name] {
continue
}
servers = append(servers, LSPServer{
Name: rs.Name,
Language: rs.Language,
Command: rs.Command,
InstallCmd: rs.InstallCmd,
Installed: isLSPCommandAvailable(rs.Command),
Description: rs.Description,
Category: rs.Category,
Version: getInstalledLSPVersion(rs.Name),
})
}
return servers, nil
}
func isLSPCommandAvailable(cmd string) bool {
_, err := exec.LookPath(cmd)
return err == nil
}
func getInstalledLSPVersion(name string) string {
home, _ := os.UserHomeDir()
if home == "" {
return ""
}
receiptPath := filepath.Join(home, ".muyue", "receipts", "lsp", name+".json")
data, err := os.ReadFile(receiptPath)
if err != nil {
return ""
}
var receipt struct {
Version string `json:"version"`
}
if json.Unmarshal(data, &receipt) == nil {
return receipt.Version
}
return ""
}
func saveLSPReceipt(name, version string) error {
home, _ := os.UserHomeDir()
if home == "" {
return nil
}
receiptDir := filepath.Join(home, ".muyue", "receipts", "lsp")
os.MkdirAll(receiptDir, 0755)
receipt := struct {
Name string `json:"name"`
Version string `json:"version"`
UpdatedAt string `json:"updated_at"`
}{
Name: name,
Version: version,
UpdatedAt: time.Now().Format(time.RFC3339),
}
data, _ := json.MarshalIndent(receipt, "", " ")
return os.WriteFile(filepath.Join(receiptDir, name+".json"), data, 0644)
}
func InstallServer(name string) error {
for _, s := range knownServers {
if s.Name == name {
if s.InstallCmd == "" {
return fmt.Errorf("%s has no auto-install command, install manually", name)
}
cmd := exec.Command("bash", "-c", s.InstallCmd)
cmd.Env = os.Environ()
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("install %s: %s: %w", name, string(output), err)
}
return nil
return doInstallLSP(s)
}
}
reg, err := LoadLSPRegistry()
if err == nil {
for _, s := range reg.Servers {
if s.Name == name {
return doInstallLSP(LSPServer{
Name: s.Name,
Language: s.Language,
Command: s.Command,
InstallCmd: s.InstallCmd,
})
}
}
}
return fmt.Errorf("unknown LSP server: %s", name)
}
func doInstallLSP(s LSPServer) error {
if s.InstallCmd == "" {
return fmt.Errorf("%s has no auto-install command, install manually", s.Name)
}
cmd := exec.Command("bash", "-c", s.InstallCmd)
cmd.Env = os.Environ()
if output, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("install %s: %s: %w", s.Name, string(output), err)
}
saveLSPReceipt(s.Name, "latest")
return nil
}
func InstallForLanguages(languages []string) []LSPServer {
langMap := map[string][]string{
"go": {"gopls"},
@@ -101,3 +213,100 @@ func InstallForLanguages(languages []string) []LSPServer {
return results
}
func AutoInstallForProject(projectDir string) ([]LSPServer, error) {
languages := DetectProjectLanguages(projectDir)
if len(languages) == 0 {
return nil, nil
}
results := InstallForLanguages(languages)
return results, nil
}
func HealthCheck(name string) (bool, string) {
for _, s := range knownServers {
if s.Name == name {
return healthCheckServer(s)
}
}
return false, "unknown server"
}
func healthCheckServer(s LSPServer) (bool, string) {
path, err := exec.LookPath(s.Command)
if err != nil {
return false, fmt.Sprintf("command %q not found in PATH", s.Command)
}
versionArgs := map[string][]string{
"gopls": {"version"},
"pyright": {"--version"},
"typescript-language-server": {"--version"},
"rust-analyzer": {"--version"},
"clangd": {"--version"},
"lua-language-server": {"--version"},
"bash-language-server": {"--version"},
"yaml-language-server": {"--version"},
}
if args, ok := versionArgs[s.Command]; ok {
cmd := exec.Command(path, args...)
output, err := cmd.CombinedOutput()
if err != nil {
return true, fmt.Sprintf("installed at %s but version check failed", path)
}
version := strings.TrimSpace(string(output))
if idx := strings.Index(version, "\n"); idx > 0 {
version = version[:idx]
}
saveLSPReceipt(s.Name, version)
return true, version
}
return true, fmt.Sprintf("installed at %s", path)
}
func GenerateEditorConfigs(servers []LSPServer, editor string, homeDir string) (string, error) {
if homeDir == "" {
home, _ := os.UserHomeDir()
homeDir = home
}
reg, err := LoadLSPRegistry()
if err != nil {
return "", err
}
regMap := map[string]RegistryEntry{}
for _, s := range reg.Servers {
regMap[s.Name] = s
}
var regEntries []RegistryEntry
for _, s := range servers {
if re, ok := regMap[s.Name]; ok {
regEntries = append(regEntries, re)
}
}
switch editor {
case "neovim", "nvim":
return GenerateNeovimConfig(regEntries), nil
case "helix", "hx":
return GenerateHelixConfig(regEntries), nil
case "vscode", "code", "cursor":
exts := GenerateVSCodeRecommendations(regEntries)
var b strings.Builder
b.WriteString("{\n \"recommendations\": [\n")
for i, ext := range exts {
if i > 0 {
b.WriteString(",\n")
}
b.WriteString(" \"" + ext + "\"")
}
b.WriteString("\n ]\n}")
return b.String(), nil
default:
return "", fmt.Errorf("unsupported editor: %s", editor)
}
}