fix: rename the active-environment accessors so stale reads fail to build (#81) (#82)

Unexporting ActiveEnv behind an accessor of the same name made the break
loud for writers and silent for readers: a method value is comparable to
nil and assignable to interface{}, so `if svc.ActiveEnv == nil` compiles
as dead code and `require.Nil(t, svc.ActiveEnv)` passes vacuously. Only
the assignment form failed to build, and go vet catches just one of the
two silent shapes.

ActiveEnvironment/SetActiveEnvironment leave no pre-#79 spelling that
compiles, so the compiler reports what review missed.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: antoinetoussaint-byte

agent.codefly.yaml

@@ -1,4 +1,4 @@
 publisher: codefly.dev
 kind: codefly:service
 name: python
-version: 0.0.60
+version: 0.0.61

pkg/code/callgraph.go

@@ -137,7 +137,7 @@ print(json.dumps({'calls': calls, 'implements': implements, 'module': workdir}))
 	// so AST analysis uses the same interpreter as the running service.
 	// Pre-Init falls through ResolveStandaloneEnvironment which picks Nix
 	// if declared, native otherwise — keeps mode consistency when possible.
-	env := c.Service.ActiveEnv()
+	env := c.Service.ActiveEnvironment()
 	if env == nil {
 		var rctx *basev0.RuntimeContext
 		if c.Service.Base != nil && c.Service.Base.Runtime != nil {

pkg/code/code.go

@@ -78,7 +78,7 @@ func (c *Code) fixPython(ctx context.Context, input corecode.FixInput) (corecode
 	// One snapshot for the whole request: a specialization publishing or
 	// clearing its environment mid-fix must not send check and format to
 	// two different interpreters.
-	active := c.Service.ActiveEnv()
+	active := c.Service.ActiveEnvironment()
 
 	checkArgs := []string{"check", "--fix-only"}
 	if input.Mode == basev0.FixMode_FIX_MODE_AGGRESSIVE {

pkg/code/fix_test.go

@@ -119,8 +119,8 @@ func TestCodeIsSafeWhileTheActiveEnvironmentIsRepublished(t *testing.T) {
 			case <-done:
 				return
 			default:
-				svc.SetActiveEnv(env)
-				svc.SetActiveEnv(nil)
+				svc.SetActiveEnvironment(env)
+				svc.SetActiveEnvironment(nil)
 			}
 		}
 	}()

pkg/runtime/commands.go

@@ -21,7 +21,7 @@
 //	                                 (stdin ◀── code ── stdin)
 //	                                 (stdout ──▶ sentinel-reader ──▶ string)
 //
-// Mode-consistent: the REPL uses the plugin's ActiveEnv. A Docker-mode
+// Mode-consistent: the REPL uses the plugin's active environment. A Docker-mode
 // plugin opens the REPL inside its container (same venv, same Python
 // version as the running service). Nix-mode plugins get the REPL
 // inside the flake's devShell.
@@ -142,10 +142,10 @@ func (s *Runtime) getOrStartRepl(ctx context.Context) (*PythonRepl, error) {
 	return r, nil
 }
 
-// resolveReplEnv returns the plugin's ActiveEnv or a standalone one
+// resolveReplEnv returns the plugin's active environment or a standalone one
 // when Runtime.Init hasn't populated it. Same pattern as Code/Tooling.
 func (s *Runtime) resolveReplEnv(ctx context.Context) runners.RunnerEnvironment {
-	if env := s.Service.ActiveEnv(); env != nil {
+	if env := s.Service.ActiveEnvironment(); env != nil {
 		return env
 	}
 	var rctx *basev0.RuntimeContext

pkg/runtime/runtime_internal_test.go

@@ -450,8 +450,8 @@ func TestResolveReplEnvIsSafeWhileTheActiveEnvironmentIsRepublished(t *testing.T
 			case <-done:
 				return
 			default:
-				service.SetActiveEnv(env)
-				service.SetActiveEnv(nil)
+				service.SetActiveEnvironment(env)
+				service.SetActiveEnvironment(nil)
 			}
 		}
 	}()

pkg/service/service.go

@@ -46,33 +46,33 @@ type Service struct {
 	// Load). Specializations may override at Load time.
 	SourceLocation string
 
-	// activeEnv is a specialization's active RunnerEnvironment, consumed by
-	// Code / Tooling / the REPL so every spawn routes through the same mode
-	// (native / docker / nix). The generic runtime leaves it nil; call sites
-	// fall back to a fresh NativeEnvironment.
+	// activeEnvironment is a specialization's active RunnerEnvironment,
+	// consumed by Code / Tooling / the REPL so every spawn routes through the
+	// same mode (native / docker / nix). The generic runtime leaves it nil;
+	// call sites fall back to a fresh NativeEnvironment.
 	//
 	// A specialization publishes it from Init and clears it from Stop, while
 	// Code, Tooling and the REPL read it on their own gRPC goroutines, so it
-	// is reachable only through ActiveEnv / SetActiveEnv.
-	activeEnvMu sync.RWMutex
-	activeEnv   runners.RunnerEnvironment
+	// is reachable only through ActiveEnvironment / SetActiveEnvironment.
+	activeEnvironmentMu sync.RWMutex
+	activeEnvironment   runners.RunnerEnvironment
 }
 
-// ActiveEnv returns the environment a specialization published, or nil when
-// none is active — before Init, or after the specialization tore it down.
-func (s *Service) ActiveEnv() runners.RunnerEnvironment {
-	s.activeEnvMu.RLock()
-	defer s.activeEnvMu.RUnlock()
-	return s.activeEnv
+// ActiveEnvironment returns the environment a specialization published, or
+// nil when none is active — before Init, or after it tore the environment down.
+func (s *Service) ActiveEnvironment() runners.RunnerEnvironment {
+	s.activeEnvironmentMu.RLock()
+	defer s.activeEnvironmentMu.RUnlock()
+	return s.activeEnvironment
 }
 
-// SetActiveEnv publishes the specialization's active RunnerEnvironment.
+// SetActiveEnvironment publishes the specialization's active RunnerEnvironment.
 // Pass nil once the environment is shut down: readers then fall back to a
 // standalone environment instead of spawning into a dead one.
-func (s *Service) SetActiveEnv(env runners.RunnerEnvironment) {
-	s.activeEnvMu.Lock()
-	defer s.activeEnvMu.Unlock()
-	s.activeEnv = env
+func (s *Service) SetActiveEnvironment(env runners.RunnerEnvironment) {
+	s.activeEnvironmentMu.Lock()
+	defer s.activeEnvironmentMu.Unlock()
+	s.activeEnvironment = env
 }
 
 // New builds a generic Python Service bound to the given agent manifest.

pkg/service/service_test.go

@@ -116,34 +116,34 @@ func TestGetAgentInformationGeneric(t *testing.T) {
 	}
 }
 
-// TestActiveEnvPublishAndClear locks in the contract specializations use:
+// TestActiveEnvironmentPublishAndClear locks in the contract specializations use:
 // what Init publishes is what Code, Tooling and the REPL read, and what Stop
 // clears sends them back to the standalone fallback.
-func TestActiveEnvPublishAndClear(t *testing.T) {
+func TestActiveEnvironmentPublishAndClear(t *testing.T) {
 	svc := pythonservice.New(&resources.Agent{Kind: "codefly:service", Name: "python"})
-	if svc.ActiveEnv() != nil {
+	if svc.ActiveEnvironment() != nil {
 		t.Fatal("a Service with no specialization environment must read nil")
 	}
 
 	env, err := runners.NewNativeEnvironment(context.Background(), t.TempDir())
 	if err != nil {
 		t.Fatalf("native environment: %v", err)
 	}
-	svc.SetActiveEnv(env)
-	if svc.ActiveEnv() != env {
+	svc.SetActiveEnvironment(env)
+	if svc.ActiveEnvironment() != env {
 		t.Fatal("published environment is not the one readers get")
 	}
 
-	svc.SetActiveEnv(nil)
-	if svc.ActiveEnv() != nil {
+	svc.SetActiveEnvironment(nil)
+	if svc.ActiveEnvironment() != nil {
 		t.Fatal("cleared environment must read nil, not a shut-down one")
 	}
 }
 
-// TestActiveEnvUnderConcurrentPublishAndRead is the -race guard for the
+// TestActiveEnvironmentUnderConcurrentPublishAndRead is the -race guard for the
 // field itself: a specialization publishes from Init and clears from Stop
 // while Code, Tooling and the REPL read on their own gRPC goroutines.
-func TestActiveEnvUnderConcurrentPublishAndRead(t *testing.T) {
+func TestActiveEnvironmentUnderConcurrentPublishAndRead(t *testing.T) {
 	svc := pythonservice.New(&resources.Agent{Kind: "codefly:service", Name: "python"})
 	env, err := runners.NewNativeEnvironment(context.Background(), t.TempDir())
 	if err != nil {
@@ -155,16 +155,16 @@ func TestActiveEnvUnderConcurrentPublishAndRead(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		for i := 0; i < 1000; i++ {
-			svc.SetActiveEnv(env)
-			svc.SetActiveEnv(nil)
+			svc.SetActiveEnvironment(env)
+			svc.SetActiveEnvironment(nil)
 		}
 	}()
 	for readers := 0; readers < 3; readers++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			for i := 0; i < 1000; i++ {
-				if got := svc.ActiveEnv(); got != nil && got != env {
+				if got := svc.ActiveEnvironment(); got != nil && got != env {
 					t.Errorf("read an environment that was never published: %#v", got)
 					return
 				}