@ctxo/lang-go 0.8.0-alpha.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctxo/lang-go",
-  "version": "0.8.0-alpha.0",
+  "version": "0.8.0",
   "description": "Ctxo Go language plugin (ctxo-go-analyzer + tree-sitter, full tier)",
   "type": "module",
   "engines": {
@@ -37,14 +37,14 @@
     "tree-sitter-go": "^0.23.4"
   },
   "peerDependencies": {
-    "@ctxo/plugin-api": "^0.7.0"
+    "@ctxo/plugin-api": "^0.7.1"
   },
   "devDependencies": {
     "@types/node": "^22.15.3",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
     "vitest": "^3.1.3",
-    "@ctxo/plugin-api": "0.7.0"
+    "@ctxo/plugin-api": "0.7.1"
   },
   "repository": {
     "type": "git",
@@ -55,6 +55,10 @@
     "url": "https://github.com/alperhankendi/Ctxo/issues"
   },
   "homepage": "https://github.com/alperhankendi/Ctxo#readme",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
     "build": "tsup",
     "typecheck": "tsc --noEmit",

package/tools/ctxo-go-analyzer/internal/edges/edges_test.go

@@ -81,9 +81,9 @@ func main() { _ = ID[int](1) }
 `,
 	})
 
-	res, err := load.Packages(dir)
-	if err != nil {
-		t.Fatal(err)
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
 	}
 	ext := NewExtractor(dir, res.Packages)
 
@@ -127,9 +127,9 @@ func main() { _ = strings.ToUpper("hi") }
 
 func extractAllEdges(t *testing.T, dir string) map[string]bool {
 	t.Helper()
-	res, err := load.Packages(dir)
-	if err != nil {
-		t.Fatal(err)
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
 	}
 	ext := NewExtractor(dir, res.Packages)
 	out := map[string]bool{}

package/tools/ctxo-go-analyzer/internal/extends/extends_test.go

@@ -103,9 +103,9 @@ type Guarded struct {
 
 func extractAll(t *testing.T, dir string) map[string]bool {
 	t.Helper()
-	res, err := load.Packages(dir)
-	if err != nil {
-		t.Fatal(err)
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
 	}
 	out := map[string]bool{}
 	for _, list := range Extract(dir, res.Packages) {

package/tools/ctxo-go-analyzer/internal/implements/implements_test.go

@@ -39,9 +39,9 @@ type LoudGreeter interface {
 `,
 	})
 
-	res, err := load.Packages(dir)
-	if err != nil {
-		t.Fatal(err)
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
 	}
 
 	out := Extract(dir, res.Packages)
@@ -93,9 +93,9 @@ func (i ID) String() string { return string(i) }
 `,
 	})
 
-	res, err := load.Packages(dir)
-	if err != nil {
-		t.Fatal(err)
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
 	}
 	out := Extract(dir, res.Packages)
 

package/tools/ctxo-go-analyzer/internal/load/load.go

@@ -5,7 +5,10 @@ package load
 
 import (
 	"fmt"
+	"io/fs"
 	"os"
+	"path/filepath"
+	"strings"
 
 	"golang.org/x/tools/go/packages"
 )
@@ -24,18 +27,39 @@ const Mode = packages.NeedName |
 	packages.NeedTypesSizes |
 	packages.NeedModule
 
+// skippedDirs are filesystem entries we never descend into during subdir
+// fallback. vendor and node_modules avoid double-loading deps; hidden
+// directories tend to be tooling state, not source.
+var skippedDirs = map[string]bool{
+	"vendor":       true,
+	".git":         true,
+	".ctxo":        true,
+	"node_modules": true,
+	"testdata":     true,
+}
+
 // LoadResult bundles the loaded package set with any non-fatal errors so the
 // caller can decide whether to surface them as warnings.
 type LoadResult struct {
 	Packages []*packages.Package
-	// Errors are package-level Errors collected from packages.PrintErrors-style
-	// traversal. Returned for visibility — the loader does not fail the run.
+	// Errors are package-level Errors collected from a Visit traversal.
+	// Returned for visibility — the loader does not fail the run on these.
 	Errors []packages.Error
+	// FatalError is set when packages.Load returned a top-level error (e.g.,
+	// module-graph conflict). The caller may still get partial Packages.
+	FatalError error
+	// FallbackUsed is true when the root pattern failed and per-subdir
+	// recovery was used to gather whatever packages still loaded cleanly.
+	FallbackUsed bool
 }
 
 // Packages loads "./..." rooted at dir. Patterns can override the default
 // for tests that want to scope analysis to a single sub-package.
-func Packages(dir string, patterns ...string) (*LoadResult, error) {
+//
+// Failure mode: returns a LoadResult (possibly with empty Packages) and
+// sets FatalError. The caller should surface the error but continue —
+// degraded analysis beats no analysis when consumers have a flaky module.
+func Packages(dir string, patterns ...string) *LoadResult {
 	if len(patterns) == 0 {
 		patterns = []string{"./..."}
 	}
@@ -54,14 +78,85 @@ func Packages(dir string, patterns ...string) (*LoadResult, error) {
 	}
 
 	pkgs, err := packages.Load(cfg, patterns...)
+	res := &LoadResult{Packages: pkgs}
 	if err != nil {
-		return nil, fmt.Errorf("load: %w", err)
+		res.FatalError = fmt.Errorf("load: %w", err)
 	}
 
-	var errs []packages.Error
 	packages.Visit(pkgs, nil, func(p *packages.Package) {
-		errs = append(errs, p.Errors...)
+		res.Errors = append(res.Errors, p.Errors...)
 	})
+	return res
+}
+
+// PackagesWithFallback tries to load the whole module first; if that yields
+// zero packages (typical when the module graph has a fatal conflict), it
+// walks top-level subdirectories and loads each independently. Subdirs that
+// transitively avoid the conflicting imports still produce full type info.
+func PackagesWithFallback(dir string) *LoadResult {
+	primary := Packages(dir)
+	if len(primary.Packages) > 0 {
+		return primary
+	}
 
-	return &LoadResult{Packages: pkgs, Errors: errs}, nil
+	subdirs := topLevelGoSubdirs(dir)
+	if len(subdirs) == 0 {
+		return primary
+	}
+
+	merged := &LoadResult{
+		FatalError:   primary.FatalError,
+		FallbackUsed: true,
+	}
+	for _, sub := range subdirs {
+		pattern := "./" + filepath.ToSlash(sub) + "/..."
+		subRes := Packages(dir, pattern)
+		if len(subRes.Packages) == 0 {
+			continue
+		}
+		merged.Packages = append(merged.Packages, subRes.Packages...)
+		merged.Errors = append(merged.Errors, subRes.Errors...)
+	}
+	return merged
+}
+
+// topLevelGoSubdirs returns immediate subdirectories of root that contain at
+// least one .go file (recursively). Skips vendor, .git, hidden dirs, etc.
+func topLevelGoSubdirs(root string) []string {
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		return nil
+	}
+	var out []string
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		name := e.Name()
+		if skippedDirs[name] || strings.HasPrefix(name, ".") {
+			continue
+		}
+		if hasGoFile(filepath.Join(root, name)) {
+			out = append(out, name)
+		}
+	}
+	return out
+}
+
+func hasGoFile(dir string) bool {
+	found := false
+	_ = filepath.WalkDir(dir, func(_ string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
+		if d.IsDir() && skippedDirs[d.Name()] {
+			return fs.SkipDir
+		}
+		if !d.IsDir() && strings.HasSuffix(d.Name(), ".go") {
+			found = true
+			return fs.SkipAll
+		}
+		return nil
+	})
+	return found
 }

package/tools/ctxo-go-analyzer/internal/load/load_test.go

@@ -0,0 +1,96 @@
+package load
+
+import (
+	"os"
+	"path/filepath"
+	"sort"
+	"testing"
+
+	"golang.org/x/tools/go/packages"
+)
+
+func TestPackagesOnHealthyModule(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"a.go":   "package fixture\n\nfunc Hello() string { return \"hi\" }\n",
+	})
+	res := Packages(dir)
+	if res.FatalError != nil {
+		t.Fatalf("FatalError: %v", res.FatalError)
+	}
+	if len(res.Packages) == 0 {
+		t.Fatal("expected at least one package")
+	}
+}
+
+func TestPackagesWithFallbackRecoversPartial(t *testing.T) {
+	// "broken/" imports a non-existent path so the module-wide load fails;
+	// "healthy/" is self-contained, so per-subdir loading recovers it.
+	dir := writeFixture(t, map[string]string{
+		"go.mod":             "module fixture\n\ngo 1.22\n",
+		"broken/broken.go":   "package broken\n\nimport _ \"definitely.nowhere/missing\"\n",
+		"healthy/healthy.go": "package healthy\n\nfunc Y() int { return 1 }\n",
+	})
+
+	res := PackagesWithFallback(dir)
+	if len(res.Packages) == 0 {
+		t.Fatalf("expected fallback to recover at least one package; got 0 (FatalError=%v)", res.FatalError)
+	}
+	if !pkgListContainsName(res.Packages, "healthy") {
+		t.Errorf("expected 'healthy' package recovered via fallback; got %v", pkgNames(res.Packages))
+	}
+}
+
+func TestTopLevelGoSubdirsSkipsHidden(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"a/file.go":     "package a",
+		".hidden/x.go":  "package x",
+		"vendor/foo.go": "package foo",
+		"b/file.go":     "package b",
+	})
+	got := topLevelGoSubdirs(dir)
+	sort.Strings(got)
+	want := []string{"a", "b"}
+	if len(got) != len(want) {
+		t.Fatalf("got %v, want %v", got, want)
+	}
+	for i := range got {
+		if got[i] != want[i] {
+			t.Fatalf("index %d: got %q want %q", i, got[i], want[i])
+		}
+	}
+}
+
+// ── helpers ──
+
+func writeFixture(t *testing.T, files map[string]string) string {
+	t.Helper()
+	dir := t.TempDir()
+	for name, body := range files {
+		path := filepath.Join(dir, name)
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}
+
+func pkgNames(pkgs []*packages.Package) []string {
+	out := make([]string, 0, len(pkgs))
+	for _, p := range pkgs {
+		out = append(out, p.Name)
+	}
+	return out
+}
+
+func pkgListContainsName(pkgs []*packages.Package, name string) bool {
+	for _, p := range pkgs {
+		if p.Name == name {
+			return true
+		}
+	}
+	return false
+}

package/tools/ctxo-go-analyzer/internal/reach/reach_test.go

@@ -119,9 +119,9 @@ func main() {
 
 func analyze(t *testing.T, dir string) *Result {
 	t.Helper()
-	res, err := load.Packages(dir)
-	if err != nil {
-		t.Fatal(err)
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
 	}
 	return Analyze(dir, res.Packages, 30*time.Second)
 }

package/tools/ctxo-go-analyzer/internal/symbols/symbols_test.go

@@ -47,9 +47,9 @@ func (u User) ID() string { return u.Name }
 `,
 	})
 
-	res, err := load.Packages(dir)
-	if err != nil {
-		t.Fatalf("Packages: %v", err)
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatalf("Packages: %v", res.FatalError)
 	}
 	if len(res.Packages) == 0 {
 		t.Fatal("no packages loaded")
@@ -123,9 +123,9 @@ type Box[T any] struct{ v T }
 func (b *Box[T]) Get() T { return b.v }
 `,
 	})
-	res, err := load.Packages(dir)
-	if err != nil {
-		t.Fatal(err)
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
 	}
 
 	found := false

package/tools/ctxo-go-analyzer/main.go

@@ -66,9 +66,12 @@ func run(root string, stdout *os.File) error {
 		return err
 	}
 
-	res, err := load.Packages(root)
-	if err != nil {
-		return fmt.Errorf("load packages: %w", err)
+	res := load.PackagesWithFallback(root)
+	if res.FatalError != nil {
+		_ = w.Progress(fmt.Sprintf("module load returned a fatal error (degrading): %v", res.FatalError))
+	}
+	if res.FallbackUsed {
+		_ = w.Progress(fmt.Sprintf("root pattern failed; per-subdir fallback recovered %d packages", len(res.Packages)))
 	}
 	if len(res.Errors) > 0 {
 		_ = w.Progress(fmt.Sprintf("load reported %d package-level errors (continuing)", len(res.Errors)))