env: add new FileSystem-related tools such as Grep, Glob and Edit.

Also modifies List to add an `ignore` argument.

Signed-off-by: Tibor Vass <teabee89@gmail.com>

Author: tiborvass

environment/filesystem.go

@@ -4,8 +4,14 @@ import (
 	"context"
 	"fmt"
 	"strings"
+
+	"dagger.io/dagger"
+	"dagger.io/dagger/dag"
 )
 
+// FIXME: See hack where it's used
+const fileEditBaseImage = "busybox"
+
 func (env *Environment) FileRead(ctx context.Context, targetFile string, shouldReadEntireFile bool, startLineOneIndexed int, endLineOneIndexedInclusive int) (string, error) {
 	file, err := env.container().File(targetFile).Contents(ctx)
 	if err != nil {
@@ -31,7 +37,7 @@ func (env *Environment) FileRead(ctx context.Context, targetFile string, shouldR
 	return strings.Join(lines[start:end], "\n"), nil
 }
 
-func (env *Environment) FileWrite(ctx context.Context, explanation, targetFile, contents string) error {
+func (env *Environment) FileWrite(ctx context.Context, targetFile, contents string) error {
 	err := env.apply(ctx, env.container().WithNewFile(targetFile, contents))
 	if err != nil {
 		return fmt.Errorf("failed applying file write, skipping git propagation: %w", err)
@@ -40,7 +46,7 @@ func (env *Environment) FileWrite(ctx context.Context, explanation, targetFile,
 	return nil
 }
 
-func (env *Environment) FileDelete(ctx context.Context, explanation, targetFile string) error {
+func (env *Environment) FileDelete(ctx context.Context, targetFile string) error {
 	err := env.apply(ctx, env.container().WithoutFile(targetFile))
 	if err != nil {
 		return fmt.Errorf("failed applying file delete, skipping git propagation: %w", err)
@@ -49,8 +55,18 @@ func (env *Environment) FileDelete(ctx context.Context, explanation, targetFile
 	return nil
 }
 
-func (env *Environment) FileList(ctx context.Context, path string) (string, error) {
-	entries, err := env.container().Directory(path).Entries(ctx)
+func (env *Environment) FileList(ctx context.Context, path string, ignore []string) (string, error) {
+	filter := dagger.DirectoryFilterOpts{Exclude: ignore}
+	return env.ls(ctx, path, filter)
+}
+
+func (env *Environment) FileGlob(ctx context.Context, path string, pattern string) (string, error) {
+	filter := dagger.DirectoryFilterOpts{Include: []string{pattern}}
+	return env.ls(ctx, path, filter)
+}
+
+func (env *Environment) ls(ctx context.Context, path string, filter dagger.DirectoryFilterOpts) (string, error) {
+	entries, err := env.container().Directory(path).Filter(filter).Entries(ctx)
 	if err != nil {
 		return "", err
 	}
@@ -60,3 +76,28 @@ func (env *Environment) FileList(ctx context.Context, path string) (string, erro
 	}
 	return out.String(), nil
 }
+
+func (env *Environment) FileGrep(ctx context.Context, path, pattern, include string) (string, error) {
+	// Hack: use busybox to run `sed` since dagger doesn't have native file editing primitives.
+	args := []string{"/bin/grep", "-E", "--", pattern, include}
+
+	dir := env.container().Rootfs().Directory(path)
+	out, err := dag.Container().From(fileEditBaseImage).WithMountedDirectory("/mnt", dir).WithWorkdir("/mnt").WithExec(args).Stdout(ctx)
+	if err != nil {
+		return "", err
+	}
+	return out, nil
+}
+
+func (env *Environment) FileEdit(ctx context.Context, targetFile string, edits []string) error {
+	// Hack: use busybox to run `sed` since dagger doesn't have native file editing primitives.
+	args := []string{"/bin/sh", "-c", fmt.Sprintf("sed -ri'' -- %s /target && cp /target /new", strings.Join(edits, " "))}
+
+	newFile := dag.Container().From(fileEditBaseImage).WithMountedFile("/target", env.container().File(targetFile)).WithExec(args).File("/new")
+	err := env.apply(ctx, env.container().WithFile(targetFile, newFile))
+	if err != nil {
+		return fmt.Errorf("failed applying file edit, skipping git propagation: %w", err)
+	}
+	env.Notes.Add("Edit %s", targetFile)
+	return nil
+}

mcpserver/tools.go

@@ -115,9 +115,12 @@ func init() {
 
 		EnvironmentRunCmdTool,
 
-		EnvironmentFileReadTool,
 		EnvironmentFileListTool,
+		EnvironmentFileGlobTool,
+		EnvironmentFileGrepTool,
+		EnvironmentFileReadTool,
 		EnvironmentFileWriteTool,
+		EnvironmentFileEditTool,
 		EnvironmentFileDeleteTool,
 
 		EnvironmentAddServiceTool,
@@ -575,7 +578,7 @@ var EnvironmentFileReadTool = &Tool{
 
 var EnvironmentFileListTool = &Tool{
 	Definition: mcp.NewTool("environment_file_list",
-		mcp.WithDescription("List the contents of a directory"),
+		mcp.WithDescription("List files and directories in a given path. You can optionally provide an array of glob patterns to ignore with the ignore parameter. You should generally prefer the environment_file_glob and environment_file_grep tools, if you know which directories to search."),
 		mcp.WithString("explanation",
 			mcp.Description("One sentence explanation for why this directory is being listed."),
 		),
@@ -591,6 +594,63 @@ var EnvironmentFileListTool = &Tool{
 			mcp.Description("Path of the directory to list contents of, absolute or relative to the workdir"),
 			mcp.Required(),
 		),
+		mcp.WithArray("ignore",
+			mcp.Description("List of glob patterns to ignore"),
+			mcp.Items(map[string]any{"type": "string"}),
+		),
+	),
+	Handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		_, env, err := openEnvironment(ctx, request)
+		if err != nil {
+			return mcp.NewToolResultErrorFromErr("unable to open the environment", err), nil
+		}
+
+		path, err := request.RequireString("path")
+		if err != nil {
+			return nil, err
+		}
+
+		args := request.GetArguments()
+		v, ok := args["ignore"]
+		var ignore []string
+		if ok {
+			ignore, ok = v.([]string)
+			if !ok {
+				return nil, fmt.Errorf("`ignore` arugment expects an array of strings")
+			}
+		}
+
+		out, err := env.FileList(ctx, path, ignore)
+		if err != nil {
+			return mcp.NewToolResultErrorFromErr("failed to list directory", err), nil
+		}
+
+		return mcp.NewToolResultText(out), nil
+	},
+}
+
+var EnvironmentFileGlobTool = &Tool{
+	Definition: mcp.NewTool("environment_file_glob",
+		mcp.WithDescription("Fast file pattern matching tool.\nSupports glob syntax \"**/*.js\" or \"src/**/*.ts\".\nReturns matching file paths sorted by modification time."),
+		mcp.WithString("explanation",
+			mcp.Description("One sentence explanation for why file paths are being matched."),
+		),
+		mcp.WithString("environment_source",
+			mcp.Description("Absolute path to the source git repository for the environment."),
+			mcp.Required(),
+		),
+		mcp.WithString("environment_id",
+			mcp.Description("The ID of the environment for this command. Must call `environment_create` first."),
+			mcp.Required(),
+		),
+		mcp.WithString("path",
+			mcp.Description("Path of the directory to search in, absolute or relative to the workdir"),
+			mcp.Required(),
+		),
+		mcp.WithString("pattern",
+			mcp.Description("The glob pattern to match file paths against."),
+			mcp.Required(),
+		),
 	),
 	Handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 		_, env, err := openEnvironment(ctx, request)
@@ -603,7 +663,12 @@ var EnvironmentFileListTool = &Tool{
 			return nil, err
 		}
 
-		out, err := env.FileList(ctx, path)
+		pattern, err := request.RequireString("pattern")
+		if err != nil {
+			return nil, err
+		}
+
+		out, err := env.FileGlob(ctx, path, pattern)
 		if err != nil {
 			return mcp.NewToolResultErrorFromErr("failed to list directory", err), nil
 		}
@@ -612,9 +677,120 @@ var EnvironmentFileListTool = &Tool{
 	},
 }
 
+var EnvironmentFileGrepTool = &Tool{
+	Definition: mcp.NewTool("environment_file_grep",
+		mcp.WithDescription("Fast file content search using regular expressions.\nSupports full regex syntax (eg. \"log.*Error\", \"function\\s+\\w+\", etc.).\nReturns matching file paths sorted by modification time."),
+		mcp.WithString("explanation",
+			mcp.Description("One sentence explanation for why file paths are being matched."),
+		),
+		mcp.WithString("environment_source",
+			mcp.Description("Absolute path to the source git repository for the environment."),
+			mcp.Required(),
+		),
+		mcp.WithString("environment_id",
+			mcp.Description("The ID of the environment for this command. Must call `environment_create` first."),
+			mcp.Required(),
+		),
+		mcp.WithString("path",
+			mcp.Description("Path of the directory to search in, absolute or relative to the workdir"),
+			mcp.Required(),
+		),
+		mcp.WithString("pattern",
+			mcp.Description("The regular expression pattern to search for in file contents."),
+			mcp.Required(),
+		),
+		mcp.WithString("include",
+			mcp.Description("File pattern to include in the search (e.g. \"*.js\", \"*.{ts,tsx}\")."),
+		),
+	),
+	Handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		_, env, err := openEnvironment(ctx, request)
+		if err != nil {
+			return mcp.NewToolResultErrorFromErr("unable to open the environment", err), nil
+		}
+
+		path, err := request.RequireString("path")
+		if err != nil {
+			return nil, err
+		}
+
+		pattern, err := request.RequireString("pattern")
+		if err != nil {
+			return nil, err
+		}
+
+		include := request.GetString("include", "")
+
+		out, err := env.FileGrep(ctx, path, pattern, include)
+		if err != nil {
+			return mcp.NewToolResultErrorFromErr("failed to grep directory", err), nil
+		}
+
+		return mcp.NewToolResultText(out), nil
+	},
+}
+
+var EnvironmentFileEditTool = &Tool{
+	Definition: mcp.NewTool("environment_file_edit",
+		mcp.WithDescription("Efficiently edit the contents of a file."),
+		mcp.WithString("explanation",
+			mcp.Description("One sentence explanation for why this file is being edited."),
+		),
+		mcp.WithString("environment_source",
+			mcp.Description("Absolute path to the source git repository for the environment."),
+			mcp.Required(),
+		),
+		mcp.WithString("environment_id",
+			mcp.Description("The ID of the environment for this command. Must call `environment_create` first."),
+			mcp.Required(),
+		),
+		mcp.WithString("target_file",
+			mcp.Description("Path of the file to edit, absolute or relative to the workdir."),
+			mcp.Required(),
+		),
+		mcp.WithArray("edits",
+			mcp.Description("Array of sed search-replace operations to perform on the contents of target_file (e.g. \"s/old/new/g\").\nUses extended regex syntax."),
+			mcp.Items(map[string]any{"type": "string"}),
+			mcp.MinItems(1),
+			mcp.Required(),
+		),
+	),
+	Handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		repo, env, err := openEnvironment(ctx, request)
+		if err != nil {
+			return mcp.NewToolResultErrorFromErr("unable to open the environment", err), nil
+		}
+
+		targetFile, err := request.RequireString("target_file")
+		if err != nil {
+			return nil, err
+		}
+
+		args := request.GetArguments()
+		v, ok := args["edits"]
+		if !ok {
+			return nil, fmt.Errorf("could not find `edits` argument")
+		}
+		edits, ok := v.([]string)
+		if !ok {
+			return nil, fmt.Errorf("`edits` argument is expected to be a []string")
+		}
+
+		if err := env.FileEdit(ctx, targetFile, edits); err != nil {
+			return mcp.NewToolResultErrorFromErr("failed to edit file", err), nil
+		}
+
+		if err := repo.Update(ctx, env, request.GetString("explanation", "")); err != nil {
+			return mcp.NewToolResultErrorFromErr("unable to update the environment", err), nil
+		}
+
+		return mcp.NewToolResultText(fmt.Sprintf("file %s edited successfully and committed to container-use/ remote", targetFile)), nil
+	},
+}
+
 var EnvironmentFileWriteTool = &Tool{
 	Definition: mcp.NewTool("environment_file_write",
-		mcp.WithDescription("Write the contents of a file."),
+		mcp.WithDescription("Write the full contents of a file."),
 		mcp.WithString("explanation",
 			mcp.Description("One sentence explanation for why this file is being written."),
 		),
@@ -650,7 +826,7 @@ var EnvironmentFileWriteTool = &Tool{
 			return nil, err
 		}
 
-		if err := env.FileWrite(ctx, request.GetString("explanation", ""), targetFile, contents); err != nil {
+		if err := env.FileWrite(ctx, targetFile, contents); err != nil {
 			return mcp.NewToolResultErrorFromErr("failed to write file", err), nil
 		}
 
@@ -692,7 +868,7 @@ var EnvironmentFileDeleteTool = &Tool{
 			return nil, err
 		}
 
-		if err := env.FileDelete(ctx, request.GetString("explanation", ""), targetFile); err != nil {
+		if err := env.FileDelete(ctx, targetFile); err != nil {
 			return mcp.NewToolResultErrorFromErr("failed to delete file", err), nil
 		}