Improve module cycle diagnostics

Author: mgomes

ROADMAP.md

@@ -252,7 +252,7 @@ Goal: make multi-file script projects easier to compose and maintain.
 - [x] Add explicit export controls (beyond underscore naming).
 - [x] Add import aliasing for module objects.
 - [x] Define and enforce module namespace conflict behavior.
-- [ ] Improve cycle error diagnostics with concise chain rendering.
+- [x] Improve cycle error diagnostics with concise chain rendering.
 - [ ] Add module cache invalidation policy for long-running hosts.
 
 ### Security and Isolation

docs/integration.md

@@ -72,6 +72,8 @@ end`)
 
 The interpreter searches each configured directory for `<module>.vibe` in order
 and caches compiled modules so subsequent calls to `require` are inexpensive.
+When a circular module dependency is detected, the runtime reports a concise
+chain (for example `a -> b -> a`).
 Use the optional `as:` keyword to bind the loaded module object to a global
 alias.
 Inside a module, use explicit relative paths (`./` or `../`) to load siblings

vibes/modules.go

@@ -81,6 +81,11 @@ func moduleKeyDisplay(key string) string {
 	return display
 }
 
+func moduleDisplayName(key string) string {
+	display := filepath.ToSlash(moduleKeyDisplay(key))
+	return strings.TrimSuffix(display, ".vibe")
+}
+
 func moduleRelativePath(root, fullPath string) (string, error) {
 	rel, err := moduleRelativePathLexical(root, fullPath)
 	if err != nil {
@@ -336,9 +341,19 @@ func moduleCycleFromExecution(stack []moduleContext, next string) ([]string, boo
 }
 
 func formatModuleCycle(cycle []string) string {
-	parts := make([]string, len(cycle))
-	for idx, key := range cycle {
-		parts[idx] = moduleKeyDisplay(key)
+	if len(cycle) == 0 {
+		return ""
+	}
+	normalized := make([]string, 0, len(cycle))
+	for _, key := range cycle {
+		if len(normalized) > 0 && normalized[len(normalized)-1] == key {
+			continue
+		}
+		normalized = append(normalized, key)
+	}
+	parts := make([]string, len(normalized))
+	for idx, key := range normalized {
+		parts[idx] = moduleDisplayName(key)
 	}
 	return strings.Join(parts, " -> ")
 }
@@ -485,7 +500,8 @@ func builtinRequire(exec *Execution, receiver Value, args []Value, kwargs map[st
 	}
 
 	if exec.moduleLoading[entry.key] {
-		return NewNil(), fmt.Errorf("require: circular dependency detected for module %q", moduleKeyDisplay(entry.key))
+		cycle := append(append([]string(nil), exec.moduleLoadStack...), entry.key)
+		return NewNil(), fmt.Errorf("require: circular dependency detected: %s", formatModuleCycle(cycle))
 	}
 	exec.moduleLoading[entry.key] = true
 	exec.moduleLoadStack = append(exec.moduleLoadStack, entry.key)

vibes/modules_test.go

@@ -814,3 +814,24 @@ end`)
 		t.Fatalf("expected 12, got %#v", result)
 	}
 }
+
+func TestFormatModuleCycleUsesConciseChain(t *testing.T) {
+	root := filepath.Join("tmp", "modules")
+	a := moduleCacheKey(root, filepath.Join("nested", "a.vibe"))
+	b := moduleCacheKey(root, filepath.Join("nested", "b.vibe"))
+
+	got := formatModuleCycle([]string{a, b, b, a})
+	want := filepath.ToSlash(filepath.Join("nested", "a")) + " -> " + filepath.ToSlash(filepath.Join("nested", "b")) + " -> " + filepath.ToSlash(filepath.Join("nested", "a"))
+	if got != want {
+		t.Fatalf("expected cycle %q, got %q", want, got)
+	}
+}
+
+func TestModuleDisplayNameTrimsExtension(t *testing.T) {
+	key := moduleCacheKey(filepath.Join("tmp", "modules"), filepath.Join("pkg", "helper.vibe"))
+	got := moduleDisplayName(key)
+	want := filepath.ToSlash(filepath.Join("pkg", "helper"))
+	if got != want {
+		t.Fatalf("expected display %q, got %q", want, got)
+	}
+}