load mixin files and index them asynchronously

Author: kindermax

docs/docs/changelog.md

@@ -19,6 +19,7 @@ title: Changelog
 * `[Added]` Show background update notifications for interactive sessions, with Homebrew-aware guidance and `LETS_CHECK_UPDATE` opt-out.
 * `[Changed]` Centralize the `lets:` log prefix in the formatter and render debug messages in blue.
 * `[Fixed]` Resolve `go to definition` from YAML merge aliases such as `<<: *test` to the referenced command in `lets self lsp`.
+* `[Added]` Load local mixin files into LSP storage and command index so mixin commands are available for navigation.
 
 ## [0.0.59](https://github.com/lets-cli/lets/releases/tag/v0.0.59)
 

internal/executor/dependency_error.go

@@ -44,6 +44,7 @@ func (e *DependencyError) FailureMessage() string {
 
 func (e *DependencyError) TreeMessage() string {
 	red := color.New(color.FgRed).SprintFunc()
+
 	var builder strings.Builder
 
 	builder.WriteString(dependencyTreeHeader)

internal/lsp/handlers.go

@@ -2,7 +2,9 @@ package lsp
 
 import (
 	"errors"
+	"os"
 	"slices"
+	"strings"
 
 	"github.com/lets-cli/lets/internal/util"
 	"github.com/tliron/commonlog"
@@ -42,9 +44,43 @@ func (s *lspServer) setTrace(context *glsp.Context, params *lsp.SetTraceParams)
 	return nil
 }
 
+// loadMixins reads local mixin files referenced by a document and adds them to storage and index.
+func (s *lspServer) loadMixins(uri string) {
+	doc := s.storage.GetDocument(uri)
+	if doc == nil {
+		return
+	}
+
+	parser := newParser(s.log)
+	path := normalizePath(uri)
+
+	for _, filename := range parser.getMixinFilenames(doc) {
+		mixinPath := replacePathFilename(path, strings.TrimPrefix(filename, "-"))
+		if !util.FileExists(mixinPath) {
+			s.log.Debugf("mixin target does not exist: %s", mixinPath)
+			continue
+		}
+
+		data, err := os.ReadFile(mixinPath)
+		if err != nil {
+			s.log.Warningf("failed to read mixin %s: %v", mixinPath, err)
+			continue
+		}
+
+		mixinURI := pathToURI(mixinPath)
+		text := string(data)
+
+		s.storage.AddDocument(mixinURI, text)
+		s.index.IndexDocument(mixinURI, text)
+	}
+}
+
 func (s *lspServer) textDocumentDidOpen(context *glsp.Context, params *lsp.DidOpenTextDocumentParams) error {
 	s.storage.AddDocument(params.TextDocument.URI, params.TextDocument.Text)
+
 	go s.index.IndexDocument(params.TextDocument.URI, params.TextDocument.Text)
+	go s.loadMixins(params.TextDocument.URI)
+
 	return nil
 }
 
@@ -53,7 +89,9 @@ func (s *lspServer) textDocumentDidChange(context *glsp.Context, params *lsp.Did
 		switch c := change.(type) {
 		case lsp.TextDocumentContentChangeEventWhole:
 			s.storage.AddDocument(params.TextDocument.URI, c.Text)
+
 			go s.index.IndexDocument(params.TextDocument.URI, c.Text)
+			go s.loadMixins(params.TextDocument.URI)
 		case lsp.TextDocumentContentChangeEvent:
 			return errors.New("incremental changes not supported")
 		}
@@ -134,6 +172,7 @@ func (h *definitionHandler) findCommandDefinition(doc *string, params *lsp.Defin
 	)
 
 	loc := locationForCommand(commandInfo.fileURI, commandInfo.position)
+
 	return []lsp.Location{loc}, nil
 }
 

internal/lsp/handlers_test.go

@@ -0,0 +1,108 @@
+package lsp
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestLoadMixinsStoresAndIndexesMixinDocuments(t *testing.T) {
+	dir := t.TempDir()
+
+	mainPath := filepath.Join(dir, "lets.yaml")
+	baseMixinPath := filepath.Join(dir, "lets.base.yaml")
+	localMixinPath := filepath.Join(dir, "lets.local.yaml")
+
+	baseMixinDoc := `commands:
+  build:
+    cmd: echo build`
+
+	localMixinDoc := `commands:
+  test:
+    cmd: echo test`
+
+	if err := os.WriteFile(baseMixinPath, []byte(baseMixinDoc), 0o644); err != nil {
+		t.Fatalf("WriteFile(%s) error = %v", baseMixinPath, err)
+	}
+
+	if err := os.WriteFile(localMixinPath, []byte(localMixinDoc), 0o644); err != nil {
+		t.Fatalf("WriteFile(%s) error = %v", localMixinPath, err)
+	}
+
+	mainDoc := `mixins:
+  - lets.base.yaml
+  - -lets.local.yaml
+commands:
+  release:
+    depends: [build, test]
+    cmd: echo release`
+
+	server := &lspServer{
+		storage: newStorage(),
+		index:   newIndex(logger),
+		log:     logger,
+	}
+
+	mainURI := pathToURI(mainPath)
+	server.storage.AddDocument(mainURI, mainDoc)
+	server.loadMixins(mainURI)
+
+	baseMixinURI := pathToURI(baseMixinPath)
+	localMixinURI := pathToURI(localMixinPath)
+
+	if got := server.storage.GetDocument(baseMixinURI); got == nil || *got != baseMixinDoc {
+		t.Fatalf("storage for %s = %#v, want %q", baseMixinURI, got, baseMixinDoc)
+	}
+
+	if got := server.storage.GetDocument(localMixinURI); got == nil || *got != localMixinDoc {
+		t.Fatalf("storage for %s = %#v, want %q", localMixinURI, got, localMixinDoc)
+	}
+
+	buildInfo, ok := server.index.findCommand("build")
+	if !ok {
+		t.Fatal("expected build command from mixin to be indexed")
+	}
+
+	if buildInfo.fileURI != baseMixinURI {
+		t.Fatalf("build indexed at %s, want %s", buildInfo.fileURI, baseMixinURI)
+	}
+
+	testInfo, ok := server.index.findCommand("test")
+	if !ok {
+		t.Fatal("expected test command from mixin to be indexed")
+	}
+
+	if testInfo.fileURI != localMixinURI {
+		t.Fatalf("test indexed at %s, want %s", testInfo.fileURI, localMixinURI)
+	}
+}
+
+func TestLoadMixinsSkipsMissingFiles(t *testing.T) {
+	dir := t.TempDir()
+
+	mainPath := filepath.Join(dir, "lets.yaml")
+	mainURI := pathToURI(mainPath)
+
+	mainDoc := `mixins:
+  - missing.yaml
+commands:
+  release:
+    cmd: echo release`
+
+	server := &lspServer{
+		storage: newStorage(),
+		index:   newIndex(logger),
+		log:     logger,
+	}
+
+	server.storage.AddDocument(mainURI, mainDoc)
+	server.loadMixins(mainURI)
+
+	if got := server.storage.GetDocument(pathToURI(filepath.Join(dir, "missing.yaml"))); got != nil {
+		t.Fatalf("expected missing mixin to not be stored, got %#v", got)
+	}
+
+	if _, ok := server.index.findCommand("missing"); ok {
+		t.Fatal("expected no indexed command for missing mixin")
+	}
+}

internal/lsp/index.go

@@ -1,8 +1,10 @@
 package lsp
 
 import (
+	"maps"
 	"sync"
 
+	"github.com/lets-cli/lets/internal/set"
 	"github.com/tliron/commonlog"
 	lsp "github.com/tliron/glsp/protocol_3_16"
 )
@@ -18,14 +20,14 @@ type index struct {
 	log           commonlog.Logger
 	mu            sync.RWMutex
 	commands      map[string]commandInfo
-	commandsByURI map[string]map[string]struct{}
+	commandsByURI map[string]set.Set[string]
 }
 
 func newIndex(log commonlog.Logger) *index {
 	return &index{
 		log:           log,
 		commands:      make(map[string]commandInfo),
-		commandsByURI: make(map[string]map[string]struct{}),
+		commandsByURI: make(map[string]set.Set[string]),
 	}
 }
 
@@ -35,15 +37,14 @@ func (i *index) IndexDocument(uri string, doc string) {
 	commands := parser.getCommands(&doc)
 
 	indexedCommands := make(map[string]commandInfo, len(commands))
-	indexedNames := make(map[string]struct{}, len(commands))
+	indexedNames := set.NewSet[string]()
 
 	for _, command := range commands {
 		indexedCommands[command.name] = commandInfo{
 			fileURI:  uri,
 			position: command.position,
 		}
-		// TODOL maybe use Set
-		indexedNames[command.name] = struct{}{}
+		indexedNames.Add(command.name)
 	}
 
 	i.mu.Lock()
@@ -55,9 +56,7 @@ func (i *index) IndexDocument(uri string, doc string) {
 		delete(i.commands, name)
 	}
 
-	for name, info := range indexedCommands {
-		i.commands[name] = info
-	}
+	maps.Copy(i.commands, indexedCommands)
 
 	if len(indexedNames) == 0 {
 		delete(i.commandsByURI, uri)
@@ -72,5 +71,6 @@ func (i *index) findCommand(name string) (commandInfo, bool) {
 	defer i.mu.RUnlock()
 
 	command, ok := i.commands[name]
+
 	return command, ok
 }

internal/lsp/storage.go

@@ -1,6 +1,9 @@
 package lsp
 
+import "sync"
+
 type storage struct {
+	mu        sync.RWMutex
 	documents map[string]*string
 }
 
@@ -11,9 +14,15 @@ func newStorage() *storage {
 }
 
 func (s *storage) GetDocument(uri string) *string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
 	return s.documents[uri]
 }
 
 func (s *storage) AddDocument(uri string, text string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
 	s.documents[uri] = &text
 }

internal/lsp/treesitter.go

@@ -295,6 +295,31 @@ func (p *parser) extractFilenameFromMixins(document *string, position lsp.Positi
 	return ""
 }
 
+func (p *parser) getMixinFilenames(document *string) []string {
+	var filenames []string
+
+	executeYAMLQuery(document, `
+		(block_mapping_pair
+			key: (flow_node) @key
+			value: (block_node
+				(block_sequence
+					(block_sequence_item
+						(flow_node
+							(plain_scalar
+								(string_scalar)) @value))))
+			(#eq? @key "mixins")
+		)
+	`, func(capture ts.QueryCapture, docBytes []byte) bool {
+		if capture.Name == "value" {
+			filenames = append(filenames, capture.Node.Text(docBytes))
+		}
+
+		return false
+	})
+
+	return filenames
+}
+
 func (p *parser) extractCommandReference(document *string, position lsp.Position) string {
 	if commandName := p.extractDependsCommandReference(document, position); commandName != "" {
 		p.log.Debugf("resolved command reference from depends: %q", commandName)
@@ -550,7 +575,7 @@ func (p *parser) getCurrentCommand(document *string, position lsp.Position) *Com
 	return nil
 }
 
-func (p *parser) findCommand(document *string, commandName string) *Command {
+func (p *parser) findCommand(document *string, commandName string) *Command { //nolint
 	tree, docBytes, err := parseYAMLDocument(document)
 	if err != nil {
 		return nil

internal/lsp/treesitter_test.go

@@ -414,7 +414,14 @@ func TestFindCommandDefinitionFromAlias(t *testing.T) {
     <<: *docs
     cmd: npm start`
 
-	handler := definitionHandler{parser: newParser(logger)}
+	idx := newIndex(logger)
+	idx.IndexDocument("file:///tmp/lets.yaml", doc)
+
+	handler := definitionHandler{
+		log:    logger,
+		parser: newParser(logger),
+		index:  idx,
+	}
 	params := &lsp.DefinitionParams{
 		TextDocumentPositionParams: lsp.TextDocumentPositionParams{
 			TextDocument: lsp.TextDocumentIdentifier{URI: "file:///tmp/lets.yaml"},
@@ -540,6 +547,24 @@ commands:
 	}
 }
 
+func TestGetMixinFilenames(t *testing.T) {
+	doc := `shell: bash
+mixins:
+  - lets.base.yaml
+  - -lets.local.yaml
+commands:
+  build:
+    cmd: echo build`
+
+	p := newParser(logger)
+	got := p.getMixinFilenames(&doc)
+	want := []string{"lets.base.yaml", "-lets.local.yaml"}
+
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("getMixinFilenames() = %#v, want %#v", got, want)
+	}
+}
+
 func TestDependsHelpersWithBlockAndFlowSequences(t *testing.T) {
 	doc := `shell: bash
 commands: