test: agregar tests completos para write_file, list_directory, append_file, delete_file

44 tests cubriendo todas las nuevas tools de archivos y la tool existente.

Tests por tool:
- write_file (11): crear archivo, ReadOnly, path fuera de allowed, contenido >1MB,
  crear dirs padre, sobreescribir, path traversal, symlink escape, deny-by-default
- list_directory (9): listado plano y recursivo, limite 500 entries, symlinks fuera
  de allowed, path traversal, deny-by-default, no-directorio, dir vacio
- append_file (11): append a existente, crear si no existe, ReadOnly, path fuera,
  limite 10MB total, path traversal, symlink escape, crear dirs padre
- delete_file (9): borrar archivo, rechazar directorios, ReadOnly, path fuera,
  path traversal, symlink escape, archivo inexistente, deny-by-default

Tambien corrige resolveReal() para resolver paths con multiples niveles de
directorios inexistentes (necesario para MkdirAll en write/append).

tools/file/list_test.go

@@ -0,0 +1,176 @@
+package file
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/enmanuel/agents/internal/config"
+)
+
+func TestListDirectory_ListsFilesAndDirs(t *testing.T) {
+	tmp := t.TempDir()
+	os.WriteFile(filepath.Join(tmp, "file1.txt"), []byte("hello"), 0644)
+	os.WriteFile(filepath.Join(tmp, "file2.txt"), []byte("world"), 0644)
+	os.Mkdir(filepath.Join(tmp, "subdir"), 0755)
+
+	cfg := config.FileOpsCfg{AllowedPaths: []string{tmp}}
+	tool := NewListDirectory(cfg)
+
+	result := tool.Exec(context.Background(), map[string]any{"path": tmp})
+	if result.Err != nil {
+		t.Fatalf("expected success, got: %v", result.Err)
+	}
+
+	if !strings.Contains(result.Output, "file1.txt") {
+		t.Fatalf("expected file1.txt in output, got: %s", result.Output)
+	}
+	if !strings.Contains(result.Output, "file2.txt") {
+		t.Fatalf("expected file2.txt in output, got: %s", result.Output)
+	}
+	if !strings.Contains(result.Output, "subdir") {
+		t.Fatalf("expected subdir in output, got: %s", result.Output)
+	}
+	if !strings.Contains(result.Output, "dir") {
+		t.Fatalf("expected 'dir' type in output, got: %s", result.Output)
+	}
+}
+
+func TestListDirectory_Recursive(t *testing.T) {
+	tmp := t.TempDir()
+	sub := filepath.Join(tmp, "sub")
+	os.Mkdir(sub, 0755)
+	os.WriteFile(filepath.Join(tmp, "root.txt"), []byte("r"), 0644)
+	os.WriteFile(filepath.Join(sub, "nested.txt"), []byte("n"), 0644)
+
+	cfg := config.FileOpsCfg{AllowedPaths: []string{tmp}}
+	tool := NewListDirectory(cfg)
+
+	result := tool.Exec(context.Background(), map[string]any{
+		"path":      tmp,
+		"recursive": true,
+	})
+	if result.Err != nil {
+		t.Fatalf("expected success, got: %v", result.Err)
+	}
+
+	if !strings.Contains(result.Output, "root.txt") {
+		t.Fatalf("expected root.txt in output, got: %s", result.Output)
+	}
+	if !strings.Contains(result.Output, filepath.Join("sub", "nested.txt")) {
+		t.Fatalf("expected sub/nested.txt in output, got: %s", result.Output)
+	}
+}
+
+func TestListDirectory_RespectsMaxEntries(t *testing.T) {
+	tmp := t.TempDir()
+	// Create more than maxListEntries files with unique names
+	for i := 0; i < maxListEntries+10; i++ {
+		name := fmt.Sprintf("file_%04d.txt", i)
+		os.WriteFile(filepath.Join(tmp, name), []byte("x"), 0644)
+	}
+
+	cfg := config.FileOpsCfg{AllowedPaths: []string{tmp}}
+	tool := NewListDirectory(cfg)
+
+	result := tool.Exec(context.Background(), map[string]any{"path": tmp})
+	if result.Err != nil {
+		t.Fatalf("expected success, got: %v", result.Err)
+	}
+
+	lines := strings.Split(result.Output, "\n")
+	// Should be maxListEntries + 1 (truncation message)
+	if len(lines) > maxListEntries+1 {
+		t.Fatalf("expected at most %d lines, got %d", maxListEntries+1, len(lines))
+	}
+	if !strings.Contains(result.Output, "truncated") {
+		t.Fatalf("expected truncation message, got: %s", result.Output[len(result.Output)-200:])
+	}
+}
+
+func TestListDirectory_SymlinkOutsideAllowedSkipped(t *testing.T) {
+	tmp := t.TempDir()
+	// Create a symlink pointing outside AllowedPaths
+	link := filepath.Join(tmp, "escape")
+	os.Symlink("/etc", link)
+
+	cfg := config.FileOpsCfg{AllowedPaths: []string{tmp}}
+	tool := NewListDirectory(cfg)
+
+	result := tool.Exec(context.Background(), map[string]any{"path": tmp})
+	if result.Err != nil {
+		t.Fatalf("expected success, got: %v", result.Err)
+	}
+
+	// The symlink should be skipped, not listed
+	if strings.Contains(result.Output, "escape") {
+		t.Fatalf("symlink pointing outside allowed paths should be skipped, got: %s", result.Output)
+	}
+}
+
+func TestListDirectory_PathTraversal(t *testing.T) {
+	tmp := t.TempDir()
+	cfg := config.FileOpsCfg{AllowedPaths: []string{tmp}}
+	tool := NewListDirectory(cfg)
+
+	result := tool.Exec(context.Background(), map[string]any{
+		"path": filepath.Join(tmp, "..", "..", "etc"),
+	})
+	if result.Err == nil {
+		t.Fatal("expected error for path traversal")
+	}
+}
+
+func TestListDirectory_DenyByDefault(t *testing.T) {
+	cfg := config.FileOpsCfg{AllowedPaths: []string{}}
+	tool := NewListDirectory(cfg)
+
+	result := tool.Exec(context.Background(), map[string]any{"path": "/tmp"})
+	if result.Err == nil {
+		t.Fatal("expected error when AllowedPaths is empty")
+	}
+}
+
+func TestListDirectory_NotADirectory(t *testing.T) {
+	tmp := t.TempDir()
+	f := filepath.Join(tmp, "file.txt")
+	os.WriteFile(f, []byte("hello"), 0644)
+
+	cfg := config.FileOpsCfg{AllowedPaths: []string{tmp}}
+	tool := NewListDirectory(cfg)
+
+	result := tool.Exec(context.Background(), map[string]any{"path": f})
+	if result.Err == nil {
+		t.Fatal("expected error for non-directory path")
+	}
+	if !strings.Contains(result.Err.Error(), "not a directory") {
+		t.Fatalf("expected 'not a directory' error, got: %v", result.Err)
+	}
+}
+
+func TestListDirectory_EmptyPath(t *testing.T) {
+	cfg := config.FileOpsCfg{AllowedPaths: []string{"/tmp"}}
+	tool := NewListDirectory(cfg)
+
+	result := tool.Exec(context.Background(), map[string]any{"path": ""})
+	if result.Err == nil {
+		t.Fatal("expected error for empty path")
+	}
+}
+
+func TestListDirectory_EmptyDirectory(t *testing.T) {
+	tmp := t.TempDir()
+	cfg := config.FileOpsCfg{AllowedPaths: []string{tmp}}
+	tool := NewListDirectory(cfg)
+
+	result := tool.Exec(context.Background(), map[string]any{"path": tmp})
+	if result.Err != nil {
+		t.Fatalf("expected success for empty dir, got: %v", result.Err)
+	}
+	if result.Output != "" {
+		t.Fatalf("expected empty output for empty dir, got: %q", result.Output)
+	}
+}