feat: add safe Ruff source repair

Author: AntoineToussaint

agent.codefly.yaml

@@ -1,3 +1,3 @@
 publisher: codefly.dev
 name: python
-version: 0.0.14
+version: 0.0.15

go.mod

@@ -5,7 +5,7 @@ go 1.25.0
 toolchain go1.26.4
 
 require (
-	github.com/codefly-dev/core v0.2.23
+	github.com/codefly-dev/core v0.2.24
 	gopkg.in/yaml.v3 v3.0.1
 )
 

main.go

@@ -19,6 +19,7 @@ import (
 	"github.com/codefly-dev/core/agents"
 	"github.com/codefly-dev/core/resources"
 	"github.com/codefly-dev/core/shared"
+	"github.com/codefly-dev/core/toolbox/lang"
 
 	pythonbuilder "github.com/codefly-dev/service-python/pkg/builder"
 	pythoncode "github.com/codefly-dev/service-python/pkg/code"
@@ -36,11 +37,13 @@ func main() {
 	svc := pythonservice.New(agent.Of(resources.ServiceAgent))
 	code := pythoncode.New(svc)
 	runtime := pythonruntime.New(svc)
+	tooling := pythontooling.New(code, runtime)
 	agents.Serve(agents.PluginRegistration{
 		Agent:   svc,
 		Runtime: runtime,
 		Builder: pythonbuilder.New(svc),
 		Code:    code,
-		Tooling: pythontooling.New(code, runtime),
+		Tooling: tooling,
+		Toolbox: lang.NewToolboxFromTooling(agent.Name, agent.Version, tooling),
 	})
 }

pkg/code/code.go

@@ -5,10 +5,15 @@ package code
 
 import (
 	"context"
+	"fmt"
 	"os"
+	"path/filepath"
+	"strings"
 
 	corecode "github.com/codefly-dev/core/code"
+	basev0 "github.com/codefly-dev/core/generated/go/codefly/base/v0"
 	codev0 "github.com/codefly-dev/core/generated/go/codefly/services/code/v0"
+	runners "github.com/codefly-dev/core/runners/base"
 
 	pythonservice "github.com/codefly-dev/service-python/pkg/service"
 )
@@ -38,15 +43,15 @@ func New(svc *pythonservice.Service) *Code {
 }
 
 // SourceDir returns the directory to operate on. Resolution order:
-// explicit Service.SourceLocation → CODEFLY_AGENT_WORKDIR → Service.Location.
+// explicit Service.SourceLocation → CODEFLY_AGENT_WORKDIR/source-dir → Service.Location/source-dir.
 func (c *Code) SourceDir() string {
 	if c.Service.SourceLocation != "" {
 		return c.Service.SourceLocation
 	}
 	if wd := os.Getenv("CODEFLY_AGENT_WORKDIR"); wd != "" {
-		return wd
+		return filepath.Join(wd, c.Service.Settings.PythonSourceDir())
 	}
-	return c.Service.Location
+	return filepath.Join(c.Service.Location, c.Service.Settings.PythonSourceDir())
 }
 
 // EnsureInit lazily swaps in a PythonCodeServer pointed at the resolved
@@ -55,23 +60,68 @@ func (c *Code) SourceDir() string {
 func (c *Code) EnsureInit() {
 	if !c.initialized {
 		c.PythonCodeServer = corecode.NewPythonCodeServer(c.SourceDir(), nil)
+		c.SetSourceFixer(c.fixPython)
 		c.initialized = true
 	}
 }
 
-// ── Lazy-init RPC wrappers ───────────────────────────────
-
-func (c *Code) GetProjectInfo(ctx context.Context, req *codev0.GetProjectInfoRequest) (*codev0.GetProjectInfoResponse, error) {
+func (c *Code) Execute(ctx context.Context, req *codev0.CodeRequest) (*codev0.CodeResponse, error) {
 	c.EnsureInit()
-	return c.PythonCodeServer.GetProjectInfo(ctx, req)
+	return c.PythonCodeServer.Execute(ctx, req)
 }
 
-func (c *Code) ListDependencies(ctx context.Context, req *codev0.ListDependenciesRequest) (*codev0.ListDependenciesResponse, error) {
-	c.EnsureInit()
-	return c.PythonCodeServer.ListDependencies(ctx, req)
+// fixPython applies only project-configured Ruff safe fixes, then Ruff's
+// formatter. Both stages operate on stdin and return source on stdout, so the
+// core Code server remains the sole writer and can honor VFS/dry-run semantics.
+func (c *Code) fixPython(ctx context.Context, input corecode.FixInput) (corecode.FixResult, error) {
+	checkArgs := []string{"check", "--fix-only"}
+	if input.Mode == basev0.FixMode_FIX_MODE_AGGRESSIVE {
+		checkArgs = append(checkArgs, "--unsafe-fixes")
+	}
+	checkArgs = append(checkArgs, "--stdin-filename", input.Path, "-")
+
+	// Fix is an authoring primitive, not environment initialization. Invoke a
+	// provisioned Ruff directly so a dry run cannot create .venv/uv.lock or
+	// download the project's dependency graph. Factory Nix shells include Ruff,
+	// the Docker runtime exposes /venv/bin on PATH, and native users may supply
+	// either a project-local .venv binary or Ruff on the host PATH.
+	ruff := c.ruffCommand()
+	checked, checkLogBytes, err := runners.RunInput(ctx, c.runnerEnvironment(ctx), c.SourceDir(), input.Content, ruff, checkArgs...)
+	checkLog := string(checkLogBytes)
+	if err != nil {
+		return corecode.FixResult{}, fmt.Errorf("ruff check --fix-only (Ruff must already be provisioned): %w: %s", err, strings.TrimSpace(checkLog))
+	}
+	formatted, formatLogBytes, err := runners.RunInput(ctx, c.runnerEnvironment(ctx), c.SourceDir(), checked, ruff, "format", "--stdin-filename", input.Path, "-")
+	formatLog := string(formatLogBytes)
+	if err != nil {
+		return corecode.FixResult{}, fmt.Errorf("ruff format: %w: %s", err, strings.TrimSpace(formatLog))
+	}
+	output := strings.TrimSpace(strings.Join([]string{checkLog, formatLog}, "\n"))
+	return corecode.FixResult{
+		Content: formatted,
+		Actions: []string{"ruff check --fix-only", "ruff format"},
+		Output:  output,
+	}, nil
 }
 
-func (c *Code) Execute(ctx context.Context, req *codev0.CodeRequest) (*codev0.CodeResponse, error) {
-	c.EnsureInit()
-	return c.PythonCodeServer.Execute(ctx, req)
+func (c *Code) ruffCommand() string {
+	if c.Service.ActiveEnv == nil {
+		candidate := filepath.Join(c.SourceDir(), ".venv", "bin", "ruff")
+		if info, err := os.Stat(candidate); err == nil && info.Mode().IsRegular() && info.Mode().Perm()&0o111 != 0 {
+			return candidate
+		}
+	}
+	return "ruff"
+}
+
+func (c *Code) runnerEnvironment(ctx context.Context) runners.RunnerEnvironment {
+	env := c.Service.ActiveEnv
+	if env != nil {
+		return env
+	}
+	var runtimeContext *basev0.RuntimeContext
+	if c.Service.Base != nil && c.Service.Base.Runtime != nil {
+		runtimeContext = c.Service.Base.Runtime.RuntimeContext
+	}
+	return runners.ResolveStandaloneEnvironment(ctx, c.SourceDir(), runtimeContext)
 }

pkg/code/fix_test.go

@@ -0,0 +1,82 @@
+package code_test
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	codev0 "github.com/codefly-dev/core/generated/go/codefly/services/code/v0"
+	"github.com/codefly-dev/core/resources"
+	pythoncode "github.com/codefly-dev/service-python/pkg/code"
+	pythonservice "github.com/codefly-dev/service-python/pkg/service"
+)
+
+func TestFixUsesRuffAndHonorsDryRun(t *testing.T) {
+	if _, err := exec.LookPath("ruff"); err != nil {
+		t.Skip("ruff is not installed")
+	}
+	dir := t.TempDir()
+	original := "import os\n\ndef answer( ):\n return 42\n"
+	if err := os.WriteFile(filepath.Join(dir, "sample.py"), []byte(original), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	svc := pythonservice.New(&resources.Agent{Kind: "codefly:service", Name: "python"})
+	svc.SourceLocation = dir
+	server := pythoncode.New(svc)
+	response, err := server.Execute(context.Background(), &codev0.CodeRequest{Operation: &codev0.CodeRequest_Fix{Fix: &codev0.FixRequest{
+		File: "sample.py", DryRun: true,
+	}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	fix := response.GetFix()
+	if !fix.GetSuccess() || !fix.GetChanged() || fix.GetWrote() {
+		t.Fatalf("dry-run fix = %+v failure=%+v", fix, response.GetFailure())
+	}
+	if strings.Contains(fix.GetContent(), "import os") || !strings.Contains(fix.GetContent(), "def answer():") {
+		t.Fatalf("Ruff pipeline did not lint+format:\n%s", fix.GetContent())
+	}
+	written, err := os.ReadFile(filepath.Join(dir, "sample.py"))
+	if err != nil || string(written) != original {
+		t.Fatalf("dry-run changed source: err=%v content=%q", err, written)
+	}
+	for _, unexpected := range []string{".venv", "uv.lock"} {
+		if _, err := os.Stat(filepath.Join(dir, unexpected)); !os.IsNotExist(err) {
+			t.Fatalf("dry-run materialized %s: %v", unexpected, err)
+		}
+	}
+}
+
+func TestApplyEditRunsRuffSafeFixerByDefault(t *testing.T) {
+	if _, err := exec.LookPath("ruff"); err != nil {
+		t.Skip("ruff is not installed")
+	}
+	dir := t.TempDir()
+	original := "import os\n\ndef answer( ):\n return 42\n"
+	if err := os.WriteFile(filepath.Join(dir, "sample.py"), []byte(original), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	svc := pythonservice.New(&resources.Agent{Kind: "codefly:service", Name: "python"})
+	svc.SourceLocation = dir
+	server := pythoncode.New(svc)
+	response, err := server.Execute(context.Background(), &codev0.CodeRequest{Operation: &codev0.CodeRequest_ApplyEdit{ApplyEdit: &codev0.ApplyEditRequest{
+		File: "sample.py", Find: "return 42", Replace: "return( 43 )",
+	}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	edit := response.GetApplyEdit()
+	if !edit.GetSuccess() || !edit.GetChanged() || !edit.GetWrote() {
+		t.Fatalf("ApplyEdit = %+v failure=%+v", edit, response.GetFailure())
+	}
+	if strings.Contains(edit.GetContent(), "import os") || !strings.Contains(edit.GetContent(), "def answer():\n    return 43") {
+		t.Fatalf("Ruff was not composed into ApplyEdit:\n%s", edit.GetContent())
+	}
+	written, err := os.ReadFile(filepath.Join(dir, "sample.py"))
+	if err != nil || string(written) != edit.GetContent() {
+		t.Fatalf("ApplyEdit did not commit returned content: err=%v content=%q", err, written)
+	}
+}

pkg/runtime/runtime.go

@@ -59,10 +59,18 @@ func (s *Runtime) Load(ctx context.Context, req *runtimev0.LoadRequest) (*runtim
 
 	response, err := s.Runtime.LoadService(ctx, req, services.RuntimeLoad{Settings: s.Service.Settings})
 
-	// Python convention: source is the service directory itself.
-	s.Service.SourceLocation = s.Location
+	// Prefer the conventional code/ source tree while retaining root-level
+	// pyproject checkouts. Code, Runtime, and arbitrary-source adapters then
+	// share one source-root contract.
+	root := s.Location
 	if wd := os.Getenv("CODEFLY_AGENT_WORKDIR"); wd != "" {
-		s.Service.SourceLocation = wd
+		root = wd
+	}
+	s.Service.SourceLocation = filepath.Join(root, s.Service.Settings.PythonSourceDir())
+	if _, statErr := os.Stat(filepath.Join(s.Service.SourceLocation, "pyproject.toml")); statErr != nil {
+		if _, rootErr := os.Stat(filepath.Join(root, "pyproject.toml")); rootErr == nil {
+			s.Service.SourceLocation = root
+		}
 	}
 
 	if response != nil && response.Status != nil {
@@ -208,16 +216,21 @@ func (s *Runtime) Test(ctx context.Context, req *runtimev0.TestRequest) (*runtim
 }
 
 // Lint runs ruff via the core python helper.
-func (s *Runtime) Lint(ctx context.Context, _ *runtimev0.LintRequest) (*runtimev0.LintResponse, error) {
+func (s *Runtime) Lint(ctx context.Context, req *runtimev0.LintRequest) (*runtimev0.LintResponse, error) {
 	defer s.Wool.Catch()
+	if req == nil {
+		req = &runtimev0.LintRequest{}
+	}
 
-	output, err := pythonhelpers.RunPythonLint(ctx, s.Service.SourceLocation)
+	output, err := pythonhelpers.RunPythonLint(ctx, s.Service.SourceLocation, req.GetTarget())
+	compressed := llmout.Compress("ruff", []string{"check"}, output)
 
 	return &runtimev0.LintResponse{
 		Status: &runtimev0.LintStatus{
 			State:   boolToLintState(err == nil),
-			Message: llmout.Compress("ruff", []string{"check"}, output),
+			Message: compressed,
 		},
+		Output: compressed,
 	}, nil
 }
 

pkg/service/service.go

@@ -22,6 +22,14 @@ import (
 //	}
 type Settings struct {
 	PythonVersion string `yaml:"python-version"`
+	SourceDir     string `yaml:"source-dir"`
+}
+
+func (s *Settings) PythonSourceDir() string {
+	if s.SourceDir != "" {
+		return s.SourceDir
+	}
+	return "code"
 }
 
 // Service carries the shared state used by Runtime, Code, Tooling, Builder.