Add files using upload-large-folder tool

projects/ui/serena-new/src/interprompt/util/class_decorators.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+
+def singleton(cls: type[Any]) -> Any:
+    instance = None
+
+    def get_instance(*args: Any, **kwargs: Any) -> Any:
+        nonlocal instance
+        if instance is None:
+            instance = cls(*args, **kwargs)
+        return instance
+
+    return get_instance

projects/ui/serena-new/src/serena/config/context_mode.py

@@ -0,0 +1,232 @@
+"""
+Context and Mode configuration loader
+"""
+
+import os
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import TYPE_CHECKING, Self
+
+import yaml
+from sensai.util import logging
+from sensai.util.string import ToStringMixin
+
+from serena.config.serena_config import ToolInclusionDefinition
+from serena.constants import (
+    DEFAULT_CONTEXT,
+    DEFAULT_MODES,
+    INTERNAL_MODE_YAMLS_DIR,
+    SERENAS_OWN_CONTEXT_YAMLS_DIR,
+    SERENAS_OWN_MODE_YAMLS_DIR,
+    USER_CONTEXT_YAMLS_DIR,
+    USER_MODE_YAMLS_DIR,
+)
+
+if TYPE_CHECKING:
+    pass
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(kw_only=True)
+class SerenaAgentMode(ToolInclusionDefinition, ToStringMixin):
+    """Represents a mode of operation for the agent, typically read off a YAML file.
+    An agent can be in multiple modes simultaneously as long as they are not mutually exclusive.
+    The modes can be adjusted after the agent is running, for example for switching from planning to editing.
+    """
+
+    name: str
+    prompt: str
+    """
+    a Jinja2 template for the generation of the system prompt.
+    It is formatted by the agent (see SerenaAgent._format_prompt()).
+    """
+    description: str = ""
+
+    def _tostring_includes(self) -> list[str]:
+        return ["name"]
+
+    def print_overview(self) -> None:
+        """Print an overview of the mode."""
+        print(f"{self.name}:\n {self.description}")
+        if self.excluded_tools:
+            print(" excluded tools:\n  " + ", ".join(sorted(self.excluded_tools)))
+
+    @classmethod
+    def from_yaml(cls, yaml_path: str | Path) -> Self:
+        """Load a mode from a YAML file."""
+        with open(yaml_path, encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        name = data.pop("name", Path(yaml_path).stem)
+        return cls(name=name, **data)
+
+    @classmethod
+    def get_path(cls, name: str) -> str:
+        """Get the path to the YAML file for a mode."""
+        fname = f"{name}.yml"
+        custom_mode_path = os.path.join(USER_MODE_YAMLS_DIR, fname)
+        if os.path.exists(custom_mode_path):
+            return custom_mode_path
+
+        own_yaml_path = os.path.join(SERENAS_OWN_MODE_YAMLS_DIR, fname)
+        if not os.path.exists(own_yaml_path):
+            raise FileNotFoundError(
+                f"Mode {name} not found in {USER_MODE_YAMLS_DIR} or in {SERENAS_OWN_MODE_YAMLS_DIR}."
+                f"Available modes:\n{cls.list_registered_mode_names()}"
+            )
+        return own_yaml_path
+
+    @classmethod
+    def from_name(cls, name: str) -> Self:
+        """Load a registered Serena mode."""
+        mode_path = cls.get_path(name)
+        return cls.from_yaml(mode_path)
+
+    @classmethod
+    def from_name_internal(cls, name: str) -> Self:
+        """Loads an internal Serena mode"""
+        yaml_path = os.path.join(INTERNAL_MODE_YAMLS_DIR, f"{name}.yml")
+        if not os.path.exists(yaml_path):
+            raise FileNotFoundError(f"Internal mode '{name}' not found in {INTERNAL_MODE_YAMLS_DIR}")
+        return cls.from_yaml(yaml_path)
+
+    @classmethod
+    def list_registered_mode_names(cls, include_user_modes: bool = True) -> list[str]:
+        """Names of all registered modes (from the corresponding YAML files in the serena repo)."""
+        modes = [f.stem for f in Path(SERENAS_OWN_MODE_YAMLS_DIR).glob("*.yml") if f.name != "mode.template.yml"]
+        if include_user_modes:
+            modes += cls.list_custom_mode_names()
+        return sorted(set(modes))
+
+    @classmethod
+    def list_custom_mode_names(cls) -> list[str]:
+        """Names of all custom modes defined by the user."""
+        return [f.stem for f in Path(USER_MODE_YAMLS_DIR).glob("*.yml")]
+
+    @classmethod
+    def load_default_modes(cls) -> list[Self]:
+        """Load the default modes (interactive and editing)."""
+        return [cls.from_name(mode) for mode in DEFAULT_MODES]
+
+    @classmethod
+    def load(cls, name_or_path: str | Path) -> Self:
+        if str(name_or_path).endswith(".yml"):
+            return cls.from_yaml(name_or_path)
+        return cls.from_name(str(name_or_path))
+
+
+@dataclass(kw_only=True)
+class SerenaAgentContext(ToolInclusionDefinition, ToStringMixin):
+    """Represents a context where the agent is operating (an IDE, a chat, etc.), typically read off a YAML file.
+    An agent can only be in a single context at a time.
+    The contexts cannot be changed after the agent is running.
+    """
+
+    name: str
+    prompt: str
+    """
+    a Jinja2 template for the generation of the system prompt.
+    It is formatted by the agent (see SerenaAgent._format_prompt()).
+    """
+    description: str = ""
+    tool_description_overrides: dict[str, str] = field(default_factory=dict)
+    """Maps tool names to custom descriptions, default descriptions are extracted from the tool docstrings."""
+
+    def _tostring_includes(self) -> list[str]:
+        return ["name"]
+
+    @classmethod
+    def from_yaml(cls, yaml_path: str | Path) -> Self:
+        """Load a context from a YAML file."""
+        with open(yaml_path, encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        name = data.pop("name", Path(yaml_path).stem)
+        # Ensure backwards compatibility for tool_description_overrides
+        if "tool_description_overrides" not in data:
+            data["tool_description_overrides"] = {}
+        return cls(name=name, **data)
+
+    @classmethod
+    def get_path(cls, name: str) -> str:
+        """Get the path to the YAML file for a context."""
+        fname = f"{name}.yml"
+        custom_context_path = os.path.join(USER_CONTEXT_YAMLS_DIR, fname)
+        if os.path.exists(custom_context_path):
+            return custom_context_path
+
+        own_yaml_path = os.path.join(SERENAS_OWN_CONTEXT_YAMLS_DIR, fname)
+        if not os.path.exists(own_yaml_path):
+            raise FileNotFoundError(
+                f"Context {name} not found in {USER_CONTEXT_YAMLS_DIR} or in {SERENAS_OWN_CONTEXT_YAMLS_DIR}."
+                f"Available contexts:\n{cls.list_registered_context_names()}"
+            )
+        return own_yaml_path
+
+    @classmethod
+    def from_name(cls, name: str) -> Self:
+        """Load a registered Serena context."""
+        context_path = cls.get_path(name)
+        return cls.from_yaml(context_path)
+
+    @classmethod
+    def load(cls, name_or_path: str | Path) -> Self:
+        if str(name_or_path).endswith(".yml"):
+            return cls.from_yaml(name_or_path)
+        return cls.from_name(str(name_or_path))
+
+    @classmethod
+    def list_registered_context_names(cls, include_user_contexts: bool = True) -> list[str]:
+        """Names of all registered contexts (from the corresponding YAML files in the serena repo)."""
+        contexts = [f.stem for f in Path(SERENAS_OWN_CONTEXT_YAMLS_DIR).glob("*.yml")]
+        if include_user_contexts:
+            contexts += cls.list_custom_context_names()
+        return sorted(set(contexts))
+
+    @classmethod
+    def list_custom_context_names(cls) -> list[str]:
+        """Names of all custom contexts defined by the user."""
+        return [f.stem for f in Path(USER_CONTEXT_YAMLS_DIR).glob("*.yml")]
+
+    @classmethod
+    def load_default(cls) -> Self:
+        """Load the default context."""
+        return cls.from_name(DEFAULT_CONTEXT)
+
+    def print_overview(self) -> None:
+        """Print an overview of the mode."""
+        print(f"{self.name}:\n {self.description}")
+        if self.excluded_tools:
+            print(" excluded tools:\n  " + ", ".join(sorted(self.excluded_tools)))
+
+
+class RegisteredContext(Enum):
+    """A registered context."""
+
+    IDE_ASSISTANT = "ide-assistant"
+    """For Serena running within an assistant that already has basic tools, like Claude Code, Cline, Cursor, etc."""
+    DESKTOP_APP = "desktop-app"
+    """For Serena running within Claude Desktop or a similar app which does not have built-in tools for code editing."""
+    AGENT = "agent"
+    """For Serena running as a standalone agent, e.g. through agno."""
+
+    def load(self) -> SerenaAgentContext:
+        """Load the context."""
+        return SerenaAgentContext.from_name(self.value)
+
+
+class RegisteredMode(Enum):
+    """A registered mode."""
+
+    INTERACTIVE = "interactive"
+    """Interactive mode, for multi-turn interactions."""
+    EDITING = "editing"
+    """Editing tools are activated."""
+    PLANNING = "planning"
+    """Editing tools are deactivated."""
+    ONE_SHOT = "one-shot"
+    """Non-interactive mode, where the goal is to finish a task autonomously."""
+
+    def load(self) -> SerenaAgentMode:
+        """Load the mode."""
+        return SerenaAgentMode.from_name(self.value)

projects/ui/serena-new/src/serena/config/serena_config.py

@@ -0,0 +1,575 @@
+"""
+The Serena Model Context Protocol (MCP) Server
+"""
+
+import os
+import shutil
+from collections.abc import Iterable
+from copy import deepcopy
+from dataclasses import dataclass, field
+from datetime import datetime
+from functools import cached_property
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional, Self, TypeVar
+
+import yaml
+from ruamel.yaml.comments import CommentedMap
+from sensai.util import logging
+from sensai.util.logging import LogTime, datetime_tag
+from sensai.util.string import ToStringMixin
+
+from serena.constants import (
+    DEFAULT_ENCODING,
+    PROJECT_TEMPLATE_FILE,
+    REPO_ROOT,
+    SERENA_CONFIG_TEMPLATE_FILE,
+    SERENA_MANAGED_DIR_IN_HOME,
+    SERENA_MANAGED_DIR_NAME,
+)
+from serena.util.general import load_yaml, save_yaml
+from serena.util.inspection import determine_programming_language_composition
+from solidlsp.ls_config import Language
+
+from ..analytics import RegisteredTokenCountEstimator
+from ..util.class_decorators import singleton
+
+if TYPE_CHECKING:
+    from ..project import Project
+
+log = logging.getLogger(__name__)
+T = TypeVar("T")
+DEFAULT_TOOL_TIMEOUT: float = 240
+
+
+@singleton
+class SerenaPaths:
+    """
+    Provides paths to various Serena-related directories and files.
+    """
+
+    def __init__(self) -> None:
+        self.user_config_dir: str = SERENA_MANAGED_DIR_IN_HOME
+        """
+        the path to the user's Serena configuration directory, which is typically ~/.serena
+        """
+
+    def get_next_log_file_path(self, prefix: str) -> str:
+        """
+        :param prefix: the filename prefix indicating the type of the log file
+        :return: the full path to the log file to use
+        """
+        log_dir = os.path.join(self.user_config_dir, "logs", datetime.now().strftime("%Y-%m-%d"))
+        os.makedirs(log_dir, exist_ok=True)
+        return os.path.join(log_dir, prefix + "_" + datetime_tag() + ".txt")
+
+    # TODO: Paths from constants.py should be moved here
+
+
+class ToolSet:
+    def __init__(self, tool_names: set[str]) -> None:
+        self._tool_names = tool_names
+
+    @classmethod
+    def default(cls) -> "ToolSet":
+        """
+        :return: the default tool set, which contains all tools that are enabled by default
+        """
+        from serena.tools import ToolRegistry
+
+        return cls(set(ToolRegistry().get_tool_names_default_enabled()))
+
+    def apply(self, *tool_inclusion_definitions: "ToolInclusionDefinition") -> "ToolSet":
+        """
+        :param tool_inclusion_definitions: the definitions to apply
+        :return: a new tool set with the definitions applied
+        """
+        from serena.tools import ToolRegistry
+
+        registry = ToolRegistry()
+        tool_names = set(self._tool_names)
+        for definition in tool_inclusion_definitions:
+            included_tools = []
+            excluded_tools = []
+            for included_tool in definition.included_optional_tools:
+                if not registry.is_valid_tool_name(included_tool):
+                    raise ValueError(f"Invalid tool name '{included_tool}' provided for inclusion")
+                if included_tool not in tool_names:
+                    tool_names.add(included_tool)
+                    included_tools.append(included_tool)
+            for excluded_tool in definition.excluded_tools:
+                if not registry.is_valid_tool_name(excluded_tool):
+                    raise ValueError(f"Invalid tool name '{excluded_tool}' provided for exclusion")
+                if excluded_tool in self._tool_names:
+                    tool_names.remove(excluded_tool)
+                    excluded_tools.append(excluded_tool)
+            if included_tools:
+                log.info(f"{definition} included {len(included_tools)} tools: {', '.join(included_tools)}")
+            if excluded_tools:
+                log.info(f"{definition} excluded {len(excluded_tools)} tools: {', '.join(excluded_tools)}")
+        return ToolSet(tool_names)
+
+    def without_editing_tools(self) -> "ToolSet":
+        """
+        :return: a new tool set that excludes all tools that can edit
+        """
+        from serena.tools import ToolRegistry
+
+        registry = ToolRegistry()
+        tool_names = set(self._tool_names)
+        for tool_name in self._tool_names:
+            if registry.get_tool_class_by_name(tool_name).can_edit():
+                tool_names.remove(tool_name)
+        return ToolSet(tool_names)
+
+    def get_tool_names(self) -> set[str]:
+        """
+        Returns the names of the tools that are currently included in the tool set.
+        """
+        return self._tool_names
+
+    def includes_name(self, tool_name: str) -> bool:
+        return tool_name in self._tool_names
+
+
+@dataclass
+class ToolInclusionDefinition:
+    excluded_tools: Iterable[str] = ()
+    included_optional_tools: Iterable[str] = ()
+
+
+class SerenaConfigError(Exception):
+    pass
+
+
+def get_serena_managed_in_project_dir(project_root: str | Path) -> str:
+    return os.path.join(project_root, SERENA_MANAGED_DIR_NAME)
+
+
+def is_running_in_docker() -> bool:
+    """Check if we're running inside a Docker container."""
+    # Check for Docker-specific files
+    if os.path.exists("/.dockerenv"):
+        return True
+    # Check cgroup for docker references
+    try:
+        with open("/proc/self/cgroup") as f:
+            return "docker" in f.read()
+    except FileNotFoundError:
+        return False
+
+
+@dataclass(kw_only=True)
+class ProjectConfig(ToolInclusionDefinition, ToStringMixin):
+    project_name: str
+    language: Language
+    ignored_paths: list[str] = field(default_factory=list)
+    read_only: bool = False
+    ignore_all_files_in_gitignore: bool = True
+    initial_prompt: str = ""
+    encoding: str = DEFAULT_ENCODING
+
+    SERENA_DEFAULT_PROJECT_FILE = "project.yml"
+
+    def _tostring_includes(self) -> list[str]:
+        return ["project_name"]
+
+    @classmethod
+    def autogenerate(
+        cls, project_root: str | Path, project_name: str | None = None, project_language: Language | None = None, save_to_disk: bool = True
+    ) -> Self:
+        """
+        Autogenerate a project configuration for a given project root.
+
+        :param project_root: the path to the project root
+        :param project_name: the name of the project; if None, the name of the project will be the name of the directory
+            containing the project
+        :param project_language: the programming language of the project; if None, it will be determined automatically
+        :param save_to_disk: whether to save the project configuration to disk
+        :return: the project configuration
+        """
+        project_root = Path(project_root).resolve()
+        if not project_root.exists():
+            raise FileNotFoundError(f"Project root not found: {project_root}")
+        with LogTime("Project configuration auto-generation", logger=log):
+            project_name = project_name or project_root.name
+            if project_language is None:
+                language_composition = determine_programming_language_composition(str(project_root))
+                if len(language_composition) == 0:
+                    raise ValueError(
+                        f"No source files found in {project_root}\n\n"
+                        f"To use Serena with this project, you need to either:\n"
+                        f"1. Add source files in one of the supported languages (Python, JavaScript/TypeScript, Java, C#, Rust, Go, Ruby, C++, PHP, Swift, Elixir, Terraform, Bash)\n"
+                        f"2. Create a project configuration file manually at:\n"
+                        f"   {os.path.join(project_root, cls.rel_path_to_project_yml())}\n\n"
+                        f"Example project.yml:\n"
+                        f"  project_name: {project_name}\n"
+                        f"  language: python  # or typescript, java, csharp, rust, go, ruby, cpp, php, swift, elixir, terraform, bash\n"
+                    )
+                # find the language with the highest percentage
+                dominant_language = max(language_composition.keys(), key=lambda lang: language_composition[lang])
+            else:
+                dominant_language = project_language.value
+            config_with_comments = load_yaml(PROJECT_TEMPLATE_FILE, preserve_comments=True)
+            config_with_comments["project_name"] = project_name
+            config_with_comments["language"] = dominant_language
+            if save_to_disk:
+                save_yaml(str(project_root / cls.rel_path_to_project_yml()), config_with_comments, preserve_comments=True)
+            return cls._from_dict(config_with_comments)
+
+    @classmethod
+    def rel_path_to_project_yml(cls) -> str:
+        return os.path.join(SERENA_MANAGED_DIR_NAME, cls.SERENA_DEFAULT_PROJECT_FILE)
+
+    @classmethod
+    def _from_dict(cls, data: dict[str, Any]) -> Self:
+        """
+        Create a ProjectConfig instance from a configuration dictionary
+        """
+        language_str = data["language"].lower()
+        project_name = data["project_name"]
+        # backwards compatibility
+        if language_str == "javascript":
+            log.warning(f"Found deprecated project language `javascript` in project {project_name}, please change to `typescript`")
+            language_str = "typescript"
+        try:
+            language = Language(language_str)
+        except ValueError as e:
+            raise ValueError(f"Invalid language: {data['language']}.\nValid languages are: {[l.value for l in Language]}") from e
+        return cls(
+            project_name=project_name,
+            language=language,
+            ignored_paths=data.get("ignored_paths", []),
+            excluded_tools=data.get("excluded_tools", []),
+            included_optional_tools=data.get("included_optional_tools", []),
+            read_only=data.get("read_only", False),
+            ignore_all_files_in_gitignore=data.get("ignore_all_files_in_gitignore", True),
+            initial_prompt=data.get("initial_prompt", ""),
+            encoding=data.get("encoding", DEFAULT_ENCODING),
+        )
+
+    @classmethod
+    def load(cls, project_root: Path | str, autogenerate: bool = False) -> Self:
+        """
+        Load a ProjectConfig instance from the path to the project root.
+        """
+        project_root = Path(project_root)
+        yaml_path = project_root / cls.rel_path_to_project_yml()
+        if not yaml_path.exists():
+            if autogenerate:
+                return cls.autogenerate(project_root)
+            else:
+                raise FileNotFoundError(f"Project configuration file not found: {yaml_path}")
+        with open(yaml_path, encoding="utf-8") as f:
+            yaml_data = yaml.safe_load(f)
+        if "project_name" not in yaml_data:
+            yaml_data["project_name"] = project_root.name
+        return cls._from_dict(yaml_data)
+
+
+class RegisteredProject(ToStringMixin):
+    def __init__(self, project_root: str, project_config: "ProjectConfig", project_instance: Optional["Project"] = None) -> None:
+        """
+        Represents a registered project in the Serena configuration.
+
+        :param project_root: the root directory of the project
+        :param project_config: the configuration of the project
+        """
+        self.project_root = Path(project_root).resolve()
+        self.project_config = project_config
+        self._project_instance = project_instance
+
+    def _tostring_exclude_private(self) -> bool:
+        return True
+
+    @property
+    def project_name(self) -> str:
+        return self.project_config.project_name
+
+    @classmethod
+    def from_project_instance(cls, project_instance: "Project") -> "RegisteredProject":
+        return RegisteredProject(
+            project_root=project_instance.project_root,
+            project_config=project_instance.project_config,
+            project_instance=project_instance,
+        )
+
+    def matches_root_path(self, path: str | Path) -> bool:
+        """
+        Check if the given path matches the project root path.
+
+        :param path: the path to check
+        :return: True if the path matches the project root, False otherwise
+        """
+        return self.project_root == Path(path).resolve()
+
+    def get_project_instance(self) -> "Project":
+        """
+        Returns the project instance for this registered project, loading it if necessary.
+        """
+        if self._project_instance is None:
+            from ..project import Project
+
+            with LogTime(f"Loading project instance for {self}", logger=log):
+                self._project_instance = Project(project_root=str(self.project_root), project_config=self.project_config)
+        return self._project_instance
+
+
+@dataclass(kw_only=True)
+class SerenaConfig(ToolInclusionDefinition, ToStringMixin):
+    """
+    Holds the Serena agent configuration, which is typically loaded from a YAML configuration file
+    (when instantiated via :method:`from_config_file`), which is updated when projects are added or removed.
+    For testing purposes, it can also be instantiated directly with the desired parameters.
+    """
+
+    projects: list[RegisteredProject] = field(default_factory=list)
+    gui_log_window_enabled: bool = False
+    log_level: int = logging.INFO
+    trace_lsp_communication: bool = False
+    web_dashboard: bool = True
+    web_dashboard_open_on_launch: bool = True
+    tool_timeout: float = DEFAULT_TOOL_TIMEOUT
+    loaded_commented_yaml: CommentedMap | None = None
+    config_file_path: str | None = None
+    """
+    the path to the configuration file to which updates of the configuration shall be saved;
+    if None, the configuration is not saved to disk
+    """
+    jetbrains: bool = False
+    """
+    whether to apply JetBrains mode
+    """
+    record_tool_usage_stats: bool = False
+    """Whether to record tool usage statistics, they will be shown in the web dashboard if recording is active. 
+    """
+    token_count_estimator: str = RegisteredTokenCountEstimator.TIKTOKEN_GPT4O.name
+    """Only relevant if `record_tool_usage` is True; the name of the token count estimator to use for tool usage statistics.
+    See the `RegisteredTokenCountEstimator` enum for available options.
+    
+    Note: some token estimators (like tiktoken) may require downloading data files
+    on the first run, which can take some time and require internet access. Others, like the Anthropic ones, may require an API key
+    and rate limits may apply.
+    """
+    default_max_tool_answer_chars: int = 150_000
+    """Used as default for tools where the apply method has a default maximal answer length.
+    Even though the value of the max_answer_chars can be changed when calling the tool, it may make sense to adjust this default 
+    through the global configuration.
+    """
+
+    CONFIG_FILE = "serena_config.yml"
+    CONFIG_FILE_DOCKER = "serena_config.docker.yml"  # Docker-specific config file; auto-generated if missing, mounted via docker-compose for user customization
+
+    def _tostring_includes(self) -> list[str]:
+        return ["config_file_path"]
+
+    @classmethod
+    def generate_config_file(cls, config_file_path: str) -> None:
+        """
+        Generates a Serena configuration file at the specified path from the template file.
+
+        :param config_file_path: the path where the configuration file should be generated
+        """
+        log.info(f"Auto-generating Serena configuration file in {config_file_path}")
+        loaded_commented_yaml = load_yaml(SERENA_CONFIG_TEMPLATE_FILE, preserve_comments=True)
+        save_yaml(config_file_path, loaded_commented_yaml, preserve_comments=True)
+
+    @classmethod
+    def _determine_config_file_path(cls) -> str:
+        """
+        :return: the location where the Serena configuration file is stored/should be stored
+        """
+        if is_running_in_docker():
+            return os.path.join(REPO_ROOT, cls.CONFIG_FILE_DOCKER)
+        else:
+            config_path = os.path.join(SERENA_MANAGED_DIR_IN_HOME, cls.CONFIG_FILE)
+
+            # if the config file does not exist, check if we can migrate it from the old location
+            if not os.path.exists(config_path):
+                old_config_path = os.path.join(REPO_ROOT, cls.CONFIG_FILE)
+                if os.path.exists(old_config_path):
+                    log.info(f"Moving Serena configuration file from {old_config_path} to {config_path}")
+                    os.makedirs(os.path.dirname(config_path), exist_ok=True)
+                    shutil.move(old_config_path, config_path)
+
+            return config_path
+
+    @classmethod
+    def from_config_file(cls, generate_if_missing: bool = True) -> "SerenaConfig":
+        """
+        Static constructor to create SerenaConfig from the configuration file
+        """
+        config_file_path = cls._determine_config_file_path()
+
+        # create the configuration file from the template if necessary
+        if not os.path.exists(config_file_path):
+            if not generate_if_missing:
+                raise FileNotFoundError(f"Serena configuration file not found: {config_file_path}")
+            log.info(f"Serena configuration file not found at {config_file_path}, autogenerating...")
+            cls.generate_config_file(config_file_path)
+
+        # load the configuration
+        log.info(f"Loading Serena configuration from {config_file_path}")
+        try:
+            loaded_commented_yaml = load_yaml(config_file_path, preserve_comments=True)
+        except Exception as e:
+            raise ValueError(f"Error loading Serena configuration from {config_file_path}: {e}") from e
+
+        # create the configuration instance
+        instance = cls(loaded_commented_yaml=loaded_commented_yaml, config_file_path=config_file_path)
+
+        # read projects
+        if "projects" not in loaded_commented_yaml:
+            raise SerenaConfigError("`projects` key not found in Serena configuration. Please update your `serena_config.yml` file.")
+
+        # load list of known projects
+        instance.projects = []
+        num_project_migrations = 0
+        for path in loaded_commented_yaml["projects"]:
+            path = Path(path).resolve()
+            if not path.exists() or (path.is_dir() and not (path / ProjectConfig.rel_path_to_project_yml()).exists()):
+                log.warning(f"Project path {path} does not exist or does not contain a project configuration file, skipping.")
+                continue
+            if path.is_file():
+                path = cls._migrate_out_of_project_config_file(path)
+                if path is None:
+                    continue
+                num_project_migrations += 1
+            project_config = ProjectConfig.load(path)
+            project = RegisteredProject(
+                project_root=str(path),
+                project_config=project_config,
+            )
+            instance.projects.append(project)
+
+        # set other configuration parameters
+        if is_running_in_docker():
+            instance.gui_log_window_enabled = False  # not supported in Docker
+        else:
+            instance.gui_log_window_enabled = loaded_commented_yaml.get("gui_log_window", False)
+        instance.log_level = loaded_commented_yaml.get("log_level", loaded_commented_yaml.get("gui_log_level", logging.INFO))
+        instance.web_dashboard = loaded_commented_yaml.get("web_dashboard", True)
+        instance.web_dashboard_open_on_launch = loaded_commented_yaml.get("web_dashboard_open_on_launch", True)
+        instance.tool_timeout = loaded_commented_yaml.get("tool_timeout", DEFAULT_TOOL_TIMEOUT)
+        instance.trace_lsp_communication = loaded_commented_yaml.get("trace_lsp_communication", False)
+        instance.excluded_tools = loaded_commented_yaml.get("excluded_tools", [])
+        instance.included_optional_tools = loaded_commented_yaml.get("included_optional_tools", [])
+        instance.jetbrains = loaded_commented_yaml.get("jetbrains", False)
+        instance.record_tool_usage_stats = loaded_commented_yaml.get("record_tool_usage_stats", False)
+        instance.token_count_estimator = loaded_commented_yaml.get(
+            "token_count_estimator", RegisteredTokenCountEstimator.TIKTOKEN_GPT4O.name
+        )
+        instance.default_max_tool_answer_chars = loaded_commented_yaml.get("default_max_tool_answer_chars", 150_000)
+
+        # re-save the configuration file if any migrations were performed
+        if num_project_migrations > 0:
+            log.info(
+                f"Migrated {num_project_migrations} project configurations from legacy format to in-project configuration; re-saving configuration"
+            )
+            instance.save()
+
+        return instance
+
+    @classmethod
+    def _migrate_out_of_project_config_file(cls, path: Path) -> Path | None:
+        """
+        Migrates a legacy project configuration file (which is a YAML file containing the project root) to the
+        in-project configuration file (project.yml) inside the project root directory.
+
+        :param path: the path to the legacy project configuration file
+        :return: the project root path if the migration was successful, None otherwise.
+        """
+        log.info(f"Found legacy project configuration file {path}, migrating to in-project configuration.")
+        try:
+            with open(path, encoding="utf-8") as f:
+                project_config_data = yaml.safe_load(f)
+            if "project_name" not in project_config_data:
+                project_name = path.stem
+                with open(path, "a", encoding="utf-8") as f:
+                    f.write(f"\nproject_name: {project_name}")
+            project_root = project_config_data["project_root"]
+            shutil.move(str(path), str(Path(project_root) / ProjectConfig.rel_path_to_project_yml()))
+            return Path(project_root).resolve()
+        except Exception as e:
+            log.error(f"Error migrating configuration file: {e}")
+            return None
+
+    @cached_property
+    def project_paths(self) -> list[str]:
+        return sorted(str(project.project_root) for project in self.projects)
+
+    @cached_property
+    def project_names(self) -> list[str]:
+        return sorted(project.project_config.project_name for project in self.projects)
+
+    def get_project(self, project_root_or_name: str) -> Optional["Project"]:
+        # look for project by name
+        project_candidates = []
+        for project in self.projects:
+            if project.project_config.project_name == project_root_or_name:
+                project_candidates.append(project)
+        if len(project_candidates) == 1:
+            return project_candidates[0].get_project_instance()
+        elif len(project_candidates) > 1:
+            raise ValueError(
+                f"Multiple projects found with name '{project_root_or_name}'. Please activate it by location instead. "
+                f"Locations: {[p.project_root for p in project_candidates]}"
+            )
+        # no project found by name; check if it's a path
+        if os.path.isdir(project_root_or_name):
+            for project in self.projects:
+                if project.matches_root_path(project_root_or_name):
+                    return project.get_project_instance()
+        return None
+
+    def add_project_from_path(self, project_root: Path | str) -> "Project":
+        """
+        Add a project to the Serena configuration from a given path. Will raise a FileExistsError if a
+        project already exists at the path.
+
+        :param project_root: the path to the project to add
+        :return: the project that was added
+        """
+        from ..project import Project
+
+        project_root = Path(project_root).resolve()
+        if not project_root.exists():
+            raise FileNotFoundError(f"Error: Path does not exist: {project_root}")
+        if not project_root.is_dir():
+            raise FileNotFoundError(f"Error: Path is not a directory: {project_root}")
+
+        for already_registered_project in self.projects:
+            if str(already_registered_project.project_root) == str(project_root):
+                raise FileExistsError(
+                    f"Project with path {project_root} was already added with name '{already_registered_project.project_name}'."
+                )
+
+        project_config = ProjectConfig.load(project_root, autogenerate=True)
+
+        new_project = Project(project_root=str(project_root), project_config=project_config, is_newly_created=True)
+        self.projects.append(RegisteredProject.from_project_instance(new_project))
+        self.save()
+
+        return new_project
+
+    def remove_project(self, project_name: str) -> None:
+        # find the index of the project with the desired name and remove it
+        for i, project in enumerate(list(self.projects)):
+            if project.project_name == project_name:
+                del self.projects[i]
+                break
+        else:
+            raise ValueError(f"Project '{project_name}' not found in Serena configuration; valid project names: {self.project_names}")
+        self.save()
+
+    def save(self) -> None:
+        """
+        Saves the configuration to the file from which it was loaded (if any)
+        """
+        if self.config_file_path is None:
+            return
+        assert self.loaded_commented_yaml is not None, "Cannot save configuration without loaded YAML"
+        loaded_original_yaml = deepcopy(self.loaded_commented_yaml)
+        # projects are unique absolute paths
+        # we also canonicalize them before saving
+        loaded_original_yaml["projects"] = sorted({str(project.project_root) for project in self.projects})
+        save_yaml(self.config_file_path, loaded_original_yaml, preserve_comments=True)

projects/ui/serena-new/src/serena/generated/generated_prompt_factory.py

@@ -0,0 +1,38 @@
+# ruff: noqa
+# black: skip
+# mypy: ignore-errors
+
+# NOTE: This module is auto-generated from interprompt.autogenerate_prompt_factory_module, do not edit manually!
+
+from interprompt.multilang_prompt import PromptList
+from interprompt.prompt_factory import PromptFactoryBase
+from typing import Any
+
+
+class PromptFactory(PromptFactoryBase):
+    """
+    A class for retrieving and rendering prompt templates and prompt lists.
+    """
+
+    def create_onboarding_prompt(self, *, system: Any) -> str:
+        return self._render_prompt("onboarding_prompt", locals())
+
+    def create_think_about_collected_information(self) -> str:
+        return self._render_prompt("think_about_collected_information", locals())
+
+    def create_think_about_task_adherence(self) -> str:
+        return self._render_prompt("think_about_task_adherence", locals())
+
+    def create_think_about_whether_you_are_done(self) -> str:
+        return self._render_prompt("think_about_whether_you_are_done", locals())
+
+    def create_summarize_changes(self) -> str:
+        return self._render_prompt("summarize_changes", locals())
+
+    def create_prepare_for_new_conversation(self) -> str:
+        return self._render_prompt("prepare_for_new_conversation", locals())
+
+    def create_system_prompt(
+        self, *, available_markers: Any, available_tools: Any, context_system_prompt: Any, mode_system_prompts: Any
+    ) -> str:
+        return self._render_prompt("system_prompt", locals())

projects/ui/serena-new/src/serena/resources/project.template.yml

@@ -0,0 +1,68 @@
+# language of the project (csharp, python, rust, java, typescript, go, cpp, or ruby)
+#  * For C, use cpp
+#  * For JavaScript, use typescript
+# Special requirements:
+#  * csharp: Requires the presence of a .sln file in the project folder.
+language: python
+
+# whether to use the project's gitignore file to ignore files
+# Added on 2025-04-07
+ignore_all_files_in_gitignore: true
+# list of additional paths to ignore
+# same syntax as gitignore, so you can use * and **
+# Was previously called `ignored_dirs`, please update your config if you are using that.
+# Added (renamed) on 2025-04-07
+ignored_paths: []
+
+# whether the project is in read-only mode
+# If set to true, all editing tools will be disabled and attempts to use them will result in an error
+# Added on 2025-04-18
+read_only: false
+
+
+# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
+# Below is the complete list of tools for convenience.
+# To make sure you have the latest list of tools, and to view their descriptions, 
+# execute `uv run scripts/print_tool_overview.py`.
+#
+#  * `activate_project`: Activates a project by name.
+#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
+#  * `create_text_file`: Creates/overwrites a file in the project directory.
+#  * `delete_lines`: Deletes a range of lines within a file.
+#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
+#  * `execute_shell_command`: Executes a shell command.
+#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
+#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
+#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file.
+#  * `initial_instructions`: Gets the initial instructions for the current project.
+#     Should only be used in settings where the system prompt cannot be set,
+#     e.g. in clients you have no control over, like Claude Desktop.
+#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
+#  * `insert_at_line`: Inserts content at a given line in a file.
+#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
+#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
+#  * `list_memories`: Lists memories in Serena's project-specific memory store.
+#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
+#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
+#  * `read_file`: Reads a file within the project directory.
+#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
+#  * `remove_project`: Removes a project from the Serena configuration.
+#  * `replace_lines`: Replaces a range of lines within a file with new content.
+#  * `replace_symbol_body`: Replaces the full definition of a symbol.
+#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
+#  * `search_for_pattern`: Performs a search for a pattern in the project.
+#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
+#  * `switch_modes`: Activates modes by providing a list of their names
+#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
+#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
+#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
+#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
+excluded_tools: []
+
+# initial prompt for the project. It will always be given to the LLM upon activating the project
+# (contrary to the memories, which are loaded on demand).
+initial_prompt: ""
+
+project_name: "project_name"

projects/ui/serena-new/src/serena/resources/serena_config.template.yml

@@ -0,0 +1,77 @@
+gui_log_window: False
+# whether to open a graphical window with Serena's logs.
+# This is mainly supported on Windows and (partly) on Linux; not available on macOS.
+# If you want to see the logs in a web browser, use the `web_dashboard` option instead.
+# Limitations: doesn't seem to work with the community version of Claude Desktop for Linux
+# Might also cause problems with some MCP clients - if you have any issues, try disabling this
+
+# Being able to inspect logs is useful both for troubleshooting and for monitoring the tool calls,
+# especially when using the agno playground, since the tool calls are not always shown,
+# and the input params are never shown in the agno UI.
+# When used as MCP server for Claude Desktop, the logs are primarily for troubleshooting.
+# Note: unfortunately, the various entities starting the Serena server or agent do so in
+# mysterious ways, often starting multiple instances of the process without shutting down
+# previous instances. This can lead to multiple log windows being opened, and only the last
+# window being updated. Since we can't control how agno or Claude Desktop start Serena,
+# we have to live with this limitation for now.
+
+web_dashboard: True
+# whether to open the Serena web dashboard (which will be accessible through your web browser) that
+# shows Serena's current session logs - as an alternative to the GUI log window which
+# is supported on all platforms.
+
+web_dashboard_open_on_launch: True
+# whether to open a browser window with the web dashboard when Serena starts (provided that web_dashboard
+# is enabled). If set to False, you can still open the dashboard manually by navigating to
+# http://localhost:24282/dashboard/ in your web browser (24282 = 0x5EDA, SErena DAshboard).
+# If you have multiple instances running, a higher port will be used; try port 24283, 24284, etc.
+
+log_level: 20
+# the minimum log level for the GUI log window and the dashboard (10 = debug, 20 = info, 30 = warning, 40 = error)
+
+trace_lsp_communication: False
+# whether to trace the communication between Serena and the language servers.
+# This is useful for debugging language server issues.
+
+tool_timeout: 240
+# timeout, in seconds, after which tool executions are terminated
+
+excluded_tools: []
+# list of tools to be globally excluded
+
+included_optional_tools: []
+# list of optional tools (which are disabled by default) to be included
+
+jetbrains: False
+# whether to enable JetBrains mode and use tools based on the Serena JetBrains IDE plugin
+# instead of language server-based tools
+# NOTE: The plugin is yet unreleased. This is for Serena developers only.
+
+
+default_max_tool_answer_chars: 150000
+# Used as default for tools where the apply method has a default maximal answer length.
+# Even though the value of the max_answer_chars can be changed when calling the tool, it may make sense to adjust this default
+# through the global configuration.
+
+record_tool_usage_stats:  False
+# whether to record tool usage statistics, they will be shown in the web dashboard if recording is active.
+
+token_count_estimator: TIKTOKEN_GPT4O
+# Only relevant if `record_tool_usage` is True; the name of the token count estimator to use for tool usage statistics.
+# See the `RegisteredTokenCountEstimator` enum for available options.
+#
+# Note: some token estimators (like tiktoken) may require downloading data files
+# on the first run, which can take some time and require internet access. Others, like the Anthropic ones, may require an API key
+# and rate limits may apply.
+
+
+# MANAGED BY SERENA, KEEP AT THE BOTTOM OF THE YAML AND DON'T EDIT WITHOUT NEED
+# The list of registered projects.
+# To add a project, within a chat, simply ask Serena to "activate the project /path/to/project" or,
+# if the project was previously added, "activate the project <project name>".
+# By default, the project's name will be the name of the directory containing the project, but you may change it
+# by editing the (auto-generated) project configuration file `/path/project/project/.serena/project.yml` file.
+# If you want to maintain full control of the project configuration, create the project.yml file manually and then
+# instruct Serena to activate the project by its path for first-time activation.
+# NOTE: Make sure there are no name collisions in the names of registered projects.
+projects: []

projects/ui/serena-new/src/serena/tools/__init__.py

@@ -0,0 +1,9 @@
+# ruff: noqa
+from .tools_base import *
+from .file_tools import *
+from .symbol_tools import *
+from .memory_tools import *
+from .cmd_tools import *
+from .config_tools import *
+from .workflow_tools import *
+from .jetbrains_tools import *

projects/ui/serena-new/src/serena/tools/cmd_tools.py

@@ -0,0 +1,36 @@
+"""
+Tools supporting the execution of (external) commands
+"""
+
+from serena.tools import Tool, ToolMarkerCanEdit
+from serena.util.shell import execute_shell_command
+
+
+class ExecuteShellCommandTool(Tool, ToolMarkerCanEdit):
+    """
+    Executes a shell command.
+    """
+
+    def apply(
+        self,
+        command: str,
+        cwd: str | None = None,
+        capture_stderr: bool = True,
+        max_answer_chars: int = -1,
+    ) -> str:
+        """
+        Execute a shell command and return its output. If there is a memory about suggested commands, read that first.
+        Never execute unsafe shell commands like `rm -rf /` or similar!
+
+        :param command: the shell command to execute
+        :param cwd: the working directory to execute the command in. If None, the project root will be used.
+        :param capture_stderr: whether to capture and return stderr output
+        :param max_answer_chars: if the output is longer than this number of characters,
+            no content will be returned. -1 means using the default value, don't adjust unless there is no other way to get the content
+            required for the task.
+        :return: a JSON object containing the command's stdout and optionally stderr output
+        """
+        _cwd = cwd or self.get_project_root()
+        result = execute_shell_command(command, cwd=_cwd, capture_stderr=capture_stderr)
+        result = result.json()
+        return self._limit_length(result, max_answer_chars)

projects/ui/serena-new/src/serena/tools/config_tools.py

@@ -0,0 +1,83 @@
+import json
+
+from serena.config.context_mode import SerenaAgentMode
+from serena.tools import Tool, ToolMarkerDoesNotRequireActiveProject, ToolMarkerOptional
+
+
+class ActivateProjectTool(Tool, ToolMarkerDoesNotRequireActiveProject):
+    """
+    Activates a project by name.
+    """
+
+    def apply(self, project: str) -> str:
+        """
+        Activates the project with the given name.
+
+        :param project: the name of a registered project to activate or a path to a project directory
+        """
+        active_project = self.agent.activate_project_from_path_or_name(project)
+        if active_project.is_newly_created:
+            result_str = (
+                f"Created and activated a new project with name '{active_project.project_name}' at {active_project.project_root}, language: {active_project.project_config.language.value}. "
+                "You can activate this project later by name.\n"
+                f"The project's Serena configuration is in {active_project.path_to_project_yml()}. In particular, you may want to edit the project name and the initial prompt."
+            )
+        else:
+            result_str = f"Activated existing project with name '{active_project.project_name}' at {active_project.project_root}, language: {active_project.project_config.language.value}"
+
+        if active_project.project_config.initial_prompt:
+            result_str += f"\nAdditional project information:\n {active_project.project_config.initial_prompt}"
+        result_str += (
+            f"\nAvailable memories:\n {json.dumps(list(self.memories_manager.list_memories()))}"
+            + "You should not read these memories directly, but rather use the `read_memory` tool to read them later if needed for the task."
+        )
+        result_str += f"\nAvailable tools:\n {json.dumps(self.agent.get_active_tool_names())}"
+        return result_str
+
+
+class RemoveProjectTool(Tool, ToolMarkerDoesNotRequireActiveProject, ToolMarkerOptional):
+    """
+    Removes a project from the Serena configuration.
+    """
+
+    def apply(self, project_name: str) -> str:
+        """
+        Removes a project from the Serena configuration.
+
+        :param project_name: Name of the project to remove
+        """
+        self.agent.serena_config.remove_project(project_name)
+        return f"Successfully removed project '{project_name}' from configuration."
+
+
+class SwitchModesTool(Tool, ToolMarkerOptional):
+    """
+    Activates modes by providing a list of their names
+    """
+
+    def apply(self, modes: list[str]) -> str:
+        """
+        Activates the desired modes, like ["editing", "interactive"] or ["planning", "one-shot"]
+
+        :param modes: the names of the modes to activate
+        """
+        mode_instances = [SerenaAgentMode.load(mode) for mode in modes]
+        self.agent.set_modes(mode_instances)
+
+        # Inform the Agent about the activated modes and the currently active tools
+        result_str = f"Successfully activated modes: {', '.join([mode.name for mode in mode_instances])}" + "\n"
+        result_str += "\n".join([mode_instance.prompt for mode_instance in mode_instances]) + "\n"
+        result_str += f"Currently active tools: {', '.join(self.agent.get_active_tool_names())}"
+        return result_str
+
+
+class GetCurrentConfigTool(Tool, ToolMarkerOptional):
+    """
+    Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+    """
+
+    def apply(self) -> str:
+        """
+        Print the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+        """
+        return self.agent.get_current_config_overview()

projects/ui/serena-new/src/serena/tools/file_tools.py

@@ -0,0 +1,403 @@
+"""
+File and file system-related tools, specifically for
+  * listing directory contents
+  * reading files
+  * creating files
+  * editing at the file level
+"""
+
+import json
+import os
+import re
+from collections import defaultdict
+from fnmatch import fnmatch
+from pathlib import Path
+
+from serena.text_utils import search_files
+from serena.tools import SUCCESS_RESULT, EditedFileContext, Tool, ToolMarkerCanEdit, ToolMarkerOptional
+from serena.util.file_system import scan_directory
+
+
+class ReadFileTool(Tool):
+    """
+    Reads a file within the project directory.
+    """
+
+    def apply(self, relative_path: str, start_line: int = 0, end_line: int | None = None, max_answer_chars: int = -1) -> str:
+        """
+        Reads the given file or a chunk of it. Generally, symbolic operations
+        like find_symbol or find_referencing_symbols should be preferred if you know which symbols you are looking for.
+
+        :param relative_path: the relative path to the file to read
+        :param start_line: the 0-based index of the first line to be retrieved.
+        :param end_line: the 0-based index of the last line to be retrieved (inclusive). If None, read until the end of the file.
+        :param max_answer_chars: if the file (chunk) is longer than this number of characters,
+            no content will be returned. Don't adjust unless there is really no other way to get the content
+            required for the task.
+        :return: the full text of the file at the given relative path
+        """
+        self.project.validate_relative_path(relative_path)
+
+        result = self.project.read_file(relative_path)
+        result_lines = result.splitlines()
+        if end_line is None:
+            result_lines = result_lines[start_line:]
+        else:
+            self.lines_read.add_lines_read(relative_path, (start_line, end_line))
+            result_lines = result_lines[start_line : end_line + 1]
+        result = "\n".join(result_lines)
+
+        return self._limit_length(result, max_answer_chars)
+
+
+class CreateTextFileTool(Tool, ToolMarkerCanEdit):
+    """
+    Creates/overwrites a file in the project directory.
+    """
+
+    def apply(self, relative_path: str, content: str) -> str:
+        """
+        Write a new file or overwrite an existing file.
+
+        :param relative_path: the relative path to the file to create
+        :param content: the (utf-8-encoded) content to write to the file
+        :return: a message indicating success or failure
+        """
+        project_root = self.get_project_root()
+        abs_path = (Path(project_root) / relative_path).resolve()
+        will_overwrite_existing = abs_path.exists()
+
+        if will_overwrite_existing:
+            self.project.validate_relative_path(relative_path)
+        else:
+            assert abs_path.is_relative_to(
+                self.get_project_root()
+            ), f"Cannot create file outside of the project directory, got {relative_path=}"
+
+        abs_path.parent.mkdir(parents=True, exist_ok=True)
+        abs_path.write_text(content, encoding="utf-8")
+        answer = f"File created: {relative_path}."
+        if will_overwrite_existing:
+            answer += " Overwrote existing file."
+        return json.dumps(answer)
+
+
+class ListDirTool(Tool):
+    """
+    Lists files and directories in the given directory (optionally with recursion).
+    """
+
+    def apply(self, relative_path: str, recursive: bool, max_answer_chars: int = -1) -> str:
+        """
+        Lists all non-gitignored files and directories in the given directory (optionally with recursion).
+
+        :param relative_path: the relative path to the directory to list; pass "." to scan the project root
+        :param recursive: whether to scan subdirectories recursively
+        :param max_answer_chars: if the output is longer than this number of characters,
+            no content will be returned. -1 means the default value from the config will be used.
+            Don't adjust unless there is really no other way to get the content required for the task.
+        :return: a JSON object with the names of directories and files within the given directory
+        """
+        # Check if the directory exists before validation
+        if not self.project.relative_path_exists(relative_path):
+            error_info = {
+                "error": f"Directory not found: {relative_path}",
+                "project_root": self.get_project_root(),
+                "hint": "Check if the path is correct relative to the project root",
+            }
+            return json.dumps(error_info)
+
+        self.project.validate_relative_path(relative_path)
+
+        dirs, files = scan_directory(
+            os.path.join(self.get_project_root(), relative_path),
+            relative_to=self.get_project_root(),
+            recursive=recursive,
+            is_ignored_dir=self.project.is_ignored_path,
+            is_ignored_file=self.project.is_ignored_path,
+        )
+
+        result = json.dumps({"dirs": dirs, "files": files})
+        return self._limit_length(result, max_answer_chars)
+
+
+class FindFileTool(Tool):
+    """
+    Finds files in the given relative paths
+    """
+
+    def apply(self, file_mask: str, relative_path: str) -> str:
+        """
+        Finds non-gitignored files matching the given file mask within the given relative path
+
+        :param file_mask: the filename or file mask (using the wildcards * or ?) to search for
+        :param relative_path: the relative path to the directory to search in; pass "." to scan the project root
+        :return: a JSON object with the list of matching files
+        """
+        self.project.validate_relative_path(relative_path)
+
+        dir_to_scan = os.path.join(self.get_project_root(), relative_path)
+
+        # find the files by ignoring everything that doesn't match
+        def is_ignored_file(abs_path: str) -> bool:
+            if self.project.is_ignored_path(abs_path):
+                return True
+            filename = os.path.basename(abs_path)
+            return not fnmatch(filename, file_mask)
+
+        dirs, files = scan_directory(
+            path=dir_to_scan,
+            recursive=True,
+            is_ignored_dir=self.project.is_ignored_path,
+            is_ignored_file=is_ignored_file,
+            relative_to=self.get_project_root(),
+        )
+
+        result = json.dumps({"files": files})
+        return result
+
+
+class ReplaceRegexTool(Tool, ToolMarkerCanEdit):
+    """
+    Replaces content in a file by using regular expressions.
+    """
+
+    def apply(
+        self,
+        relative_path: str,
+        regex: str,
+        repl: str,
+        allow_multiple_occurrences: bool = False,
+    ) -> str:
+        r"""
+        Replaces one or more occurrences of the given regular expression.
+        This is the preferred way to replace content in a file whenever the symbol-level
+        tools are not appropriate.
+        Even large sections of code can be replaced by providing a concise regular expression of
+        the form "beginning.*?end-of-text-to-be-replaced".
+        Always try to use wildcards to avoid specifying the exact content of the code to be replaced,
+        especially if it spans several lines.
+
+        IMPORTANT: REMEMBER TO USE WILDCARDS WHEN APPROPRIATE! I WILL BE VERY UNHAPPY IF YOU WRITE LONG REGEXES WITHOUT USING WILDCARDS INSTEAD!
+
+        :param relative_path: the relative path to the file
+        :param regex: a Python-style regular expression, matches of which will be replaced.
+            Dot matches all characters, multi-line matching is enabled.
+        :param repl: the string to replace the matched content with, which may contain
+            backreferences like \1, \2, etc.
+            Make sure to escape special characters appropriately, e.g., use `\\n` for a literal `\n`.
+        :param allow_multiple_occurrences: if True, the regex may match multiple occurrences in the file
+            and all of them will be replaced.
+            If this is set to False and the regex matches multiple occurrences, an error will be returned
+            (and you may retry with a revised, more specific regex).
+        """
+        self.project.validate_relative_path(relative_path)
+        with EditedFileContext(relative_path, self.agent) as context:
+            original_content = context.get_original_content()
+            updated_content, n = re.subn(regex, repl, original_content, flags=re.DOTALL | re.MULTILINE)
+            if n == 0:
+                return f"Error: No matches found for regex '{regex}' in file '{relative_path}'."
+            if not allow_multiple_occurrences and n > 1:
+                return (
+                    f"Error: Regex '{regex}' matches {n} occurrences in file '{relative_path}'. "
+                    "Please revise the regex to be more specific or enable allow_multiple_occurrences if this is expected."
+                )
+            context.set_updated_content(updated_content)
+        return SUCCESS_RESULT
+
+
+class DeleteLinesTool(Tool, ToolMarkerCanEdit, ToolMarkerOptional):
+    """
+    Deletes a range of lines within a file.
+    """
+
+    def apply(
+        self,
+        relative_path: str,
+        start_line: int,
+        end_line: int,
+    ) -> str:
+        """
+        Deletes the given lines in the file.
+        Requires that the same range of lines was previously read using the `read_file` tool to verify correctness
+        of the operation.
+
+        :param relative_path: the relative path to the file
+        :param start_line: the 0-based index of the first line to be deleted
+        :param end_line: the 0-based index of the last line to be deleted
+        """
+        if not self.lines_read.were_lines_read(relative_path, (start_line, end_line)):
+            read_lines_tool = self.agent.get_tool(ReadFileTool)
+            return f"Error: Must call `{read_lines_tool.get_name_from_cls()}` first to read exactly the affected lines."
+        code_editor = self.create_code_editor()
+        code_editor.delete_lines(relative_path, start_line, end_line)
+        return SUCCESS_RESULT
+
+
+class ReplaceLinesTool(Tool, ToolMarkerCanEdit, ToolMarkerOptional):
+    """
+    Replaces a range of lines within a file with new content.
+    """
+
+    def apply(
+        self,
+        relative_path: str,
+        start_line: int,
+        end_line: int,
+        content: str,
+    ) -> str:
+        """
+        Replaces the given range of lines in the given file.
+        Requires that the same range of lines was previously read using the `read_file` tool to verify correctness
+        of the operation.
+
+        :param relative_path: the relative path to the file
+        :param start_line: the 0-based index of the first line to be deleted
+        :param end_line: the 0-based index of the last line to be deleted
+        :param content: the content to insert
+        """
+        if not content.endswith("\n"):
+            content += "\n"
+        result = self.agent.get_tool(DeleteLinesTool).apply(relative_path, start_line, end_line)
+        if result != SUCCESS_RESULT:
+            return result
+        self.agent.get_tool(InsertAtLineTool).apply(relative_path, start_line, content)
+        return SUCCESS_RESULT
+
+
+class InsertAtLineTool(Tool, ToolMarkerCanEdit, ToolMarkerOptional):
+    """
+    Inserts content at a given line in a file.
+    """
+
+    def apply(
+        self,
+        relative_path: str,
+        line: int,
+        content: str,
+    ) -> str:
+        """
+        Inserts the given content at the given line in the file, pushing existing content of the line down.
+        In general, symbolic insert operations like insert_after_symbol or insert_before_symbol should be preferred if you know which
+        symbol you are looking for.
+        However, this can also be useful for small targeted edits of the body of a longer symbol (without replacing the entire body).
+
+        :param relative_path: the relative path to the file
+        :param line: the 0-based index of the line to insert content at
+        :param content: the content to be inserted
+        """
+        if not content.endswith("\n"):
+            content += "\n"
+        code_editor = self.create_code_editor()
+        code_editor.insert_at_line(relative_path, line, content)
+        return SUCCESS_RESULT
+
+
+class SearchForPatternTool(Tool):
+    """
+    Performs a search for a pattern in the project.
+    """
+
+    def apply(
+        self,
+        substring_pattern: str,
+        context_lines_before: int = 0,
+        context_lines_after: int = 0,
+        paths_include_glob: str = "",
+        paths_exclude_glob: str = "",
+        relative_path: str = "",
+        restrict_search_to_code_files: bool = False,
+        max_answer_chars: int = -1,
+    ) -> str:
+        """
+        Offers a flexible search for arbitrary patterns in the codebase, including the
+        possibility to search in non-code files.
+        Generally, symbolic operations like find_symbol or find_referencing_symbols
+        should be preferred if you know which symbols you are looking for.
+
+        Pattern Matching Logic:
+            For each match, the returned result will contain the full lines where the
+            substring pattern is found, as well as optionally some lines before and after it. The pattern will be compiled with
+            DOTALL, meaning that the dot will match all characters including newlines.
+            This also means that it never makes sense to have .* at the beginning or end of the pattern,
+            but it may make sense to have it in the middle for complex patterns.
+            If a pattern matches multiple lines, all those lines will be part of the match.
+            Be careful to not use greedy quantifiers unnecessarily, it is usually better to use non-greedy quantifiers like .*? to avoid
+            matching too much content.
+
+        File Selection Logic:
+            The files in which the search is performed can be restricted very flexibly.
+            Using `restrict_search_to_code_files` is useful if you are only interested in code symbols (i.e., those
+            symbols that can be manipulated with symbolic tools like find_symbol).
+            You can also restrict the search to a specific file or directory,
+            and provide glob patterns to include or exclude certain files on top of that.
+            The globs are matched against relative file paths from the project root (not to the `relative_path` parameter that
+            is used to further restrict the search).
+            Smartly combining the various restrictions allows you to perform very targeted searches.
+
+
+        :param substring_pattern: Regular expression for a substring pattern to search for
+        :param context_lines_before: Number of lines of context to include before each match
+        :param context_lines_after: Number of lines of context to include after each match
+        :param paths_include_glob: optional glob pattern specifying files to include in the search.
+            Matches against relative file paths from the project root (e.g., "*.py", "src/**/*.ts").
+            Only matches files, not directories. If left empty, all non-ignored files will be included.
+        :param paths_exclude_glob: optional glob pattern specifying files to exclude from the search.
+            Matches against relative file paths from the project root (e.g., "*test*", "**/*_generated.py").
+            Takes precedence over paths_include_glob. Only matches files, not directories. If left empty, no files are excluded.
+        :param relative_path: only subpaths of this path (relative to the repo root) will be analyzed. If a path to a single
+            file is passed, only that will be searched. The path must exist, otherwise a `FileNotFoundError` is raised.
+        :param max_answer_chars: if the output is longer than this number of characters,
+            no content will be returned.
+            -1 means the default value from the config will be used.
+            Don't adjust unless there is really no other way to get the content
+            required for the task. Instead, if the output is too long, you should
+            make a stricter query.
+        :param restrict_search_to_code_files: whether to restrict the search to only those files where
+            analyzed code symbols can be found. Otherwise, will search all non-ignored files.
+            Set this to True if your search is only meant to discover code that can be manipulated with symbolic tools.
+            For example, for finding classes or methods from a name pattern.
+            Setting to False is a better choice if you also want to search in non-code files, like in html or yaml files,
+            which is why it is the default.
+        :return: A mapping of file paths to lists of matched consecutive lines.
+        """
+        abs_path = os.path.join(self.get_project_root(), relative_path)
+        if not os.path.exists(abs_path):
+            raise FileNotFoundError(f"Relative path {relative_path} does not exist.")
+
+        if restrict_search_to_code_files:
+            matches = self.project.search_source_files_for_pattern(
+                pattern=substring_pattern,
+                relative_path=relative_path,
+                context_lines_before=context_lines_before,
+                context_lines_after=context_lines_after,
+                paths_include_glob=paths_include_glob.strip(),
+                paths_exclude_glob=paths_exclude_glob.strip(),
+            )
+        else:
+            if os.path.isfile(abs_path):
+                rel_paths_to_search = [relative_path]
+            else:
+                dirs, rel_paths_to_search = scan_directory(
+                    path=abs_path,
+                    recursive=True,
+                    is_ignored_dir=self.project.is_ignored_path,
+                    is_ignored_file=self.project.is_ignored_path,
+                    relative_to=self.get_project_root(),
+                )
+            # TODO (maybe): not super efficient to walk through the files again and filter if glob patterns are provided
+            #   but it probably never matters and this version required no further refactoring
+            matches = search_files(
+                rel_paths_to_search,
+                substring_pattern,
+                root_path=self.get_project_root(),
+                paths_include_glob=paths_include_glob,
+                paths_exclude_glob=paths_exclude_glob,
+            )
+        # group matches by file
+        file_to_matches: dict[str, list[str]] = defaultdict(list)
+        for match in matches:
+            assert match.source_file_path is not None
+            file_to_matches[match.source_file_path].append(match.to_display_string())
+        result = json.dumps(file_to_matches)
+        return self._limit_length(result, max_answer_chars)

projects/ui/serena-new/src/serena/tools/jetbrains_plugin_client.py

@@ -0,0 +1,185 @@
+"""
+Client for the Serena JetBrains Plugin
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Optional, Self, TypeVar
+
+import requests
+from sensai.util.string import ToStringMixin
+
+from serena.project import Project
+
+T = TypeVar("T")
+log = logging.getLogger(__name__)
+
+
+class SerenaClientError(Exception):
+    """Base exception for Serena client errors."""
+
+
+class ConnectionError(SerenaClientError):
+    """Raised when connection to the service fails."""
+
+
+class APIError(SerenaClientError):
+    """Raised when the API returns an error response."""
+
+
+class ServerNotFoundError(Exception):
+    """Raised when the plugin's service is not found."""
+
+
+class JetBrainsPluginClient(ToStringMixin):
+    """
+    Python client for the Serena Backend Service.
+
+    Provides simple methods to interact with all available endpoints.
+    """
+
+    BASE_PORT = 0x5EA2
+    last_port: int | None = None
+
+    def __init__(self, port: int, timeout: int = 30):
+        self.base_url = f"http://127.0.0.1:{port}"
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.session.headers.update({"Content-Type": "application/json", "Accept": "application/json"})
+
+    def _tostring_includes(self) -> list[str]:
+        return ["base_url", "timeout"]
+
+    @classmethod
+    def from_project(cls, project: Project) -> Self:
+        resolved_path = Path(project.project_root).resolve()
+
+        if cls.last_port is not None:
+            client = JetBrainsPluginClient(cls.last_port)
+            if client.matches(resolved_path):
+                return client
+
+        for port in range(cls.BASE_PORT, cls.BASE_PORT + 20):
+            client = JetBrainsPluginClient(port)
+            if client.matches(resolved_path):
+                log.info("Found JetBrains IDE service at port %d for project %s", port, resolved_path)
+                cls.last_port = port
+                return client
+
+        raise ServerNotFoundError("Found no Serena service in a JetBrains IDE instance for the project at " + str(resolved_path))
+
+    def matches(self, resolved_path: Path) -> bool:
+        try:
+            return Path(self.project_root()).resolve() == resolved_path
+        except ConnectionError:
+            return False
+
+    def _make_request(self, method: str, endpoint: str, data: Optional[dict] = None) -> dict[str, Any]:
+        url = f"{self.base_url}{endpoint}"
+
+        try:
+            if method.upper() == "GET":
+                response = self.session.get(url, timeout=self.timeout)
+            elif method.upper() == "POST":
+                json_data = json.dumps(data) if data else None
+                response = self.session.post(url, data=json_data, timeout=self.timeout)
+            else:
+                raise ValueError(f"Unsupported HTTP method: {method}")
+
+            response.raise_for_status()
+
+            # Try to parse JSON response
+            try:
+                return self._pythonify_response(response.json())
+            except json.JSONDecodeError:
+                # If response is not JSON, return raw text
+                return {"response": response.text}
+
+        except requests.exceptions.ConnectionError as e:
+            raise ConnectionError(f"Failed to connect to Serena service at {url}: {e}")
+        except requests.exceptions.Timeout as e:
+            raise ConnectionError(f"Request to {url} timed out: {e}")
+        except requests.exceptions.HTTPError:
+            raise APIError(f"API request failed with status {response.status_code}: {response.text}")
+        except requests.exceptions.RequestException as e:
+            raise SerenaClientError(f"Request failed: {e}")
+
+    @staticmethod
+    def _pythonify_response(response: T) -> T:
+        """
+        Converts dictionary keys from camelCase to snake_case recursively.
+
+        :response: the response in which to convert keys (dictionary or list)
+        """
+        to_snake_case = lambda s: "".join(["_" + c.lower() if c.isupper() else c for c in s])
+
+        def convert(x):  # type: ignore
+            if isinstance(x, dict):
+                return {to_snake_case(k): convert(v) for k, v in x.items()}
+            elif isinstance(x, list):
+                return [convert(item) for item in x]
+            else:
+                return x
+
+        return convert(response)
+
+    def project_root(self) -> str:
+        response = self._make_request("GET", "/status")
+        return response["project_root"]
+
+    def find_symbol(
+        self, name_path: str, relative_path: str | None = None, include_body: bool = False, depth: int = 0, include_location: bool = False
+    ) -> dict[str, Any]:
+        """
+        Find symbols by name.
+
+        :param name_path: the name path to match
+        :param relative_path: the relative path to which to restrict the search
+        :param include_body: whether to include symbol body content
+        :param depth: depth of children to include (0 = no children)
+
+        :return: Dictionary containing 'symbols' list with matching symbols
+        """
+        request_data = {
+            "namePath": name_path,
+            "relativePath": relative_path,
+            "includeBody": include_body,
+            "depth": depth,
+            "includeLocation": include_location,
+        }
+        return self._make_request("POST", "/findSymbol", request_data)
+
+    def find_references(self, name_path: str, relative_path: str) -> dict[str, Any]:
+        """
+        Find references to a symbol.
+
+        :param name_path: the name path of the symbol
+        :param relative_path: the relative path
+        :return: dictionary containing 'symbols' list with symbol references
+        """
+        request_data = {"namePath": name_path, "relativePath": relative_path}
+        return self._make_request("POST", "/findReferences", request_data)
+
+    def get_symbols_overview(self, relative_path: str) -> dict[str, Any]:
+        """
+        :param relative_path: the relative path to a source file
+        """
+        request_data = {"relativePath": relative_path}
+        return self._make_request("POST", "/getSymbolsOverview", request_data)
+
+    def is_service_available(self) -> bool:
+        try:
+            response = self.heartbeat()
+            return response.get("status") == "OK"
+        except (ConnectionError, APIError):
+            return False
+
+    def close(self) -> None:
+        self.session.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):  # type: ignore
+        self.close()

projects/ui/serena-new/src/serena/tools/jetbrains_tools.py

@@ -0,0 +1,132 @@
+import json
+
+from serena.tools import Tool, ToolMarkerOptional, ToolMarkerSymbolicRead
+from serena.tools.jetbrains_plugin_client import JetBrainsPluginClient
+
+
+class JetBrainsFindSymbolTool(Tool, ToolMarkerSymbolicRead, ToolMarkerOptional):
+    """
+    Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+    """
+
+    def apply(
+        self,
+        name_path: str,
+        depth: int = 0,
+        relative_path: str | None = None,
+        include_body: bool = False,
+        max_answer_chars: int = -1,
+    ) -> str:
+        """
+        Retrieves information on all symbols/code entities (classes, methods, etc.) based on the given `name_path`,
+        which represents a pattern for the symbol's path within the symbol tree of a single file.
+        The returned symbol location can be used for edits or further queries.
+        Specify `depth > 0` to retrieve children (e.g., methods of a class).
+
+        The matching behavior is determined by the structure of `name_path`, which can
+        either be a simple name (e.g. "method") or a name path like "class/method" (relative name path)
+        or "/class/method" (absolute name path).
+        Note that the name path is not a path in the file system but rather a path in the symbol tree
+        **within a single file**. Thus, file or directory names should never be included in the `name_path`.
+        For restricting the search to a single file or directory, pass the `relative_path` parameter.
+        The retrieved symbols' `name_path` attribute will always be composed of symbol names, never file
+        or directory names.
+
+        Key aspects of the name path matching behavior:
+        - The name of the retrieved symbols will match the last segment of `name_path`, while preceding segments
+          will restrict the search to symbols that have a desired sequence of ancestors.
+        - If there is no `/` in `name_path`, there is no restriction on the ancestor symbols.
+          For example, passing `method` will match against all symbols with name paths like `method`,
+          `class/method`, `class/nested_class/method`, etc.
+        - If `name_path` contains at least one `/`, the matching is restricted to symbols
+          with the respective ancestors. For example, passing `class/method` will match against
+          `class/method` as well as `nested_class/class/method` but not `other_class/method`.
+        - If `name_path` starts with a `/`, it will be treated as an absolute name path pattern, i.e.
+          all ancestors are provided and must match.
+          For example, passing `/class` will match only against top-level symbols named `class` but
+          will not match `nested_class/class`. Passing `/class/method` will match `class/method` but
+          not `outer_class/class/method`.
+
+        :param name_path: The name path pattern to search for, see above for details.
+        :param depth: Depth to retrieve descendants (e.g., 1 for class methods/attributes).
+        :param relative_path: Optional. Restrict search to this file or directory.
+            If None, searches entire codebase.
+            If a directory is passed, the search will be restricted to the files in that directory.
+            If a file is passed, the search will be restricted to that file.
+            If you have some knowledge about the codebase, you should use this parameter, as it will significantly
+            speed up the search as well as reduce the number of results.
+        :param include_body: If True, include the symbol's source code. Use judiciously.
+        :param max_answer_chars: max characters for the JSON result. If exceeded, no content is returned.
+            -1 means the default value from the config will be used.
+        :return: JSON string: a list of symbols (with locations) matching the name.
+        """
+        with JetBrainsPluginClient.from_project(self.project) as client:
+            response_dict = client.find_symbol(
+                name_path=name_path,
+                relative_path=relative_path,
+                depth=depth,
+                include_body=include_body,
+            )
+            result = json.dumps(response_dict)
+        return self._limit_length(result, max_answer_chars)
+
+
+class JetBrainsFindReferencingSymbolsTool(Tool, ToolMarkerSymbolicRead, ToolMarkerOptional):
+    """
+    Finds symbols that reference the given symbol
+    """
+
+    def apply(
+        self,
+        name_path: str,
+        relative_path: str,
+        max_answer_chars: int = -1,
+    ) -> str:
+        """
+        Finds symbols that reference the symbol at the given `name_path`.
+        The result will contain metadata about the referencing symbols.
+
+        :param name_path: name path of the symbol for which to find references; matching logic as described in find symbol tool.
+        :param relative_path: the relative path to the file containing the symbol for which to find references.
+            Note that here you can't pass a directory but must pass a file.
+        :param max_answer_chars: max characters for the JSON result. If exceeded, no content is returned. -1 means the
+            default value from the config will be used.
+        :return: a list of JSON objects with the symbols referencing the requested symbol
+        """
+        with JetBrainsPluginClient.from_project(self.project) as client:
+            response_dict = client.find_references(
+                name_path=name_path,
+                relative_path=relative_path,
+            )
+            result = json.dumps(response_dict)
+        return self._limit_length(result, max_answer_chars)
+
+
+class JetBrainsGetSymbolsOverviewTool(Tool, ToolMarkerSymbolicRead, ToolMarkerOptional):
+    """
+    Retrieves an overview of the top-level symbols within a specified file
+    """
+
+    def apply(
+        self,
+        relative_path: str,
+        max_answer_chars: int = -1,
+    ) -> str:
+        """
+        Gets an overview of the top-level symbols in the given file.
+        Calling this is often a good idea before more targeted reading, searching or editing operations on the code symbols.
+        Before requesting a symbol overview, it is usually a good idea to narrow down the scope of the overview
+        by first understanding the basic directory structure of the repository that you can get from memories
+        or by using the `list_dir` and `find_file` tools (or similar).
+
+        :param relative_path: the relative path to the file to get the overview of
+        :param max_answer_chars: max characters for the JSON result. If exceeded, no content is returned.
+            -1 means the default value from the config will be used.
+        :return: a JSON object containing the symbols
+        """
+        with JetBrainsPluginClient.from_project(self.project) as client:
+            response_dict = client.get_symbols_overview(
+                relative_path=relative_path,
+            )
+            result = json.dumps(response_dict)
+        return self._limit_length(result, max_answer_chars)

projects/ui/serena-new/src/serena/tools/memory_tools.py

@@ -0,0 +1,64 @@
+import json
+
+from serena.tools import Tool
+
+
+class WriteMemoryTool(Tool):
+    """
+    Writes a named memory (for future reference) to Serena's project-specific memory store.
+    """
+
+    def apply(self, memory_name: str, content: str, max_answer_chars: int = -1) -> str:
+        """
+        Write some information about this project that can be useful for future tasks to a memory in md format.
+        The memory name should be meaningful.
+        """
+        if max_answer_chars == -1:
+            max_answer_chars = self.agent.serena_config.default_max_tool_answer_chars
+        if len(content) > max_answer_chars:
+            raise ValueError(
+                f"Content for {memory_name} is too long. Max length is {max_answer_chars} characters. " + "Please make the content shorter."
+            )
+
+        return self.memories_manager.save_memory(memory_name, content)
+
+
+class ReadMemoryTool(Tool):
+    """
+    Reads the memory with the given name from Serena's project-specific memory store.
+    """
+
+    def apply(self, memory_file_name: str, max_answer_chars: int = -1) -> str:
+        """
+        Read the content of a memory file. This tool should only be used if the information
+        is relevant to the current task. You can infer whether the information
+        is relevant from the memory file name.
+        You should not read the same memory file multiple times in the same conversation.
+        """
+        return self.memories_manager.load_memory(memory_file_name)
+
+
+class ListMemoriesTool(Tool):
+    """
+    Lists memories in Serena's project-specific memory store.
+    """
+
+    def apply(self) -> str:
+        """
+        List available memories. Any memory can be read using the `read_memory` tool.
+        """
+        return json.dumps(self.memories_manager.list_memories())
+
+
+class DeleteMemoryTool(Tool):
+    """
+    Deletes a memory from Serena's project-specific memory store.
+    """
+
+    def apply(self, memory_file_name: str) -> str:
+        """
+        Delete a memory file. Should only happen if a user asks for it explicitly,
+        for example by saying that the information retrieved from a memory file is no longer correct
+        or no longer relevant for the project.
+        """
+        return self.memories_manager.delete_memory(memory_file_name)

projects/ui/serena-new/src/serena/tools/symbol_tools.py

@@ -0,0 +1,290 @@
+"""
+Language server-related tools
+"""
+
+import dataclasses
+import json
+import os
+from collections.abc import Sequence
+from copy import copy
+from typing import Any
+
+from serena.tools import (
+    SUCCESS_RESULT,
+    Tool,
+    ToolMarkerSymbolicEdit,
+    ToolMarkerSymbolicRead,
+)
+from serena.tools.tools_base import ToolMarkerOptional
+from solidlsp.ls_types import SymbolKind
+
+
+def _sanitize_symbol_dict(symbol_dict: dict[str, Any]) -> dict[str, Any]:
+    """
+    Sanitize a symbol dictionary inplace by removing unnecessary information.
+    """
+    # We replace the location entry, which repeats line information already included in body_location
+    # and has unnecessary information on column, by just the relative path.
+    symbol_dict = copy(symbol_dict)
+    s_relative_path = symbol_dict.get("location", {}).get("relative_path")
+    if s_relative_path is not None:
+        symbol_dict["relative_path"] = s_relative_path
+    symbol_dict.pop("location", None)
+    # also remove name, name_path should be enough
+    symbol_dict.pop("name")
+    return symbol_dict
+
+
+class RestartLanguageServerTool(Tool, ToolMarkerOptional):
+    """Restarts the language server, may be necessary when edits not through Serena happen."""
+
+    def apply(self) -> str:
+        """Use this tool only on explicit user request or after confirmation.
+        It may be necessary to restart the language server if it hangs.
+        """
+        self.agent.reset_language_server()
+        return SUCCESS_RESULT
+
+
+class GetSymbolsOverviewTool(Tool, ToolMarkerSymbolicRead):
+    """
+    Gets an overview of the top-level symbols defined in a given file.
+    """
+
+    def apply(self, relative_path: str, max_answer_chars: int = -1) -> str:
+        """
+        Use this tool to get a high-level understanding of the code symbols in a file.
+        This should be the first tool to call when you want to understand a new file, unless you already know
+        what you are looking for.
+
+        :param relative_path: the relative path to the file to get the overview of
+        :param max_answer_chars: if the overview is longer than this number of characters,
+            no content will be returned. -1 means the default value from the config will be used.
+            Don't adjust unless there is really no other way to get the content required for the task.
+        :return: a JSON object containing info about top-level symbols in the file
+        """
+        symbol_retriever = self.create_language_server_symbol_retriever()
+        file_path = os.path.join(self.project.project_root, relative_path)
+
+        # The symbol overview is capable of working with both files and directories,
+        # but we want to ensure that the user provides a file path.
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File or directory {relative_path} does not exist in the project.")
+        if os.path.isdir(file_path):
+            raise ValueError(f"Expected a file path, but got a directory path: {relative_path}. ")
+        result = symbol_retriever.get_symbol_overview(relative_path)[relative_path]
+        result_json_str = json.dumps([dataclasses.asdict(i) for i in result])
+        return self._limit_length(result_json_str, max_answer_chars)
+
+
+class FindSymbolTool(Tool, ToolMarkerSymbolicRead):
+    """
+    Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+    """
+
+    def apply(
+        self,
+        name_path: str,
+        depth: int = 0,
+        relative_path: str = "",
+        include_body: bool = False,
+        include_kinds: list[int] = [],  # noqa: B006
+        exclude_kinds: list[int] = [],  # noqa: B006
+        substring_matching: bool = False,
+        max_answer_chars: int = -1,
+    ) -> str:
+        """
+        Retrieves information on all symbols/code entities (classes, methods, etc.) based on the given `name_path`,
+        which represents a pattern for the symbol's path within the symbol tree of a single file.
+        The returned symbol location can be used for edits or further queries.
+        Specify `depth > 0` to retrieve children (e.g., methods of a class).
+
+        The matching behavior is determined by the structure of `name_path`, which can
+        either be a simple name (e.g. "method") or a name path like "class/method" (relative name path)
+        or "/class/method" (absolute name path). Note that the name path is not a path in the file system
+        but rather a path in the symbol tree **within a single file**. Thus, file or directory names should never
+        be included in the `name_path`. For restricting the search to a single file or directory,
+        the `within_relative_path` parameter should be used instead. The retrieved symbols' `name_path` attribute
+        will always be composed of symbol names, never file or directory names.
+
+        Key aspects of the name path matching behavior:
+        - Trailing slashes in `name_path` play no role and are ignored.
+        - The name of the retrieved symbols will match (either exactly or as a substring)
+          the last segment of `name_path`, while other segments will restrict the search to symbols that
+          have a desired sequence of ancestors.
+        - If there is no starting or intermediate slash in `name_path`, there is no
+          restriction on the ancestor symbols. For example, passing `method` will match
+          against symbols with name paths like `method`, `class/method`, `class/nested_class/method`, etc.
+        - If `name_path` contains a `/` but doesn't start with a `/`, the matching is restricted to symbols
+          with the same ancestors as the last segment of `name_path`. For example, passing `class/method` will match against
+          `class/method` as well as `nested_class/class/method` but not `method`.
+        - If `name_path` starts with a `/`, it will be treated as an absolute name path pattern, meaning
+          that the first segment of it must match the first segment of the symbol's name path.
+          For example, passing `/class` will match only against top-level symbols like `class` but not against `nested_class/class`.
+          Passing `/class/method` will match against `class/method` but not `nested_class/class/method` or `method`.
+
+
+        :param name_path: The name path pattern to search for, see above for details.
+        :param depth: Depth to retrieve descendants (e.g., 1 for class methods/attributes).
+        :param relative_path: Optional. Restrict search to this file or directory. If None, searches entire codebase.
+            If a directory is passed, the search will be restricted to the files in that directory.
+            If a file is passed, the search will be restricted to that file.
+            If you have some knowledge about the codebase, you should use this parameter, as it will significantly
+            speed up the search as well as reduce the number of results.
+        :param include_body: If True, include the symbol's source code. Use judiciously.
+        :param include_kinds: Optional. List of LSP symbol kind integers to include. (e.g., 5 for Class, 12 for Function).
+            Valid kinds: 1=file, 2=module, 3=namespace, 4=package, 5=class, 6=method, 7=property, 8=field, 9=constructor, 10=enum,
+            11=interface, 12=function, 13=variable, 14=constant, 15=string, 16=number, 17=boolean, 18=array, 19=object,
+            20=key, 21=null, 22=enum member, 23=struct, 24=event, 25=operator, 26=type parameter.
+            If not provided, all kinds are included.
+        :param exclude_kinds: Optional. List of LSP symbol kind integers to exclude. Takes precedence over `include_kinds`.
+            If not provided, no kinds are excluded.
+        :param substring_matching: If True, use substring matching for the last segment of `name`.
+        :param max_answer_chars: Max characters for the JSON result. If exceeded, no content is returned.
+            -1 means the default value from the config will be used.
+        :return: a list of symbols (with locations) matching the name.
+        """
+        parsed_include_kinds: Sequence[SymbolKind] | None = [SymbolKind(k) for k in include_kinds] if include_kinds else None
+        parsed_exclude_kinds: Sequence[SymbolKind] | None = [SymbolKind(k) for k in exclude_kinds] if exclude_kinds else None
+        symbol_retriever = self.create_language_server_symbol_retriever()
+        symbols = symbol_retriever.find_by_name(
+            name_path,
+            include_body=include_body,
+            include_kinds=parsed_include_kinds,
+            exclude_kinds=parsed_exclude_kinds,
+            substring_matching=substring_matching,
+            within_relative_path=relative_path,
+        )
+        symbol_dicts = [_sanitize_symbol_dict(s.to_dict(kind=True, location=True, depth=depth, include_body=include_body)) for s in symbols]
+        result = json.dumps(symbol_dicts)
+        return self._limit_length(result, max_answer_chars)
+
+
+class FindReferencingSymbolsTool(Tool, ToolMarkerSymbolicRead):
+    """
+    Finds symbols that reference the symbol at the given location (optionally filtered by type).
+    """
+
+    def apply(
+        self,
+        name_path: str,
+        relative_path: str,
+        include_kinds: list[int] = [],  # noqa: B006
+        exclude_kinds: list[int] = [],  # noqa: B006
+        max_answer_chars: int = -1,
+    ) -> str:
+        """
+        Finds references to the symbol at the given `name_path`. The result will contain metadata about the referencing symbols
+        as well as a short code snippet around the reference.
+
+        :param name_path: for finding the symbol to find references for, same logic as in the `find_symbol` tool.
+        :param relative_path: the relative path to the file containing the symbol for which to find references.
+            Note that here you can't pass a directory but must pass a file.
+        :param include_kinds: same as in the `find_symbol` tool.
+        :param exclude_kinds: same as in the `find_symbol` tool.
+        :param max_answer_chars: same as in the `find_symbol` tool.
+        :return: a list of JSON objects with the symbols referencing the requested symbol
+        """
+        include_body = False  # It is probably never a good idea to include the body of the referencing symbols
+        parsed_include_kinds: Sequence[SymbolKind] | None = [SymbolKind(k) for k in include_kinds] if include_kinds else None
+        parsed_exclude_kinds: Sequence[SymbolKind] | None = [SymbolKind(k) for k in exclude_kinds] if exclude_kinds else None
+        symbol_retriever = self.create_language_server_symbol_retriever()
+        references_in_symbols = symbol_retriever.find_referencing_symbols(
+            name_path,
+            relative_file_path=relative_path,
+            include_body=include_body,
+            include_kinds=parsed_include_kinds,
+            exclude_kinds=parsed_exclude_kinds,
+        )
+        reference_dicts = []
+        for ref in references_in_symbols:
+            ref_dict = ref.symbol.to_dict(kind=True, location=True, depth=0, include_body=include_body)
+            ref_dict = _sanitize_symbol_dict(ref_dict)
+            if not include_body:
+                ref_relative_path = ref.symbol.location.relative_path
+                assert ref_relative_path is not None, f"Referencing symbol {ref.symbol.name} has no relative path, this is likely a bug."
+                content_around_ref = self.project.retrieve_content_around_line(
+                    relative_file_path=ref_relative_path, line=ref.line, context_lines_before=1, context_lines_after=1
+                )
+                ref_dict["content_around_reference"] = content_around_ref.to_display_string()
+            reference_dicts.append(ref_dict)
+        result = json.dumps(reference_dicts)
+        return self._limit_length(result, max_answer_chars)
+
+
+class ReplaceSymbolBodyTool(Tool, ToolMarkerSymbolicEdit):
+    """
+    Replaces the full definition of a symbol.
+    """
+
+    def apply(
+        self,
+        name_path: str,
+        relative_path: str,
+        body: str,
+    ) -> str:
+        r"""
+        Replaces the body of the symbol with the given `name_path`.
+
+        :param name_path: for finding the symbol to replace, same logic as in the `find_symbol` tool.
+        :param relative_path: the relative path to the file containing the symbol
+        :param body: the new symbol body. Important: Begin directly with the symbol definition and provide no
+            leading indentation for the first line (but do indent the rest of the body according to the context).
+        """
+        code_editor = self.create_code_editor()
+        code_editor.replace_body(
+            name_path,
+            relative_file_path=relative_path,
+            body=body,
+        )
+        return SUCCESS_RESULT
+
+
+class InsertAfterSymbolTool(Tool, ToolMarkerSymbolicEdit):
+    """
+    Inserts content after the end of the definition of a given symbol.
+    """
+
+    def apply(
+        self,
+        name_path: str,
+        relative_path: str,
+        body: str,
+    ) -> str:
+        """
+        Inserts the given body/content after the end of the definition of the given symbol (via the symbol's location).
+        A typical use case is to insert a new class, function, method, field or variable assignment.
+
+        :param name_path: name path of the symbol after which to insert content (definitions in the `find_symbol` tool apply)
+        :param relative_path: the relative path to the file containing the symbol
+        :param body: the body/content to be inserted. The inserted code shall begin with the next line after
+            the symbol.
+        """
+        code_editor = self.create_code_editor()
+        code_editor.insert_after_symbol(name_path, relative_file_path=relative_path, body=body)
+        return SUCCESS_RESULT
+
+
+class InsertBeforeSymbolTool(Tool, ToolMarkerSymbolicEdit):
+    """
+    Inserts content before the beginning of the definition of a given symbol.
+    """
+
+    def apply(
+        self,
+        name_path: str,
+        relative_path: str,
+        body: str,
+    ) -> str:
+        """
+        Inserts the given content before the beginning of the definition of the given symbol (via the symbol's location).
+        A typical use case is to insert a new class, function, method, field or variable assignment; or
+        a new import statement before the first symbol in the file.
+
+        :param name_path: name path of the symbol before which to insert content (definitions in the `find_symbol` tool apply)
+        :param relative_path: the relative path to the file containing the symbol
+        :param body: the body/content to be inserted before the line in which the referenced symbol is defined
+        """
+        code_editor = self.create_code_editor()
+        code_editor.insert_before_symbol(name_path, relative_file_path=relative_path, body=body)
+        return SUCCESS_RESULT

projects/ui/serena-new/src/serena/tools/tools_base.py

@@ -0,0 +1,418 @@
+import inspect
+import os
+from abc import ABC
+from collections.abc import Iterable
+from dataclasses import dataclass
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, Protocol, Self, TypeVar
+
+from mcp.server.fastmcp.utilities.func_metadata import FuncMetadata, func_metadata
+from sensai.util import logging
+from sensai.util.string import dict_string
+
+from serena.project import Project
+from serena.prompt_factory import PromptFactory
+from serena.symbol import LanguageServerSymbolRetriever
+from serena.util.class_decorators import singleton
+from serena.util.inspection import iter_subclasses
+from solidlsp.ls_exceptions import SolidLSPException
+
+if TYPE_CHECKING:
+    from serena.agent import LinesRead, MemoriesManager, SerenaAgent
+    from serena.code_editor import CodeEditor
+
+log = logging.getLogger(__name__)
+T = TypeVar("T")
+SUCCESS_RESULT = "OK"
+
+
+class Component(ABC):
+    def __init__(self, agent: "SerenaAgent"):
+        self.agent = agent
+
+    def get_project_root(self) -> str:
+        """
+        :return: the root directory of the active project, raises a ValueError if no active project configuration is set
+        """
+        return self.agent.get_project_root()
+
+    @property
+    def prompt_factory(self) -> PromptFactory:
+        return self.agent.prompt_factory
+
+    @property
+    def memories_manager(self) -> "MemoriesManager":
+        assert self.agent.memories_manager is not None
+        return self.agent.memories_manager
+
+    def create_language_server_symbol_retriever(self) -> LanguageServerSymbolRetriever:
+        if not self.agent.is_using_language_server():
+            raise Exception("Cannot create LanguageServerSymbolRetriever; agent is not in language server mode.")
+        language_server = self.agent.language_server
+        assert language_server is not None
+        return LanguageServerSymbolRetriever(language_server, agent=self.agent)
+
+    @property
+    def project(self) -> Project:
+        return self.agent.get_active_project_or_raise()
+
+    def create_code_editor(self) -> "CodeEditor":
+        from ..code_editor import JetBrainsCodeEditor, LanguageServerCodeEditor
+
+        if self.agent.is_using_language_server():
+            return LanguageServerCodeEditor(self.create_language_server_symbol_retriever(), agent=self.agent)
+        else:
+            return JetBrainsCodeEditor(project=self.project, agent=self.agent)
+
+    @property
+    def lines_read(self) -> "LinesRead":
+        assert self.agent.lines_read is not None
+        return self.agent.lines_read
+
+
+class ToolMarker:
+    """
+    Base class for tool markers.
+    """
+
+
+class ToolMarkerCanEdit(ToolMarker):
+    """
+    Marker class for all tools that can perform editing operations on files.
+    """
+
+
+class ToolMarkerDoesNotRequireActiveProject(ToolMarker):
+    pass
+
+
+class ToolMarkerOptional(ToolMarker):
+    """
+    Marker class for optional tools that are disabled by default.
+    """
+
+
+class ToolMarkerSymbolicRead(ToolMarker):
+    """
+    Marker class for tools that perform symbol read operations.
+    """
+
+
+class ToolMarkerSymbolicEdit(ToolMarkerCanEdit):
+    """
+    Marker class for tools that perform symbolic edit operations.
+    """
+
+
+class ApplyMethodProtocol(Protocol):
+    """Callable protocol for the apply method of a tool."""
+
+    def __call__(self, *args: Any, **kwargs: Any) -> str:
+        pass
+
+
+class Tool(Component):
+    # NOTE: each tool should implement the apply method, which is then used in
+    # the central method of the Tool class `apply_ex`.
+    # Failure to do so will result in a RuntimeError at tool execution time.
+    # The apply method is not declared as part of the base Tool interface since we cannot
+    # know the signature of the (input parameters of the) method in advance.
+    #
+    # The docstring and types of the apply method are used to generate the tool description
+    # (which is use by the LLM, so a good description is important)
+    # and to validate the tool call arguments.
+
+    @classmethod
+    def get_name_from_cls(cls) -> str:
+        name = cls.__name__
+        if name.endswith("Tool"):
+            name = name[:-4]
+        # convert to snake_case
+        name = "".join(["_" + c.lower() if c.isupper() else c for c in name]).lstrip("_")
+        return name
+
+    def get_name(self) -> str:
+        return self.get_name_from_cls()
+
+    def get_apply_fn(self) -> ApplyMethodProtocol:
+        apply_fn = getattr(self, "apply")
+        if apply_fn is None:
+            raise RuntimeError(f"apply not defined in {self}. Did you forget to implement it?")
+        return apply_fn
+
+    @classmethod
+    def can_edit(cls) -> bool:
+        """
+        Returns whether this tool can perform editing operations on code.
+
+        :return: True if the tool can edit code, False otherwise
+        """
+        return issubclass(cls, ToolMarkerCanEdit)
+
+    @classmethod
+    def get_tool_description(cls) -> str:
+        docstring = cls.__doc__
+        if docstring is None:
+            return ""
+        return docstring.strip()
+
+    @classmethod
+    def get_apply_docstring_from_cls(cls) -> str:
+        """Get the docstring for the apply method from the class (static metadata).
+        Needed for creating MCP tools in a separate process without running into serialization issues.
+        """
+        # First try to get from __dict__ to handle dynamic docstring changes
+        if "apply" in cls.__dict__:
+            apply_fn = cls.__dict__["apply"]
+        else:
+            # Fall back to getattr for inherited methods
+            apply_fn = getattr(cls, "apply", None)
+            if apply_fn is None:
+                raise AttributeError(f"apply method not defined in {cls}. Did you forget to implement it?")
+
+        docstring = apply_fn.__doc__
+        if not docstring:
+            raise AttributeError(f"apply method has no (or empty) docstring in {cls}. Did you forget to implement it?")
+        return docstring.strip()
+
+    def get_apply_docstring(self) -> str:
+        """Gets the docstring for the tool application, used by the MCP server."""
+        return self.get_apply_docstring_from_cls()
+
+    def get_apply_fn_metadata(self) -> FuncMetadata:
+        """Gets the metadata for the tool application function, used by the MCP server."""
+        return self.get_apply_fn_metadata_from_cls()
+
+    @classmethod
+    def get_apply_fn_metadata_from_cls(cls) -> FuncMetadata:
+        """Get the metadata for the apply method from the class (static metadata).
+        Needed for creating MCP tools in a separate process without running into serialization issues.
+        """
+        # First try to get from __dict__ to handle dynamic docstring changes
+        if "apply" in cls.__dict__:
+            apply_fn = cls.__dict__["apply"]
+        else:
+            # Fall back to getattr for inherited methods
+            apply_fn = getattr(cls, "apply", None)
+            if apply_fn is None:
+                raise AttributeError(f"apply method not defined in {cls}. Did you forget to implement it?")
+
+        return func_metadata(apply_fn, skip_names=["self", "cls"])
+
+    def _log_tool_application(self, frame: Any) -> None:
+        params = {}
+        ignored_params = {"self", "log_call", "catch_exceptions", "args", "apply_fn"}
+        for param, value in frame.f_locals.items():
+            if param in ignored_params:
+                continue
+            if param == "kwargs":
+                params.update(value)
+            else:
+                params[param] = value
+        log.info(f"{self.get_name_from_cls()}: {dict_string(params)}")
+
+    def _limit_length(self, result: str, max_answer_chars: int) -> str:
+        if max_answer_chars == -1:
+            max_answer_chars = self.agent.serena_config.default_max_tool_answer_chars
+        if max_answer_chars <= 0:
+            raise ValueError(f"Must be positive or the default (-1), got: {max_answer_chars=}")
+        if (n_chars := len(result)) > max_answer_chars:
+            result = (
+                f"The answer is too long ({n_chars} characters). "
+                + "Please try a more specific tool query or raise the max_answer_chars parameter."
+            )
+        return result
+
+    def is_active(self) -> bool:
+        return self.agent.tool_is_active(self.__class__)
+
+    def apply_ex(self, log_call: bool = True, catch_exceptions: bool = True, **kwargs) -> str:  # type: ignore
+        """
+        Applies the tool with logging and exception handling, using the given keyword arguments
+        """
+
+        def task() -> str:
+            apply_fn = self.get_apply_fn()
+
+            try:
+                if not self.is_active():
+                    return f"Error: Tool '{self.get_name_from_cls()}' is not active. Active tools: {self.agent.get_active_tool_names()}"
+            except Exception as e:
+                return f"RuntimeError while checking if tool {self.get_name_from_cls()} is active: {e}"
+
+            if log_call:
+                self._log_tool_application(inspect.currentframe())
+            try:
+                # check whether the tool requires an active project and language server
+                if not isinstance(self, ToolMarkerDoesNotRequireActiveProject):
+                    if self.agent._active_project is None:
+                        return (
+                            "Error: No active project. Ask to user to select a project from this list: "
+                            + f"{self.agent.serena_config.project_names}"
+                        )
+                    if self.agent.is_using_language_server() and not self.agent.is_language_server_running():
+                        log.info("Language server is not running. Starting it ...")
+                        self.agent.reset_language_server()
+
+                # apply the actual tool
+                try:
+                    result = apply_fn(**kwargs)
+                except SolidLSPException as e:
+                    if e.is_language_server_terminated():
+                        log.error(f"Language server terminated while executing tool ({e}). Restarting the language server and retrying ...")
+                        self.agent.reset_language_server()
+                        result = apply_fn(**kwargs)
+                    else:
+                        raise
+
+                # record tool usage
+                self.agent.record_tool_usage_if_enabled(kwargs, result, self)
+
+            except Exception as e:
+                if not catch_exceptions:
+                    raise
+                msg = f"Error executing tool: {e}"
+                log.error(f"Error executing tool: {e}", exc_info=e)
+                result = msg
+
+            if log_call:
+                log.info(f"Result: {result}")
+
+            try:
+                if self.agent.language_server is not None:
+                    self.agent.language_server.save_cache()
+            except Exception as e:
+                log.error(f"Error saving language server cache: {e}")
+
+            return result
+
+        future = self.agent.issue_task(task, name=self.__class__.__name__)
+        return future.result(timeout=self.agent.serena_config.tool_timeout)
+
+
+class EditedFileContext:
+    """
+    Context manager for file editing.
+
+    Create the context, then use `set_updated_content` to set the new content, the original content
+    being provided in `original_content`.
+    When exiting the context without an exception, the updated content will be written back to the file.
+    """
+
+    def __init__(self, relative_path: str, agent: "SerenaAgent"):
+        self._project = agent.get_active_project()
+        assert self._project is not None
+        self._abs_path = os.path.join(self._project.project_root, relative_path)
+        if not os.path.isfile(self._abs_path):
+            raise FileNotFoundError(f"File {self._abs_path} does not exist.")
+        with open(self._abs_path, encoding=self._project.project_config.encoding) as f:
+            self._original_content = f.read()
+        self._updated_content: str | None = None
+
+    def __enter__(self) -> Self:
+        return self
+
+    def get_original_content(self) -> str:
+        """
+        :return: the original content of the file before any modifications.
+        """
+        return self._original_content
+
+    def set_updated_content(self, content: str) -> None:
+        """
+        Sets the updated content of the file, which will be written back to the file
+        when the context is exited without an exception.
+
+        :param content: the updated content of the file
+        """
+        self._updated_content = content
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+        if self._updated_content is not None and exc_type is None:
+            assert self._project is not None
+            with open(self._abs_path, "w", encoding=self._project.project_config.encoding) as f:
+                f.write(self._updated_content)
+            log.info(f"Updated content written to {self._abs_path}")
+            # Language servers should automatically detect the change and update its state accordingly.
+            # If they do not, we may have to add a call to notify it.
+
+
+@dataclass(kw_only=True)
+class RegisteredTool:
+    tool_class: type[Tool]
+    is_optional: bool
+    tool_name: str
+
+
+@singleton
+class ToolRegistry:
+    def __init__(self) -> None:
+        self._tool_dict: dict[str, RegisteredTool] = {}
+        for cls in iter_subclasses(Tool):
+            if not cls.__module__.startswith("serena.tools"):
+                continue
+            is_optional = issubclass(cls, ToolMarkerOptional)
+            name = cls.get_name_from_cls()
+            if name in self._tool_dict:
+                raise ValueError(f"Duplicate tool name found: {name}. Tool classes must have unique names.")
+            self._tool_dict[name] = RegisteredTool(tool_class=cls, is_optional=is_optional, tool_name=name)
+
+    def get_tool_class_by_name(self, tool_name: str) -> type[Tool]:
+        return self._tool_dict[tool_name].tool_class
+
+    def get_all_tool_classes(self) -> list[type[Tool]]:
+        return list(t.tool_class for t in self._tool_dict.values())
+
+    def get_tool_classes_default_enabled(self) -> list[type[Tool]]:
+        """
+        :return: the list of tool classes that are enabled by default (i.e. non-optional tools).
+        """
+        return [t.tool_class for t in self._tool_dict.values() if not t.is_optional]
+
+    def get_tool_classes_optional(self) -> list[type[Tool]]:
+        """
+        :return: the list of tool classes that are optional (i.e. disabled by default).
+        """
+        return [t.tool_class for t in self._tool_dict.values() if t.is_optional]
+
+    def get_tool_names_default_enabled(self) -> list[str]:
+        """
+        :return: the list of tool names that are enabled by default (i.e. non-optional tools).
+        """
+        return [t.tool_name for t in self._tool_dict.values() if not t.is_optional]
+
+    def get_tool_names_optional(self) -> list[str]:
+        """
+        :return: the list of tool names that are optional (i.e. disabled by default).
+        """
+        return [t.tool_name for t in self._tool_dict.values() if t.is_optional]
+
+    def get_tool_names(self) -> list[str]:
+        """
+        :return: the list of all tool names.
+        """
+        return list(self._tool_dict.keys())
+
+    def print_tool_overview(
+        self, tools: Iterable[type[Tool] | Tool] | None = None, include_optional: bool = False, only_optional: bool = False
+    ) -> None:
+        """
+        Print a summary of the tools. If no tools are passed, a summary of the selection of tools (all, default or only optional) is printed.
+        """
+        if tools is None:
+            if only_optional:
+                tools = self.get_tool_classes_optional()
+            elif include_optional:
+                tools = self.get_all_tool_classes()
+            else:
+                tools = self.get_tool_classes_default_enabled()
+
+        tool_dict: dict[str, type[Tool] | Tool] = {}
+        for tool_class in tools:
+            tool_dict[tool_class.get_name_from_cls()] = tool_class
+        for tool_name in sorted(tool_dict.keys()):
+            tool_class = tool_dict[tool_name]
+            print(f" * `{tool_name}`: {tool_class.get_tool_description().strip()}")
+
+    def is_valid_tool_name(self, tool_name: str) -> bool:
+        return tool_name in self._tool_dict

projects/ui/serena-new/src/serena/tools/workflow_tools.py

@@ -0,0 +1,139 @@
+"""
+Tools supporting the general workflow of the agent
+"""
+
+import json
+import platform
+
+from serena.tools import Tool, ToolMarkerDoesNotRequireActiveProject, ToolMarkerOptional
+
+
+class CheckOnboardingPerformedTool(Tool):
+    """
+    Checks whether project onboarding was already performed.
+    """
+
+    def apply(self) -> str:
+        """
+        Checks whether project onboarding was already performed.
+        You should always call this tool before beginning to actually work on the project/after activating a project,
+        but after calling the initial instructions tool.
+        """
+        from .memory_tools import ListMemoriesTool
+
+        list_memories_tool = self.agent.get_tool(ListMemoriesTool)
+        memories = json.loads(list_memories_tool.apply())
+        if len(memories) == 0:
+            return (
+                "Onboarding not performed yet (no memories available). "
+                + "You should perform onboarding by calling the `onboarding` tool before proceeding with the task."
+            )
+        else:
+            return f"""The onboarding was already performed, below is the list of available memories.
+            Do not read them immediately, just remember that they exist and that you can read them later, if it is necessary
+            for the current task.
+            Some memories may be based on previous conversations, others may be general for the current project.
+            You should be able to tell which one you need based on the name of the memory.
+            
+            {memories}"""
+
+
+class OnboardingTool(Tool):
+    """
+    Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
+    """
+
+    def apply(self) -> str:
+        """
+        Call this tool if onboarding was not performed yet.
+        You will call this tool at most once per conversation.
+
+        :return: instructions on how to create the onboarding information
+        """
+        system = platform.system()
+        return self.prompt_factory.create_onboarding_prompt(system=system)
+
+
+class ThinkAboutCollectedInformationTool(Tool):
+    """
+    Thinking tool for pondering the completeness of collected information.
+    """
+
+    def apply(self) -> str:
+        """
+        Think about the collected information and whether it is sufficient and relevant.
+        This tool should ALWAYS be called after you have completed a non-trivial sequence of searching steps like
+        find_symbol, find_referencing_symbols, search_files_for_pattern, read_file, etc.
+        """
+        return self.prompt_factory.create_think_about_collected_information()
+
+
+class ThinkAboutTaskAdherenceTool(Tool):
+    """
+    Thinking tool for determining whether the agent is still on track with the current task.
+    """
+
+    def apply(self) -> str:
+        """
+        Think about the task at hand and whether you are still on track.
+        Especially important if the conversation has been going on for a while and there
+        has been a lot of back and forth.
+
+        This tool should ALWAYS be called before you insert, replace, or delete code.
+        """
+        return self.prompt_factory.create_think_about_task_adherence()
+
+
+class ThinkAboutWhetherYouAreDoneTool(Tool):
+    """
+    Thinking tool for determining whether the task is truly completed.
+    """
+
+    def apply(self) -> str:
+        """
+        Whenever you feel that you are done with what the user has asked for, it is important to call this tool.
+        """
+        return self.prompt_factory.create_think_about_whether_you_are_done()
+
+
+class SummarizeChangesTool(Tool, ToolMarkerOptional):
+    """
+    Provides instructions for summarizing the changes made to the codebase.
+    """
+
+    def apply(self) -> str:
+        """
+        Summarize the changes you have made to the codebase.
+        This tool should always be called after you have fully completed any non-trivial coding task,
+        but only after the think_about_whether_you_are_done call.
+        """
+        return self.prompt_factory.create_summarize_changes()
+
+
+class PrepareForNewConversationTool(Tool):
+    """
+    Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
+    """
+
+    def apply(self) -> str:
+        """
+        Instructions for preparing for a new conversation. This tool should only be called on explicit user request.
+        """
+        return self.prompt_factory.create_prepare_for_new_conversation()
+
+
+class InitialInstructionsTool(Tool, ToolMarkerDoesNotRequireActiveProject, ToolMarkerOptional):
+    """
+    Gets the initial instructions for the current project.
+    Should only be used in settings where the system prompt cannot be set,
+    e.g. in clients you have no control over, like Claude Desktop.
+    """
+
+    def apply(self) -> str:
+        """
+        Get the initial instructions for the current coding project.
+        If you haven't received instructions on how to use Serena's tools in the system prompt,
+        you should always call this tool before starting to work (including using any other tool) on any programming task,
+        the only exception being when you are asked to call `activate_project`, which you should then call before.
+        """
+        return self.agent.create_system_prompt()

projects/ui/serena-new/src/serena/util/class_decorators.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+
+# duplicate of interprompt.class_decorators
+# We don't want to depend on interprompt for this in serena, so we duplicate it here
+def singleton(cls: type[Any]) -> Any:
+    instance = None
+
+    def get_instance(*args: Any, **kwargs: Any) -> Any:
+        nonlocal instance
+        if instance is None:
+            instance = cls(*args, **kwargs)
+        return instance
+
+    return get_instance

projects/ui/serena-new/src/serena/util/exception.py

@@ -0,0 +1,65 @@
+import os
+import sys
+
+from serena.agent import log
+
+
+def is_headless_environment() -> bool:
+    """
+    Detect if we're running in a headless environment where GUI operations would fail.
+
+    Returns True if:
+    - No DISPLAY variable on Linux/Unix
+    - Running in SSH session
+    - Running in WSL without X server
+    - Running in Docker container
+    """
+    # Check if we're on Windows - GUI usually works there
+    if sys.platform == "win32":
+        return False
+
+    # Check for DISPLAY variable (required for X11)
+    if not os.environ.get("DISPLAY"):  # type: ignore
+        return True
+
+    # Check for SSH session
+    if os.environ.get("SSH_CONNECTION") or os.environ.get("SSH_CLIENT"):
+        return True
+
+    # Check for common CI/container environments
+    if os.environ.get("CI") or os.environ.get("CONTAINER") or os.path.exists("/.dockerenv"):
+        return True
+
+    # Check for WSL (only on Unix-like systems where os.uname exists)
+    if hasattr(os, "uname"):
+        if "microsoft" in os.uname().release.lower():
+            # In WSL, even with DISPLAY set, X server might not be running
+            # This is a simplified check - could be improved
+            return True
+
+    return False
+
+
+def show_fatal_exception_safe(e: Exception) -> None:
+    """
+    Shows the given exception in the GUI log viewer on the main thread and ensures that the exception is logged or at
+    least printed to stderr.
+    """
+    # Log the error and print it to stderr
+    log.error(f"Fatal exception: {e}", exc_info=e)
+    print(f"Fatal exception: {e}", file=sys.stderr)
+
+    # Don't attempt GUI in headless environments
+    if is_headless_environment():
+        log.debug("Skipping GUI error display in headless environment")
+        return
+
+    # attempt to show the error in the GUI
+    try:
+        # NOTE: The import can fail on macOS if Tk is not available (depends on Python interpreter installation, which uv
+        #   used as a base); while tkinter as such is always available, its dependencies can be unavailable on macOS.
+        from serena.gui_log_viewer import show_fatal_exception
+
+        show_fatal_exception(e)
+    except Exception as gui_error:
+        log.debug(f"Failed to show GUI error dialog: {gui_error}")

projects/ui/serena-new/src/serena/util/file_system.py

@@ -0,0 +1,346 @@
+import logging
+import os
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import NamedTuple
+
+import pathspec
+from pathspec import PathSpec
+from sensai.util.logging import LogTime
+
+log = logging.getLogger(__name__)
+
+
+class ScanResult(NamedTuple):
+    """Result of scanning a directory."""
+
+    directories: list[str]
+    files: list[str]
+
+
+def scan_directory(
+    path: str,
+    recursive: bool = False,
+    relative_to: str | None = None,
+    is_ignored_dir: Callable[[str], bool] = lambda x: False,
+    is_ignored_file: Callable[[str], bool] = lambda x: False,
+) -> ScanResult:
+    """
+    :param path: the path to scan
+    :param recursive: whether to recursively scan subdirectories
+    :param relative_to: the path to which the results should be relative to; if None, provide absolute paths
+    :param is_ignored_dir: a function with which to determine whether the given directory (abs. path) shall be ignored
+    :param is_ignored_file: a function with which to determine whether the given file (abs. path) shall be ignored
+    :return: the list of directories and files
+    """
+    files = []
+    directories = []
+
+    abs_path = os.path.abspath(path)
+    rel_base = os.path.abspath(relative_to) if relative_to else None
+
+    try:
+        with os.scandir(abs_path) as entries:
+            for entry in entries:
+                try:
+                    entry_path = entry.path
+
+                    if rel_base:
+                        result_path = os.path.relpath(entry_path, rel_base)
+                    else:
+                        result_path = entry_path
+
+                    if entry.is_file():
+                        if not is_ignored_file(entry_path):
+                            files.append(result_path)
+                    elif entry.is_dir():
+                        if not is_ignored_dir(entry_path):
+                            directories.append(result_path)
+                            if recursive:
+                                sub_result = scan_directory(
+                                    entry_path,
+                                    recursive=True,
+                                    relative_to=relative_to,
+                                    is_ignored_dir=is_ignored_dir,
+                                    is_ignored_file=is_ignored_file,
+                                )
+                                files.extend(sub_result.files)
+                                directories.extend(sub_result.directories)
+                except PermissionError as ex:
+                    # Skip files/directories that cannot be accessed due to permission issues
+                    log.debug(f"Skipping entry due to permission error: {entry.path}", exc_info=ex)
+                    continue
+    except PermissionError as ex:
+        # Skip the entire directory if it cannot be accessed
+        log.debug(f"Skipping directory due to permission error: {abs_path}", exc_info=ex)
+        return ScanResult([], [])
+
+    return ScanResult(directories, files)
+
+
+def find_all_non_ignored_files(repo_root: str) -> list[str]:
+    """
+    Find all non-ignored files in the repository, respecting all gitignore files in the repository.
+
+    :param repo_root: The root directory of the repository
+    :return: A list of all non-ignored files in the repository
+    """
+    gitignore_parser = GitignoreParser(repo_root)
+    _, files = scan_directory(
+        repo_root, recursive=True, is_ignored_dir=gitignore_parser.should_ignore, is_ignored_file=gitignore_parser.should_ignore
+    )
+    return files
+
+
+@dataclass
+class GitignoreSpec:
+    file_path: str
+    """Path to the gitignore file."""
+    patterns: list[str] = field(default_factory=list)
+    """List of patterns from the gitignore file.
+    The patterns are adjusted based on the gitignore file location.
+    """
+    pathspec: PathSpec = field(init=False)
+    """Compiled PathSpec object for pattern matching."""
+
+    def __post_init__(self) -> None:
+        """Initialize the PathSpec from patterns."""
+        self.pathspec = PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, self.patterns)
+
+    def matches(self, relative_path: str) -> bool:
+        """
+        Check if the given path matches any pattern in this gitignore spec.
+
+        :param relative_path: Path to check (should be relative to repo root)
+        :return: True if path matches any pattern
+        """
+        return match_path(relative_path, self.pathspec, root_path=os.path.dirname(self.file_path))
+
+
+class GitignoreParser:
+    """
+    Parser for gitignore files in a repository.
+
+    This class handles parsing multiple gitignore files throughout a repository
+    and provides methods to check if paths should be ignored.
+    """
+
+    def __init__(self, repo_root: str) -> None:
+        """
+        Initialize the parser for a repository.
+
+        :param repo_root: Root directory of the repository
+        """
+        self.repo_root = os.path.abspath(repo_root)
+        self.ignore_specs: list[GitignoreSpec] = []
+        self._load_gitignore_files()
+
+    def _load_gitignore_files(self) -> None:
+        """Load all gitignore files from the repository."""
+        with LogTime("Loading of .gitignore files", logger=log):
+            for gitignore_path in self._iter_gitignore_files():
+                log.info("Processing .gitignore file: %s", gitignore_path)
+                spec = self._create_ignore_spec(gitignore_path)
+                if spec.patterns:  # Only add non-empty specs
+                    self.ignore_specs.append(spec)
+
+    def _iter_gitignore_files(self, follow_symlinks: bool = False) -> Iterator[str]:
+        """
+        Iteratively discover .gitignore files in a top-down fashion, starting from the repository root.
+        Directory paths are skipped if they match any already loaded ignore patterns.
+
+        :return: an iterator yielding paths to .gitignore files (top-down)
+        """
+        queue: list[str] = [self.repo_root]
+
+        def scan(abs_path: str | None):
+            for entry in os.scandir(abs_path):
+                if entry.is_dir(follow_symlinks=follow_symlinks):
+                    queue.append(entry.path)
+                elif entry.is_file(follow_symlinks=follow_symlinks) and entry.name == ".gitignore":
+                    yield entry.path
+
+        while queue:
+            next_abs_path = queue.pop(0)
+            if next_abs_path != self.repo_root:
+                rel_path = os.path.relpath(next_abs_path, self.repo_root)
+                if self.should_ignore(rel_path):
+                    continue
+            yield from scan(next_abs_path)
+
+    def _create_ignore_spec(self, gitignore_file_path: str) -> GitignoreSpec:
+        """
+        Create a GitignoreSpec from a single gitignore file.
+
+        :param gitignore_file_path: Path to the .gitignore file
+        :return: GitignoreSpec object for the gitignore patterns
+        """
+        try:
+            with open(gitignore_file_path, encoding="utf-8") as f:
+                content = f.read()
+        except (OSError, UnicodeDecodeError):
+            # If we can't read the file, return an empty spec
+            return GitignoreSpec(gitignore_file_path, [])
+
+        gitignore_dir = os.path.dirname(gitignore_file_path)
+        patterns = self._parse_gitignore_content(content, gitignore_dir)
+
+        return GitignoreSpec(gitignore_file_path, patterns)
+
+    def _parse_gitignore_content(self, content: str, gitignore_dir: str) -> list[str]:
+        """
+        Parse gitignore content and adjust patterns based on the gitignore file location.
+
+        :param content: Content of the .gitignore file
+        :param gitignore_dir: Directory containing the .gitignore file (absolute path)
+        :return: List of adjusted patterns
+        """
+        patterns = []
+
+        # Get the relative path from repo root to the gitignore directory
+        rel_dir = os.path.relpath(gitignore_dir, self.repo_root)
+        if rel_dir == ".":
+            rel_dir = ""
+
+        for line in content.splitlines():
+            # Strip trailing whitespace (but preserve leading whitespace for now)
+            line = line.rstrip()
+
+            # Skip empty lines and comments
+            if not line or line.lstrip().startswith("#"):
+                continue
+
+            # Store whether this is a negation pattern
+            is_negation = line.startswith("!")
+            if is_negation:
+                line = line[1:]
+
+            # Strip leading/trailing whitespace after removing negation
+            line = line.strip()
+
+            if not line:
+                continue
+
+            # Handle escaped characters at the beginning
+            if line.startswith(("\\#", "\\!")):
+                line = line[1:]
+
+            # Determine if pattern is anchored to the gitignore directory and remove leading slash for processing
+            is_anchored = line.startswith("/")
+            if is_anchored:
+                line = line[1:]
+
+            # Adjust pattern based on gitignore file location
+            if rel_dir:
+                if is_anchored:
+                    # Anchored patterns are relative to the gitignore directory
+                    adjusted_pattern = os.path.join(rel_dir, line)
+                else:
+                    # Non-anchored patterns can match anywhere below the gitignore directory
+                    # We need to preserve this behavior
+                    if line.startswith("**/"):
+                        # Even if pattern starts with **, it should still be scoped to the subdirectory
+                        adjusted_pattern = os.path.join(rel_dir, line)
+                    else:
+                        # Add the directory prefix but also allow matching in subdirectories
+                        adjusted_pattern = os.path.join(rel_dir, "**", line)
+            else:
+                if is_anchored:
+                    # Anchored patterns in root should only match at root level
+                    # Add leading slash back to indicate root-only matching
+                    adjusted_pattern = "/" + line
+                else:
+                    # Non-anchored patterns can match anywhere
+                    adjusted_pattern = line
+
+            # Re-add negation if needed
+            if is_negation:
+                adjusted_pattern = "!" + adjusted_pattern
+
+            # Normalize path separators to forward slashes (gitignore uses forward slashes)
+            adjusted_pattern = adjusted_pattern.replace(os.sep, "/")
+
+            patterns.append(adjusted_pattern)
+
+        return patterns
+
+    def should_ignore(self, path: str) -> bool:
+        """
+        Check if a path should be ignored based on the gitignore rules.
+
+        :param path: Path to check (absolute or relative to repo_root)
+        :return: True if the path should be ignored, False otherwise
+        """
+        # Convert to relative path from repo root
+        if os.path.isabs(path):
+            try:
+                rel_path = os.path.relpath(path, self.repo_root)
+            except Exception as e:
+                # If the path could not be converted to a relative path,
+                # it is outside the repository root, so we ignore it
+                log.info("Ignoring path '%s' which is outside of the repository root (%s)", path, e)
+                return True
+        else:
+            rel_path = path
+
+        # Ignore paths inside .git
+        rel_path_first_path = Path(rel_path).parts[0]
+        if rel_path_first_path == ".git":
+            return True
+
+        abs_path = os.path.join(self.repo_root, rel_path)
+
+        # Normalize path separators
+        rel_path = rel_path.replace(os.sep, "/")
+
+        if os.path.exists(abs_path) and os.path.isdir(abs_path) and not rel_path.endswith("/"):
+            rel_path = rel_path + "/"
+
+        # Check against each ignore spec
+        for spec in self.ignore_specs:
+            if spec.matches(rel_path):
+                return True
+
+        return False
+
+    def get_ignore_specs(self) -> list[GitignoreSpec]:
+        """
+        Get all loaded gitignore specs.
+
+        :return: List of GitignoreSpec objects
+        """
+        return self.ignore_specs
+
+    def reload(self) -> None:
+        """Reload all gitignore files from the repository."""
+        self.ignore_specs.clear()
+        self._load_gitignore_files()
+
+
+def match_path(relative_path: str, path_spec: PathSpec, root_path: str = "") -> bool:
+    """
+    Match a relative path against a given pathspec. Just pathspec.match_file() is not enough,
+    we need to do some massaging to fix issues with pathspec matching.
+
+    :param relative_path: relative path to match against the pathspec
+    :param path_spec: the pathspec to match against
+    :param root_path: the root path from which the relative path is derived
+    :return:
+    """
+    normalized_path = str(relative_path).replace(os.path.sep, "/")
+
+    # We can have patterns like /src/..., which would only match corresponding paths from the repo root
+    # Unfortunately, pathspec can't know whether a relative path is relative to the repo root or not,
+    # so it will never match src/...
+    # The fix is to just always assume that the input path is relative to the repo root and to
+    # prefix it with /.
+    if not normalized_path.startswith("/"):
+        normalized_path = "/" + normalized_path
+
+    # pathspec can't handle the matching of directories if they don't end with a slash!
+    # see https://github.com/cpburnz/python-pathspec/issues/89
+    abs_path = os.path.abspath(os.path.join(root_path, relative_path))
+    if os.path.isdir(abs_path) and not normalized_path.endswith("/"):
+        normalized_path = normalized_path + "/"
+    return path_spec.match_file(normalized_path)