feat(make): support local formula path and improve test coverage (#104)

* feat(make): support local file patterns for llar make

Add support for local filesystem patterns (., ./path, ./path@ver) in
`llar make`, enabling CI workflows within the llarhub repository to build
local formulas while resolving dependencies from the remote store.

Key changes:
- Extract Store interface from concrete struct in repo package
- Add overlayStore to serve local modules with remote fallback
- Add modlocal package for local module discovery via versions.json
- Update parseModuleArg to detect and validate local patterns
- Split runMake into local/remote branches with overlay composition

* docs: add local formula build examples to README

Add documentation examples demonstrating how to build local formulas using `llar make` command with local paths. This clarifies the usage of the tool for building formulas from local directories.

* fix(overlay): implement LockModule with local lock file for local modules

* docs: clarify unsupported parent directory module patterns

Add documentation note explaining that `..` and `../path` patterns are not supported for local module imports. Users should use `.` instead, which automatically walks up from the current directory to find the nearest `versions.json` file, eliminating the need for manual parent directory navigation.

* test(make): add local libpng e2e fixtures and test

* test(make): switch local-remote e2e to cjson with remote zlib

* test(make): switch mixed-source e2e to local demo repo + remote zlib

* test(make): log captured llar output in mixed-source e2e

* test(make): clarify in-process stdout capture rationale

* test(make): expand parseModuleArg path edge cases

* fix(make): disable local ./... pattern for now

* fix(repo): unify overlay locking by module path

* fix(make): enforce local pattern validity rules

* refactor(modlocal): move pattern validation into Resolve

* test(modlocal): expand local pattern edge-case coverage

* modules: validate remote module paths in load pipeline

* feat(make): align local patterns with Go-style paths

Author: MeteorsLiu

README.md

@@ -33,6 +33,10 @@ llar make -o ./output madler/zlib@v1.3.1
 
 # Build and export as a zip archive
 llar make -o zlib.zip madler/zlib@v1.3.1
+
+# Build a local formula
+llar make ./@1.0.0
+llar make ./madler/zlib@v1.3.1
 ```
 
 ### Commands

cmd/llar/internal/make.go

@@ -4,6 +4,7 @@ import (
 	"archive/zip"
 	"context"
 	"fmt"
+	stdbuild "go/build"
 	"io"
 	"os"
 	"path/filepath"
@@ -14,6 +15,7 @@ import (
 	"github.com/goplus/llar/internal/build"
 	"github.com/goplus/llar/internal/formula/repo"
 	"github.com/goplus/llar/internal/modules"
+	"github.com/goplus/llar/internal/modules/modlocal"
 	"github.com/goplus/llar/internal/vcs"
 	"github.com/goplus/llar/mod/module"
 	"github.com/spf13/cobra"
@@ -22,6 +24,19 @@ import (
 var makeVerbose bool
 var makeOutput string
 
+// newRemoteStore creates the remote formula store. Overridable for testing.
+var newRemoteStore = func() (repo.Store, error) {
+	formulaDir, err := repo.DefaultDir()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get formula dir: %w", err)
+	}
+	formulaRepo, err := vcs.NewRepo("github.com/goplus/llarhub")
+	if err != nil {
+		return nil, err
+	}
+	return repo.New(formulaDir, formulaRepo), nil
+}
+
 var makeCmd = &cobra.Command{
 	Use:   "make [module@version]",
 	Short: "Build a module to FormulaDir",
@@ -37,38 +52,79 @@ func init() {
 }
 
 func runMake(cmd *cobra.Command, args []string) error {
-	modPath, version := parseModuleArg(args[0])
+	pattern, version, isLocal, err := parseModuleArg(args[0])
+	if err != nil {
+		return err
+	}
 
 	ctx := context.Background()
 
-	// Set up formula store
-	formulaDir, err := repo.DefaultDir()
+	// Resolve output path to absolute before build (build may change cwd)
+	if makeOutput != "" {
+		abs, err := filepath.Abs(makeOutput)
+		if err != nil {
+			return fmt.Errorf("failed to resolve output path: %w", err)
+		}
+		makeOutput = abs
+	}
+
+	matrix := formula.Matrix{
+		Require: map[string][]string{
+			"os":   {runtime.GOOS},
+			"arch": {runtime.GOARCH},
+		},
+	}
+	matrixStr := matrix.Combinations()[0]
+
+	// Set up remote formula store (always needed for deps)
+	remoteStore, err := newRemoteStore()
 	if err != nil {
-		return fmt.Errorf("failed to get formula dir: %w", err)
+		return err
 	}
-	formulaRepo, err := vcs.NewRepo("github.com/goplus/llarhub")
+
+	if !isLocal {
+		return buildModule(ctx, remoteStore, pattern, version, matrixStr)
+	}
+
+	// Resolve local pattern
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get working directory: %w", err)
+	}
+
+	localMods, err := modlocal.Resolve(cwd, pattern)
 	if err != nil {
 		return err
 	}
-	store := repo.New(formulaDir, formulaRepo)
 
-	// Load modules
+	// Build overlay: local modules from disk, deps from remote
+	locals := make(map[string]string, len(localMods))
+	for _, m := range localMods {
+		locals[m.Path] = m.Dir
+	}
+	store := repo.NewOverlayStore(remoteStore, locals)
+
+	for _, m := range localMods {
+		ver := m.Version
+		if ver == "" {
+			ver = version // global @version from arg
+		}
+		if err := buildModule(ctx, store, m.Path, ver, matrixStr); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// buildModule loads and builds a single module.
+func buildModule(ctx context.Context, store repo.Store, modPath, version, matrixStr string) error {
 	mods, err := modules.Load(ctx, module.Version{Path: modPath, Version: version}, modules.Options{
 		FormulaStore: store,
 	})
 	if err != nil {
 		return fmt.Errorf("failed to load modules: %w", err)
 	}
 
-	// Resolve output path to absolute before build (build may change cwd)
-	if makeOutput != "" {
-		abs, err := filepath.Abs(makeOutput)
-		if err != nil {
-			return fmt.Errorf("failed to resolve output path: %w", err)
-		}
-		makeOutput = abs
-	}
-
 	// Handle verbose output
 	var savedStdout, savedStderr *os.File
 	if !makeVerbose {
@@ -77,7 +133,6 @@ func runMake(cmd *cobra.Command, args []string) error {
 			mod.SetStderr(io.Discard)
 		}
 
-		// Redirect os.Stdout/os.Stderr so subprocess output (cmake, etc.) is also silenced
 		savedStdout = os.Stdout
 		savedStderr = os.Stderr
 		devNull, err := os.OpenFile(os.DevNull, os.O_WRONLY, 0)
@@ -93,15 +148,6 @@ func runMake(cmd *cobra.Command, args []string) error {
 		}()
 	}
 
-	matrix := formula.Matrix{
-		Require: map[string][]string{
-			"os":   {runtime.GOOS},
-			"arch": {runtime.GOARCH},
-		},
-	}
-	matrixStr := matrix.Combinations()[0]
-
-	// When -o is specified, use a temp workspace so we don't pollute the cache
 	buildOpts := build.Options{
 		Store:     store,
 		MatrixStr: matrixStr,
@@ -131,14 +177,11 @@ func runMake(cmd *cobra.Command, args []string) error {
 		os.Stderr = savedStderr
 	}
 
-	// Print metadata for main module (last in build order)
 	if len(results) > 0 {
 		main := results[len(results)-1]
 		if main.Metadata != "" {
 			fmt.Println(main.Metadata)
 		}
-
-		// Output build artifacts if -o specified
 		if makeOutput != "" {
 			if err := outputResult(main.OutputDir, makeOutput); err != nil {
 				return fmt.Errorf("failed to write output: %w", err)
@@ -149,14 +192,31 @@ func runMake(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
-// parseModuleArg parses a module argument in the form "owner/repo@version" or "owner/repo".
-func parseModuleArg(arg string) (modPath, version string) {
-	for i := len(arg) - 1; i >= 0; i-- {
-		if arg[i] == '@' {
-			return arg[:i], arg[i+1:]
+// parseModuleArg parses a module argument and detects local filesystem patterns.
+// Local patterns follow Go-style local import forms (., .., ./x, ../x, absolute path).
+// Returns an error for invalid patterns like ".@version" (use "./@version" instead).
+func parseModuleArg(arg string) (pattern, version string, isLocal bool, err error) {
+	if strings.HasPrefix(arg, ".@") {
+		return "", "", false, fmt.Errorf("invalid local pattern %q: use \"./@version\" instead of \".@version\"", arg)
+	}
+
+	pattern = arg
+	for i := len(pattern) - 1; i >= 0; i-- {
+		if pattern[i] == '@' {
+			version = pattern[i+1:]
+			pattern = pattern[:i]
+			break
+		}
+	}
+
+	if stdbuild.IsLocalImport(pattern) || filepath.IsAbs(pattern) {
+		isLocal = true
+		pattern = filepath.Clean(pattern)
+		if pattern == "." {
+			pattern = ""
 		}
 	}
-	return arg, ""
+	return
 }
 
 // outputResult writes the build output to dest.