Add files using upload-large-folder tool

projects/ui/serena-new/.github/workflows/junie.yml

@@ -0,0 +1,21 @@
+name: Junie
+run-name: Junie run ${{ inputs.run_id }}
+
+permissions:
+  contents: write
+
+on:
+  workflow_dispatch:
+    inputs:
+      run_id:
+        description: "id of workflow process"
+        required: true
+      workflow_params:
+        description: "stringified params"
+        required: true
+
+jobs:
+  call-workflow-passing-data:
+    uses: jetbrains-junie/junie-workflows/.github/workflows/ej-issue.yml@main
+    with:
+      workflow_params: ${{ inputs.workflow_params }}

projects/ui/serena-new/.github/workflows/lint_and_docs.yaml

@@ -0,0 +1,47 @@
+name: Linting, Types and Docs Check
+
+on:
+  workflow_dispatch:  # Manual trigger only - workflow disabled from auto-running
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      id-token: write
+      pages: write
+      actions: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.11
+      
+      
+      # use uv package manager
+      - name: Install uv
+        run: pip install uv
+      - uses: actions/cache@v3
+        name: Cache dependencies
+        with:
+          path: ~/.cache/uv
+          key: uv-${{ hashFiles('pyproject.toml') }}
+      - name: Install dependencies
+        run: |
+          uv venv
+          uv pip install -e ".[dev]"
+      - name: Lint
+        run: uv run poe lint
+      - name: Types
+        run: uv run poe type-check
+      - name: Docs
+        run: uv run poe doc-build
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v2
+        with:
+          path: "docs/_build"
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v2

projects/ui/serena-new/.github/workflows/publish.yml

@@ -0,0 +1,54 @@
+name: Publish Python Package
+
+on:
+  release:
+    types: [created]
+
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Tag name for the release (e.g., v0.1.0)'
+        required: true
+        default: 'v0.1.0'
+
+env:
+  # Set this to true manually in the GitHub workflow UI if you want to publish to PyPI
+  # Will always publish to testpypi
+  PUBLISH_TO_PYPI: true
+
+jobs:
+  publish:
+    name: Publish the serena-agent package
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write  # Required for trusted publishing
+      contents: write  # Required for updating artifact
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          version: "latest"
+
+      - name: Build package
+        run: uv build
+
+      - name: Upload artifacts to GitHub Release
+        if: env.PUBLISH_TO_PYPI == 'true'
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ github.event.inputs.tag || github.ref_name }}
+          files: |
+            dist/*.tar.gz
+            dist/*.whl
+
+      - name: Publish to TestPyPI
+        run: uv publish --index testpypi
+
+      - name: Publish to PyPI (conditional)
+        if: env.PUBLISH_TO_PYPI == 'true'
+        run: uv publish

projects/ui/serena-new/.github/workflows/pytest.yml

@@ -0,0 +1,256 @@
+name: Tests on CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  cpu:
+    name: Tests on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.11"]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: "${{ matrix.python-version }}"
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ">=1.17.0"
+      - name: Ensure cached directory exist before calling cache-related actions
+        shell: bash
+        run: |
+          mkdir -p $HOME/.serena/language_servers/static
+          mkdir -p $HOME/.cache/go-build
+          mkdir -p $HOME/go/bin
+      # Add Go bin directory to PATH for this workflow
+      # GITHUB_PATH is a special file that GitHub Actions uses to modify PATH
+      # Writing to this file adds the directory to the PATH for subsequent steps
+      - name: Cache Go binaries
+        id: cache-go-binaries
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/go/bin
+            ~/.cache/go-build
+          key: go-binaries-${{ runner.os }}-gopls-latest
+      - name: Install gopls
+        if: steps.cache-go-binaries.outputs.cache-hit != 'true'
+        shell: bash
+        run: go install golang.org/x/tools/gopls@latest
+      - name: Set up Elixir
+        if: runner.os != 'Windows'
+        uses: erlef/setup-beam@v1
+        with:
+          elixir-version: "1.18.4"
+          otp-version: "26.1"
+#      Erlang currently not tested in CI, random hangings on macos, always hangs on ubuntu
+#      In local tests, erlang seems to work though
+#      - name: Install Erlang Language Server
+#        if: runner.os != 'Windows'
+#        shell: bash
+#        run: |
+#          # Install rebar3 if not already available
+#          which rebar3 || (curl -fsSL https://github.com/erlang/rebar3/releases/download/3.23.0/rebar3 -o /tmp/rebar3 && chmod +x /tmp/rebar3 && sudo mv /tmp/rebar3 /usr/local/bin/rebar3)
+#          # Clone and build erlang_ls
+#          git clone https://github.com/erlang-ls/erlang_ls.git /tmp/erlang_ls
+#          cd /tmp/erlang_ls
+#          make install PREFIX=/usr/local
+#          # Ensure erlang_ls is in PATH
+#          echo "$HOME/.local/bin" >> $GITHUB_PATH
+      - name: Install clojure tools
+        uses: DeLaGuardo/setup-clojure@13.4
+        with:
+          cli: latest
+      - name: Setup Java (for JVM based languages)
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+      - name: Install Terraform
+        uses: hashicorp/setup-terraform@v3
+        with:
+          terraform_version: "1.5.0"
+          terraform_wrapper: false
+      # - name: Install swift
+      #   if: runner.os != 'Windows'
+      #   uses: swift-actions/setup-swift@v2
+      # Installation of swift with the action screws with installation of ruby on macOS for some reason
+      # We can try again when version 3 of the action is released, where they will also use swiftly
+      # Until then, we use custom code to install swift. Sourcekit-lsp is installed automatically with swift
+      - name: Install Swift with swiftly (macOS)
+        if: runner.os == 'macOS'
+        run: |
+          echo "=== Installing swiftly on macOS ==="
+          curl -O https://download.swift.org/swiftly/darwin/swiftly.pkg && \
+          installer -pkg swiftly.pkg -target CurrentUserHomeDirectory && \
+          ~/.swiftly/bin/swiftly init --quiet-shell-followup && \
+          . "${SWIFTLY_HOME_DIR:-$HOME/.swiftly}/env.sh" && \
+          hash -r
+          swiftly install --use 6.1.2
+          swiftly use 6.1.2
+          echo "~/.swiftly/bin" >> $GITHUB_PATH
+          echo "Swiftly installed successfully"
+      - name: Install Swift with swiftly (Ubuntu)
+        if: runner.os == 'Linux'
+        run: |
+          echo "=== Installing swiftly on Ubuntu ==="
+          curl -O https://download.swift.org/swiftly/linux/swiftly-$(uname -m).tar.gz && \
+          tar zxf swiftly-$(uname -m).tar.gz && \
+          ./swiftly init --quiet-shell-followup && \
+          . "${SWIFTLY_HOME_DIR:-$HOME/.local/share/swiftly}/env.sh" && \
+          hash -r
+          swiftly install --use 6.1.2
+          swiftly use 6.1.2
+          sudo apt-get -y install libcurl4-openssl-dev
+          echo "=== Adding Swift toolchain to PATH ==="
+          echo "$HOME/.local/share/swiftly/bin" >> $GITHUB_PATH
+          echo "Swiftly installed successfully!"
+      - name: Install Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4'
+      - name: Install Ruby language server
+        shell: bash
+        run: gem install ruby-lsp
+      - name: Install R
+        uses: r-lib/actions/setup-r@v2
+        with:
+          r-version: '4.4.2'
+          use-public-rspm: true
+      - name: Install R language server
+        shell: bash
+        run: |
+          Rscript -e "install.packages('languageserver', repos='https://cloud.r-project.org')"
+      - name: Install Zig
+        uses: goto-bus-stop/setup-zig@v2
+        with:
+          version: 0.14.1
+      - name: Install ZLS (Zig Language Server)
+        shell: bash
+        run: |
+          if [[ "${{ runner.os }}" == "Linux" ]]; then
+            wget https://github.com/zigtools/zls/releases/download/0.14.0/zls-x86_64-linux.tar.xz
+            tar -xf zls-x86_64-linux.tar.xz
+            sudo mv zls /usr/local/bin/
+            rm zls-x86_64-linux.tar.xz
+          elif [[ "${{ runner.os }}" == "macOS" ]]; then
+            wget https://github.com/zigtools/zls/releases/download/0.14.0/zls-x86_64-macos.tar.xz
+            tar -xf zls-x86_64-macos.tar.xz
+            sudo mv zls /usr/local/bin/
+            rm zls-x86_64-macos.tar.xz
+          elif [[ "${{ runner.os }}" == "Windows" ]]; then
+            curl -L -o zls.zip https://github.com/zigtools/zls/releases/download/0.14.0/zls-x86_64-windows.zip
+            unzip -o zls.zip
+            mkdir -p "$HOME/bin"
+            mv zls.exe "$HOME/bin/"
+            echo "$HOME/bin" >> $GITHUB_PATH
+            rm zls.zip
+          fi
+      - name: Install Lua Language Server
+        shell: bash
+        run: |
+          LUA_LS_VERSION="3.15.0"
+          LUA_LS_DIR="$HOME/.serena/language_servers/lua"
+          mkdir -p "$LUA_LS_DIR"
+          
+          if [[ "${{ runner.os }}" == "Linux" ]]; then
+            if [[ "$(uname -m)" == "x86_64" ]]; then
+              wget https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-linux-x64.tar.gz
+              tar -xzf lua-language-server-${LUA_LS_VERSION}-linux-x64.tar.gz -C "$LUA_LS_DIR"
+            else
+              wget https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-linux-arm64.tar.gz
+              tar -xzf lua-language-server-${LUA_LS_VERSION}-linux-arm64.tar.gz -C "$LUA_LS_DIR"
+            fi
+            chmod +x "$LUA_LS_DIR/bin/lua-language-server"
+            # Create wrapper script instead of symlink to ensure supporting files are found
+            echo '#!/bin/bash' | sudo tee /usr/local/bin/lua-language-server > /dev/null
+            echo 'cd "${HOME}/.serena/language_servers/lua/bin"' | sudo tee -a /usr/local/bin/lua-language-server > /dev/null
+            echo 'exec ./lua-language-server "$@"' | sudo tee -a /usr/local/bin/lua-language-server > /dev/null
+            sudo chmod +x /usr/local/bin/lua-language-server
+            rm lua-language-server-*.tar.gz
+          elif [[ "${{ runner.os }}" == "macOS" ]]; then
+            if [[ "$(uname -m)" == "x86_64" ]]; then
+              wget https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-darwin-x64.tar.gz
+              tar -xzf lua-language-server-${LUA_LS_VERSION}-darwin-x64.tar.gz -C "$LUA_LS_DIR"
+            else
+              wget https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-darwin-arm64.tar.gz
+              tar -xzf lua-language-server-${LUA_LS_VERSION}-darwin-arm64.tar.gz -C "$LUA_LS_DIR"
+            fi
+            chmod +x "$LUA_LS_DIR/bin/lua-language-server"
+            # Create wrapper script instead of symlink to ensure supporting files are found
+            echo '#!/bin/bash' | sudo tee /usr/local/bin/lua-language-server > /dev/null
+            echo 'cd "${HOME}/.serena/language_servers/lua/bin"' | sudo tee -a /usr/local/bin/lua-language-server > /dev/null
+            echo 'exec ./lua-language-server "$@"' | sudo tee -a /usr/local/bin/lua-language-server > /dev/null
+            sudo chmod +x /usr/local/bin/lua-language-server
+            rm lua-language-server-*.tar.gz
+          elif [[ "${{ runner.os }}" == "Windows" ]]; then
+            curl -L -o lua-ls.zip https://github.com/LuaLS/lua-language-server/releases/download/${LUA_LS_VERSION}/lua-language-server-${LUA_LS_VERSION}-win32-x64.zip
+            unzip -o lua-ls.zip -d "$LUA_LS_DIR"
+            # For Windows, we'll add the bin directory directly to PATH
+            # The lua-language-server.exe can find its supporting files relative to its location
+            echo "$LUA_LS_DIR/bin" >> $GITHUB_PATH
+            rm lua-ls.zip
+          fi
+      - name: Install Nix
+        if: runner.os != 'Windows'  # Nix doesn't support Windows natively
+        uses: cachix/install-nix-action@v30
+        with:
+          nix_path: nixpkgs=channel:nixos-unstable
+      - name: Install nixd (Nix Language Server)
+        if: runner.os != 'Windows'  # Skip on Windows since Nix isn't available
+        shell: bash
+        run: |
+          # Install nixd using nix
+          nix profile install github:nix-community/nixd
+          
+          # Verify nixd is installed and working
+          if ! command -v nixd &> /dev/null; then
+            echo "nixd installation failed or not in PATH"
+            exit 1
+          fi
+          
+          echo "$HOME/.nix-profile/bin" >> $GITHUB_PATH
+      - name: Install uv
+        shell: bash
+        run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - name: Cache uv virtualenv
+        id: cache-uv
+        uses: actions/cache@v3
+        with:
+          path: .venv
+          key: uv-venv-${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
+      - name: Cache language servers
+        id: cache-language-servers
+        uses: actions/cache@v3
+        with:
+          path: ~/.serena/language_servers/static
+          key: language-servers-${{ runner.os }}-v1
+          restore-keys: |
+            language-servers-${{ runner.os }}-
+      - name: Create virtual environment
+        shell: bash
+        run: |
+          if [ ! -d ".venv" ]; then
+            uv venv
+          fi
+      - name: Install dependencies
+        shell: bash
+        run: uv pip install -e ".[dev]"
+      - name: Check formatting
+        shell: bash
+        run: uv run poe lint
+      - name: Test with pytest
+        shell: bash
+        run: uv run poe test

projects/ui/serena-new/.serena/memories/adding_new_language_support_guide.md

@@ -0,0 +1,224 @@
+# Adding New Language Support to Serena
+
+This guide explains how to add support for a new programming language to Serena.
+
+## Overview
+
+Adding a new language involves:
+
+1. **Language Server Implementation** - Creating a language-specific server class
+2. **Language Registration** - Adding the language to enums and configurations  
+3. **Test Repository** - Creating a minimal test project
+4. **Test Suite** - Writing comprehensive tests
+5. **Runtime Dependencies** - Configuring automatic language server downloads
+
+## Step 1: Language Server Implementation
+
+### 1.1 Create Language Server Class
+
+Create a new file in `src/solidlsp/language_servers/` (e.g., `new_language_server.py`).
+Have a look at `intelephense.py` for a reference implementation of a language server which downloads all its dependencies, at `gopls.py` for an LS that needs some preinstalled
+dependencies, and on `pyright_server.py` that does not need any additional dependencies
+because the language server can be installed directly as python package.
+
+
+```python
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import LanguageServerConfig
+from solidlsp.ls_logger import LanguageServerLogger
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+
+class NewLanguageServer(SolidLanguageServer):
+    """
+    Language server implementation for NewLanguage.
+    """
+    
+    def __init__(self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str):
+        # Determine language server command
+        cmd = self._get_language_server_command()
+        
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=cmd, cwd=repository_root_path),
+            "new_language",  # Language ID for LSP
+        )
+    
+    def _get_language_server_command(self) -> list[str]:
+        """Get the command to start the language server."""
+        # Example: return ["new-language-server", "--stdio"]
+        pass
+    
+    @override
+    def is_ignored_dirname(self, dirname: str) -> bool:
+        """Define language-specific directories to ignore."""
+        return super().is_ignored_dirname(dirname) or dirname in ["build", "dist", "target"]
+```
+
+### 1.2 Language Server Discovery and Installation
+
+For languages requiring automatic installation, implement download logic similar to C#:
+
+```python
+@classmethod
+def _ensure_server_installed(cls, logger: LanguageServerLogger) -> str:
+    """Ensure language server is installed and return path."""
+    # Check system installation first
+    system_server = shutil.which("new-language-server")
+    if system_server:
+        return system_server
+    
+    # Download and install if needed
+    server_path = cls._download_and_install_server(logger)
+    return server_path
+
+def _download_and_install_server(cls, logger: LanguageServerLogger) -> str:
+    """Download and install the language server."""
+    # Implementation specific to your language server
+    pass
+```
+
+### 1.3 LSP Initialization
+
+Override initialization methods if needed:
+
+```python
+def _get_initialize_params(self) -> InitializeParams:
+    """Return language-specific initialization parameters."""
+    return {
+        "processId": os.getpid(),
+        "rootUri": PathUtils.path_to_uri(self.repository_root_path),
+        "capabilities": {
+            # Language-specific capabilities
+        }
+    }
+
+def _start_server(self):
+    """Start the language server with custom handlers."""
+    # Set up notification handlers
+    self.server.on_notification("window/logMessage", self._handle_log_message)
+    
+    # Start server and initialize
+    self.server.start()
+    init_response = self.server.send.initialize(self._get_initialize_params())
+    self.server.notify.initialized({})
+```
+
+## Step 2: Language Registration
+
+### 2.1 Add to Language Enum
+
+In `src/solidlsp/ls_config.py`, add your language to the `Language` enum:
+
+```python
+class Language(str, Enum):
+    # Existing languages...
+    NEW_LANGUAGE = "new_language"
+    
+    def get_source_fn_matcher(self) -> FilenameMatcher:
+        match self:
+            # Existing cases...
+            case self.NEW_LANGUAGE:
+                return FilenameMatcher("*.newlang", "*.nl")  # File extensions
+```
+
+### 2.2 Update Language Server Factory
+
+In `src/solidlsp/ls.py`, add your language to the `create` method:
+
+```python
+@classmethod
+def create(cls, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str) -> "SolidLanguageServer":
+    match config.code_language:
+        # Existing cases...
+        case Language.NEW_LANGUAGE:
+            from solidlsp.language_servers.new_language_server import NewLanguageServer
+            return NewLanguageServer(config, logger, repository_root_path)
+```
+
+## Step 3: Test Repository
+
+### 3.1 Create Test Project
+
+Create a minimal project in `test/resources/repos/new_language/test_repo/`:
+
+```
+test/resources/repos/new_language/test_repo/
+├── main.newlang              # Main source file
+├── lib/
+│   └── helper.newlang       # Additional source for testing
+├── project.toml             # Project configuration (if applicable)
+└── .gitignore              # Ignore build artifacts
+```
+
+### 3.2 Example Source Files
+
+Create meaningful source files that demonstrate:
+
+- **Classes/Types** - For symbol testing
+- **Functions/Methods** - For reference finding
+- **Imports/Dependencies** - For cross-file operations
+- **Nested Structures** - For hierarchical symbol testing
+
+Example `main.newlang`:
+```
+import lib.helper
+
+class Calculator {
+    func add(a: Int, b: Int) -> Int {
+        return a + b
+    }
+    
+    func subtract(a: Int, b: Int) -> Int {
+        return helper.subtract(a, b)  // Reference to imported function
+    }
+}
+
+class Program {
+    func main() {
+        let calc = Calculator()
+        let result = calc.add(5, 3)  // Reference to add method
+        print(result)
+    }
+}
+```
+
+## Step 4: Test Suite
+
+Testing the language server implementation is of crucial importance, and the tests will
+form the main part of the review process. Make sure that the tests are up to the standard
+of Serena to make the review go smoother.
+
+General rules for tests:
+
+1. Tests for symbols and references should always check that the expected symbol names and references were actually found.
+   Just testing that a list came back or that the result is not None is insufficient.
+2. Tests should never be skipped, the only exception is skipping based on some package being available or on an unsupported OS.
+3. Tests should run in CI, check if there is a suitable GitHub action for installing the dependencies.
+
+### 4.1 Basic Tests
+
+Create `test/solidlsp/new_language/test_new_language_basic.py`.
+Have a look at the structure of existing tests, for example, in `test/solidlsp/php/test_php_basic.py`
+You should at least test:
+
+1. Finding symbols
+2. Finding within-file references
+3. Finding cross-file references
+
+Have a look at `test/solidlsp/php/test_php_basic.py` as an example for what should be tested.
+Don't forget to add a new language marker to `pytest.ini`.
+
+### 4.2 Integration Tests
+
+Consider adding new cases to the parametrized tests in `test_serena_agent.py` for the new language.
+
+
+### 5 Documentation
+
+Update:
+
+- **README.md** - Add language to supported languages list
+- **CHANGELOG.md** - Document the new language support
+- **Language-specific docs** - Installation requirements, known issues

projects/ui/serena-new/.serena/memories/serena_core_concepts_and_architecture.md

@@ -0,0 +1,175 @@
+# Serena Core Concepts and Architecture
+
+## High-Level Architecture
+
+Serena is built around a dual-layer architecture:
+
+1. **SerenaAgent** - The main orchestrator that manages projects, tools, and user interactions
+2. **SolidLanguageServer** - A unified wrapper around Language Server Protocol (LSP) implementations
+
+## Core Components
+
+### 1. SerenaAgent (`src/serena/agent.py`)
+
+The central coordinator that:
+- Manages active projects and their configurations
+- Coordinates between different tools and contexts
+- Handles language server lifecycle
+- Manages memory persistence
+- Provides MCP (Model Context Protocol) server interface
+
+Key responsibilities:
+- **Project Management** - Activating, switching between projects
+- **Tool Registry** - Loading and managing available tools based on context/mode
+- **Language Server Integration** - Starting/stopping language servers per project
+- **Memory Management** - Persistent storage of project knowledge
+- **Task Execution** - Coordinating complex multi-step operations
+
+### 2. SolidLanguageServer (`src/solidlsp/ls.py`)
+
+A unified abstraction over multiple language servers that provides:
+- **Language-agnostic interface** for symbol operations
+- **Caching layer** for performance optimization
+- **Error handling and recovery** for unreliable language servers
+- **Uniform API** regardless of underlying LSP implementation
+
+Core capabilities:
+- Symbol discovery and navigation
+- Code completion and hover information
+- Find references and definitions
+- Document and workspace symbol search
+- File watching and change notifications
+
+### 3. Tool System (`src/serena/tools/`)
+
+Modular tool architecture with several categories:
+
+#### File Tools (`file_tools.py`)
+- File system operations (read, write, list directories)
+- Text search and pattern matching
+- Regex-based replacements
+
+#### Symbol Tools (`symbol_tools.py`)  
+- Language-aware symbol finding and navigation
+- Symbol body replacement and insertion
+- Reference finding across codebase
+
+#### Memory Tools (`memory_tools.py`)
+- Project knowledge persistence
+- Memory retrieval and management
+- Onboarding information storage
+
+#### Configuration Tools (`config_tools.py`)
+- Project activation and switching
+- Mode and context management
+- Tool inclusion/exclusion
+
+### 4. Configuration System (`src/serena/config/`)
+
+Multi-layered configuration supporting:
+- **Contexts** - Define available tools and their behavior
+- **Modes** - Specify operational patterns (interactive, editing, etc.)
+- **Projects** - Per-project settings and language server configs
+- **Tool Sets** - Grouped tool collections for different use cases
+
+## Language Server Integration
+
+### Language Support Model
+
+Each supported language has:
+1. **Language Server Implementation** (`src/solidlsp/language_servers/`)
+2. **Runtime Dependencies** - Managed downloads of language servers
+3. **Test Repository** (`test/resources/repos/<language>/`)
+4. **Test Suite** (`test/solidlsp/<language>/`)
+
+### Language Server Lifecycle
+
+1. **Discovery** - Find language servers or download them automatically
+2. **Initialization** - Start server process and perform LSP handshake
+3. **Project Setup** - Open workspace and configure language-specific settings
+4. **Operation** - Handle requests/responses with caching and error recovery
+5. **Shutdown** - Clean shutdown of server processes
+
+### Supported Languages
+
+Current language support includes:
+- **C#** - Microsoft.CodeAnalysis.LanguageServer (.NET 9)
+- **Python** - Pyright or Jedi
+- **TypeScript/JavaScript** - TypeScript Language Server
+- **Rust** - rust-analyzer
+- **Go** - gopls
+- **Java** - Eclipse JDT Language Server
+- **Kotlin** - Kotlin Language Server
+- **PHP** - Intelephense
+- **Ruby** - Solargraph
+- **Clojure** - clojure-lsp
+- **Elixir** - ElixirLS
+- **Dart** - Dart Language Server
+- **C/C++** - clangd
+- **Terraform** - terraform-ls
+
+## Memory and Knowledge Management
+
+### Memory System
+- **Markdown-based storage** in `.serena/memories/` directory
+- **Contextual retrieval** - memories loaded based on relevance
+- **Project-specific** knowledge persistence
+- **Onboarding support** - guided setup for new projects
+
+### Knowledge Categories
+- **Project Structure** - Directory layouts, build systems
+- **Architecture Patterns** - How the codebase is organized
+- **Development Workflows** - Testing, building, deployment
+- **Domain Knowledge** - Business logic and requirements
+
+## MCP Server Interface
+
+Serena exposes its functionality through Model Context Protocol:
+- **Tool Discovery** - AI agents can enumerate available tools
+- **Context-Aware Operations** - Tools behave based on active project/mode
+- **Stateful Sessions** - Maintains project state across interactions
+- **Error Handling** - Graceful degradation when tools fail
+
+## Error Handling and Resilience
+
+### Language Server Reliability
+- **Timeout Management** - Configurable timeouts for LSP requests
+- **Process Recovery** - Automatic restart of crashed language servers
+- **Fallback Behavior** - Graceful degradation when LSP unavailable
+- **Caching Strategy** - Reduces impact of server failures
+
+### Project Activation Safety
+- **Validation** - Verify project structure before activation
+- **Error Isolation** - Project failures don't affect other projects
+- **Recovery Mechanisms** - Automatic cleanup and retry logic
+
+## Performance Considerations
+
+### Caching Strategy
+- **Symbol Cache** - In-memory caching of expensive symbol operations
+- **File System Cache** - Reduced disk I/O for repeated operations
+- **Language Server Cache** - Persistent cache across sessions
+
+### Resource Management
+- **Language Server Pooling** - Reuse servers across projects when possible
+- **Memory Management** - Automatic cleanup of unused resources
+- **Background Operations** - Async operations don't block user interactions
+
+## Extension Points
+
+### Adding New Languages
+1. Implement language server class in `src/solidlsp/language_servers/`
+2. Add runtime dependencies configuration
+3. Create test repository and test suite
+4. Update language enumeration and configuration
+
+### Adding New Tools
+1. Inherit from `Tool` base class in `tools_base.py`
+2. Implement required methods and parameter validation
+3. Register tool in appropriate tool registry
+4. Add to context/mode configurations as needed
+
+### Custom Contexts and Modes
+- Define new contexts in YAML configuration files
+- Specify tool sets and operational patterns
+- Configure for specific development workflows

projects/ui/serena-new/.serena/memories/serena_repository_structure.md

@@ -0,0 +1,113 @@
+# Serena Repository Structure
+
+## Overview
+Serena is a multi-language code assistant that combines two main components:
+1. **Serena Core** - The main agent framework with tools and MCP server
+2. **SolidLSP** - A unified Language Server Protocol wrapper for multiple programming languages
+
+## Top-Level Structure
+
+```
+serena/
+├── src/                          # Main source code
+│   ├── serena/                   # Serena agent framework
+│   ├── solidlsp/                 # LSP wrapper library  
+│   └── interprompt/              # Multi-language prompt templates
+├── test/                         # Test suites
+│   ├── serena/                   # Serena agent tests
+│   ├── solidlsp/                 # Language server tests
+│   └── resources/repos/          # Test repositories for each language
+├── scripts/                      # Build and utility scripts
+├── resources/                    # Static resources and configurations
+├── pyproject.toml               # Python project configuration
+├── README.md                    # Project documentation
+└── CHANGELOG.md                 # Version history
+```
+
+## Source Code Organization
+
+### Serena Core (`src/serena/`)
+- **`agent.py`** - Main SerenaAgent class that orchestrates everything
+- **`tools/`** - MCP tools for file operations, symbols, memory, etc.
+  - `file_tools.py` - File system operations (read, write, search)
+  - `symbol_tools.py` - Symbol-based code operations (find, edit)
+  - `memory_tools.py` - Knowledge persistence and retrieval
+  - `config_tools.py` - Project and mode management
+  - `workflow_tools.py` - Onboarding and meta-operations
+- **`config/`** - Configuration management
+  - `serena_config.py` - Main configuration classes
+  - `context_mode.py` - Context and mode definitions
+- **`util/`** - Utility modules
+- **`mcp.py`** - MCP server implementation
+- **`cli.py`** - Command-line interface
+
+### SolidLSP (`src/solidlsp/`)
+- **`ls.py`** - Main SolidLanguageServer class
+- **`language_servers/`** - Language-specific implementations
+  - `csharp_language_server.py` - C# (Microsoft.CodeAnalysis.LanguageServer)
+  - `python_server.py` - Python (Pyright)
+  - `typescript_language_server.py` - TypeScript
+  - `rust_analyzer.py` - Rust
+  - `gopls.py` - Go
+  - And many more...
+- **`ls_config.py`** - Language server configuration
+- **`ls_types.py`** - LSP type definitions
+- **`ls_utils.py`** - Utilities for working with LSP data
+
+### Interprompt (`src/interprompt/`)
+- Multi-language prompt template system
+- Jinja2-based templating with language fallbacks
+
+## Test Structure
+
+### Language Server Tests (`test/solidlsp/`)
+Each language has its own test directory:
+```
+test/solidlsp/
+├── csharp/
+│   └── test_csharp_basic.py
+├── python/
+│   └── test_python_basic.py
+├── typescript/
+│   └── test_typescript_basic.py
+└── ...
+```
+
+### Test Resources (`test/resources/repos/`)
+Contains minimal test projects for each language:
+```
+test/resources/repos/
+├── csharp/test_repo/
+│   ├── serena.sln
+│   ├── TestProject.csproj
+│   ├── Program.cs
+│   └── Models/Person.cs
+├── python/test_repo/
+├── typescript/test_repo/
+└── ...
+```
+
+### Test Infrastructure
+- **`test/conftest.py`** - Shared test fixtures and utilities
+- **`create_ls()`** function - Creates language server instances for testing
+- **`language_server` fixture** - Parametrized fixture for multi-language tests
+
+## Key Configuration Files
+
+- **`pyproject.toml`** - Python dependencies, build config, and tool settings
+- **`.serena/`** directories - Project-specific Serena configuration and memories
+- **`CLAUDE.md`** - Instructions for AI assistants working on the project
+
+## Dependencies Management
+
+The project uses modern Python tooling:
+- **uv** for fast dependency resolution and virtual environments
+- **pytest** for testing with language-specific markers (`@pytest.mark.csharp`)
+- **ruff** for linting and formatting
+- **mypy** for type checking
+
+## Build and Development
+
+- **Docker support** - Full containerized development environment
+- **GitHub Actions** - CI/CD with language server testing
+- **Development scripts** in `scripts/` directory

projects/ui/serena-new/.serena/memories/suggested_commands.md

@@ -0,0 +1,26 @@
+# Suggested Commands
+
+## Development Tasks (using uv and poe)
+
+The following tasks should generally be executed using `uv run poe <task_name>`.
+
+- `format`: This is the **only** allowed command for formatting. Run as `uv run poe format`.
+- `type-check`: This is the **only** allowed command for type checking. Run as `uv run poe type-check`.
+- `test`: This is the preferred command for running tests (`uv run poe test [args]`). You can select subsets of tests with markers,
+   the current markers are
+   ```toml
+    markers = [
+        "python: language server running for Python",
+        "go: language server running for Go",
+        "java: language server running for Java",
+        "rust: language server running for Rust",
+        "typescript: language server running for TypeScript",
+        "php: language server running for PHP",
+        "snapshot: snapshot tests for symbolic editing operations",
+    ]
+   ```
+  By default, `uv run poe test` uses the markers set in the env var `PYTEST_MARKERS`, or, if it unset, uses `-m "not java and not rust and not isolated process"`.
+  You can override this behavior by simply passing the `-m` option to `uv run poe test`, e.g. `uv run poe test -m "python or go"`.
+
+For finishing a task, make sure format, type-check and test pass! Run them at the end of the task
+and if needed fix any issues that come up and run them again until they pass.

projects/ui/serena-new/src/interprompt/.syncCommitId.remote

@@ -0,0 +1 @@
+6bdf19b0fd0fa5a809e1989b334bbfe9d8a7051a

projects/ui/serena-new/src/interprompt/.syncCommitId.this

@@ -0,0 +1 @@
+6d9d3adac8e77fa72e55e2675c1bcd3a7331cde1

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

@@ -0,0 +1,3 @@
+from .prompt_factory import autogenerate_prompt_factory_module
+
+__all__ = ["autogenerate_prompt_factory_module"]

projects/ui/serena-new/src/interprompt/jinja_template.py

@@ -0,0 +1,43 @@
+from typing import Any
+
+import jinja2
+import jinja2.meta
+import jinja2.nodes
+import jinja2.visitor
+
+from interprompt.util.class_decorators import singleton
+
+
+class ParameterizedTemplateInterface:
+    def get_parameters(self) -> list[str]: ...
+
+
+@singleton
+class _JinjaEnvProvider:
+    def __init__(self) -> None:
+        self._env: jinja2.Environment | None = None
+
+    def get_env(self) -> jinja2.Environment:
+        if self._env is None:
+            self._env = jinja2.Environment()
+        return self._env
+
+
+class JinjaTemplate(ParameterizedTemplateInterface):
+    def __init__(self, template_string: str) -> None:
+        self._template_string = template_string
+        self._template = _JinjaEnvProvider().get_env().from_string(self._template_string)
+        parsed_content = self._template.environment.parse(self._template_string)
+        self._parameters = sorted(jinja2.meta.find_undeclared_variables(parsed_content))
+
+    def render(self, **params: Any) -> str:
+        """Renders the template with the given kwargs. You can find out which parameters are required by calling get_parameter_names()."""
+        return self._template.render(**params)
+
+    def get_parameters(self) -> list[str]:
+        """A sorted list of parameter names that are extracted from the template string. It is impossible to know the types of the parameter
+        values, they can be primitives, dicts or dict-like objects.
+
+        :return: the list of parameter names
+        """
+        return self._parameters

projects/ui/serena-new/src/interprompt/multilang_prompt.py

@@ -0,0 +1,388 @@
+import logging
+import os
+from enum import Enum
+from typing import Any, Generic, Literal, TypeVar
+
+import yaml
+from sensai.util.string import ToStringMixin
+
+from .jinja_template import JinjaTemplate, ParameterizedTemplateInterface
+
+log = logging.getLogger(__name__)
+
+
+class PromptTemplate(ToStringMixin, ParameterizedTemplateInterface):
+    def __init__(self, name: str, jinja_template_string: str) -> None:
+        self.name = name
+        self._jinja_template = JinjaTemplate(jinja_template_string.strip())
+
+    def _tostring_exclude_private(self) -> bool:
+        return True
+
+    def render(self, **params: Any) -> str:
+        return self._jinja_template.render(**params)
+
+    def get_parameters(self) -> list[str]:
+        return self._jinja_template.get_parameters()
+
+
+class PromptList:
+    def __init__(self, items: list[str]) -> None:
+        self.items = [x.strip() for x in items]
+
+    def to_string(self) -> str:
+        bullet = " * "
+        indent = " " * len(bullet)
+        items = [x.replace("\n", "\n" + indent) for x in self.items]
+        return "\n * ".join(items)
+
+
+T = TypeVar("T")
+DEFAULT_LANG_CODE = "default"
+
+
+class LanguageFallbackMode(Enum):
+    """
+    Defines what to do if there is no item for the given language.
+    """
+
+    ANY = "any"
+    """
+    Return the item for any language (the first one found)
+    """
+    EXCEPTION = "exception"
+    """
+    If the requested language is not found, raise an exception
+    """
+    USE_DEFAULT_LANG = "use_default_lang"
+    """
+    If the requested language is not found, use the default language
+    """
+
+
+class _MultiLangContainer(Generic[T], ToStringMixin):
+    """
+    A container of items (usually, all having the same semantic meaning) which are associated with different languages.
+    Can also be used for single-language purposes by always using the default language code.
+    """
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self._lang2item: dict[str, T] = {}
+        """Maps language codes to items"""
+
+    def _tostring_excludes(self) -> list[str]:
+        return ["lang2item"]
+
+    def _tostring_additional_entries(self) -> dict[str, Any]:
+        return dict(languages=list(self._lang2item.keys()))
+
+    def get_language_codes(self) -> list[str]:
+        """The language codes for which items are registered in the container."""
+        return list(self._lang2item.keys())
+
+    def add_item(self, item: T, lang_code: str = DEFAULT_LANG_CODE, allow_overwrite: bool = False) -> None:
+        """Adds an item to the container, representing the same semantic entity as the other items in the container but in a different language.
+
+        :param item: the item to add
+        :param lang_code: the language shortcode for which to add the item. Use the default for single-language use cases.
+        :param allow_overwrite: if True, allow overwriting an existing entry for the same language
+        """
+        if not allow_overwrite and lang_code in self._lang2item:
+            raise KeyError(f"Item for language '{lang_code}' already registered for name '{self.name}'")
+        self._lang2item[lang_code] = item
+
+    def has_item(self, lang_code: str = DEFAULT_LANG_CODE) -> bool:
+        return lang_code in self._lang2item
+
+    def get_item(self, lang: str = DEFAULT_LANG_CODE, fallback_mode: LanguageFallbackMode = LanguageFallbackMode.EXCEPTION) -> T:
+        """
+        Gets the item for the given language.
+
+        :param lang: the language shortcode for which to obtain the prompt template. A default language can be specified.
+        :param fallback_mode: defines what to do if there is no item for the given language
+        :return: the item
+        """
+        try:
+            return self._lang2item[lang]
+        except KeyError as outer_e:
+            if fallback_mode == LanguageFallbackMode.EXCEPTION:
+                raise KeyError(f"Item for language '{lang}' not found for name '{self.name}'") from outer_e
+            if fallback_mode == LanguageFallbackMode.ANY:
+                try:
+                    return next(iter(self._lang2item.values()))
+                except StopIteration as e:
+                    raise KeyError(f"No items registered for any language in container '{self.name}'") from e
+            if fallback_mode == LanguageFallbackMode.USE_DEFAULT_LANG:
+                try:
+                    return self._lang2item[DEFAULT_LANG_CODE]
+                except KeyError as e:
+                    raise KeyError(
+                        f"Item not found neither for {lang=} nor for the default language '{DEFAULT_LANG_CODE}' in container '{self.name}'"
+                    ) from e
+
+    def __len__(self) -> int:
+        return len(self._lang2item)
+
+
+class MultiLangPromptTemplate(ParameterizedTemplateInterface):
+    """
+    Represents a prompt template with support for multiple languages.
+    The parameters of all prompt templates (for all languages) are (must be) the same.
+    """
+
+    def __init__(self, name: str) -> None:
+        self._prompts_container = _MultiLangContainer[PromptTemplate](name)
+
+    def __len__(self) -> int:
+        return len(self._prompts_container)
+
+    @property
+    def name(self) -> str:
+        return self._prompts_container.name
+
+    def add_prompt_template(
+        self, prompt_template: PromptTemplate, lang_code: str = DEFAULT_LANG_CODE, allow_overwrite: bool = False
+    ) -> None:
+        """
+        Adds a prompt template for a new language.
+        The parameters of all prompt templates (for all languages) are (must be) the same, so if a prompt template is already registered,
+        the parameters of the new prompt template should be the same as the existing ones.
+
+        :param prompt_template: the prompt template to add
+        :param lang_code: the language code for which to add the prompt template. For single-language use cases, you should always use the default language code.
+        :param allow_overwrite: whether to allow overwriting an existing entry for the same language
+        """
+        incoming_parameters = prompt_template.get_parameters()
+        if len(self) > 0:
+            parameters = self.get_parameters()
+            if parameters != incoming_parameters:
+                raise ValueError(
+                    f"Cannot add prompt template for language '{lang_code}' to MultiLangPromptTemplate '{self.name}'"
+                    f"because the parameters are inconsistent: {parameters} vs {prompt_template.get_parameters()}"
+                )
+
+        self._prompts_container.add_item(prompt_template, lang_code, allow_overwrite)
+
+    def get_prompt_template(
+        self, lang_code: str = DEFAULT_LANG_CODE, fallback_mode: LanguageFallbackMode = LanguageFallbackMode.EXCEPTION
+    ) -> PromptTemplate:
+        return self._prompts_container.get_item(lang_code, fallback_mode)
+
+    def get_parameters(self) -> list[str]:
+        if len(self) == 0:
+            raise RuntimeError(
+                f"No prompt templates registered for MultiLangPromptTemplate '{self.name}', make sure to register a prompt template before accessing the parameters"
+            )
+        first_prompt_template = next(iter(self._prompts_container._lang2item.values()))
+        return first_prompt_template.get_parameters()
+
+    def render(
+        self,
+        params: dict[str, Any],
+        lang_code: str = DEFAULT_LANG_CODE,
+        fallback_mode: LanguageFallbackMode = LanguageFallbackMode.EXCEPTION,
+    ) -> str:
+        prompt_template = self.get_prompt_template(lang_code, fallback_mode)
+        return prompt_template.render(**params)
+
+    def has_item(self, lang_code: str = DEFAULT_LANG_CODE) -> bool:
+        return self._prompts_container.has_item(lang_code)
+
+
+class MultiLangPromptList(_MultiLangContainer[PromptList]):
+    pass
+
+
+class MultiLangPromptCollection:
+    """
+    Main class for managing a collection of prompt templates and prompt lists, with support for multiple languages.
+    All data will be read from the yamls directly contained in the given directory on initialization.
+    It is thus assumed that you manage one directory per prompt collection.
+
+    The yamls are assumed to be either of the form
+
+    ```yaml
+    lang: <language_code> # optional, defaults to "default"
+    prompts:
+      <prompt_name>:
+        <prompt_template_string>
+      <prompt_list_name>: [<prompt_string_1>, <prompt_string_2>, ...]
+
+    ```
+
+    When specifying prompt templates for multiple languages, make sure that the Jinja template parameters
+    (inferred from the things inside the `{{ }}` in the template strings) are the same for all languages
+    (you will get an exception otherwise).
+
+    The prompt names must be unique (for the same language) within the collection.
+    """
+
+    def __init__(self, prompts_dir: str | list[str], fallback_mode: LanguageFallbackMode = LanguageFallbackMode.EXCEPTION) -> None:
+        """
+        :param prompts_dir: the directory containing the prompt templates and prompt lists.
+            If a list is provided, will look for prompt templates in the dirs from left to right
+            (first one containing the desired template wins).
+        :param fallback_mode: the fallback mode to use when a prompt template or prompt list is not found for the requested language.
+            May be reset after initialization.
+        """
+        self._multi_lang_prompt_templates: dict[str, MultiLangPromptTemplate] = {}
+        self._multi_lang_prompt_lists: dict[str, MultiLangPromptList] = {}
+        if isinstance(prompts_dir, str):
+            prompts_dir = [prompts_dir]
+
+        # Add prompts from multiple directories, prioritizing names from the left.
+        # If name collisions appear in the first directory, an error is raised (so the first directory should have no
+        # internal collisions, this helps in avoiding errors)
+        # For all following directories, on a collision the new value will be ignored.
+        # This also means that for the following directories, there is no error check on collisions internal to them.
+        # We assume that they are correct (i.e., they have no internal collisions).
+        first_prompts_dir, fallback_prompt_dirs = prompts_dir[0], prompts_dir[1:]
+        self._load_from_disc(first_prompts_dir, on_name_collision="raise")
+        for fallback_prompt_dir in fallback_prompt_dirs:
+            # already loaded prompts have priority
+            self._load_from_disc(fallback_prompt_dir, on_name_collision="skip")
+
+        self.fallback_mode = fallback_mode
+
+    def _add_prompt_template(
+        self,
+        name: str,
+        template_str: str,
+        lang_code: str = DEFAULT_LANG_CODE,
+        on_name_collision: Literal["skip", "overwrite", "raise"] = "raise",
+    ) -> None:
+        """
+        :param name: name of the prompt template
+        :param template_str: the Jinja template string
+        :param lang_code: the language code for which to add the prompt template.
+        :param on_name_collision: how to deal with name/lang_code collisions
+        """
+        allow_overwrite = False
+        prompt_template = PromptTemplate(name, template_str)
+        mlpt = self._multi_lang_prompt_templates.get(name)
+        if mlpt is None:
+            mlpt = MultiLangPromptTemplate(name)
+            self._multi_lang_prompt_templates[name] = mlpt
+        if mlpt.has_item(lang_code):
+            if on_name_collision == "raise":
+                raise KeyError(f"Prompt '{name}' for {lang_code} already exists!")
+            if on_name_collision == "skip":
+                log.debug(f"Skipping prompt '{name}' since it already exists.")
+                return
+            elif on_name_collision == "overwrite":
+                allow_overwrite = True
+        mlpt.add_prompt_template(prompt_template, lang_code=lang_code, allow_overwrite=allow_overwrite)
+
+    def _add_prompt_list(
+        self,
+        name: str,
+        prompt_list: list[str],
+        lang_code: str = DEFAULT_LANG_CODE,
+        on_name_collision: Literal["skip", "overwrite", "raise"] = "raise",
+    ) -> None:
+        """
+        :param name: name of the prompt list
+        :param prompt_list: a list of prompts
+        :param lang_code: the language code for which to add the prompt list.
+        :param on_name_collision: how to deal with name/lang_code collisions
+        """
+        allow_overwrite = False
+        multilang_prompt_list = self._multi_lang_prompt_lists.get(name)
+        if multilang_prompt_list is None:
+            multilang_prompt_list = MultiLangPromptList(name)
+            self._multi_lang_prompt_lists[name] = multilang_prompt_list
+        if multilang_prompt_list.has_item(lang_code):
+            if on_name_collision == "raise":
+                raise KeyError(f"Prompt '{name}' for {lang_code} already exists!")
+            if on_name_collision == "skip":
+                log.debug(f"Skipping prompt '{name}' since it already exists.")
+                return
+            elif on_name_collision == "overwrite":
+                allow_overwrite = True
+        multilang_prompt_list.add_item(PromptList(prompt_list), lang_code=lang_code, allow_overwrite=allow_overwrite)
+
+    def _load_from_disc(self, prompts_dir: str, on_name_collision: Literal["skip", "overwrite", "raise"] = "raise") -> None:
+        """Loads all prompt templates and prompt lists from yaml files in the given directory.
+
+        :param prompts_dir:
+        :param on_name_collision: how to deal with name/lang_code collisions
+        """
+        for fn in os.listdir(prompts_dir):
+            if not fn.endswith((".yml", ".yaml")):
+                log.debug(f"Skipping non-YAML file: {fn}")
+                continue
+            path = os.path.join(prompts_dir, fn)
+            with open(path, encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+            try:
+                prompts_data = data["prompts"]
+            except KeyError as e:
+                raise KeyError(f"Invalid yaml structure (missing 'prompts' key) in file {path}") from e
+
+            lang_code = prompts_data.get("lang", DEFAULT_LANG_CODE)
+            # add the data to the collection
+            for prompt_name, prompt_template_or_list in prompts_data.items():
+                if isinstance(prompt_template_or_list, list):
+                    self._add_prompt_list(prompt_name, prompt_template_or_list, lang_code=lang_code, on_name_collision=on_name_collision)
+                elif isinstance(prompt_template_or_list, str):
+                    self._add_prompt_template(
+                        prompt_name, prompt_template_or_list, lang_code=lang_code, on_name_collision=on_name_collision
+                    )
+                else:
+                    raise ValueError(
+                        f"Invalid prompt type for {prompt_name} in file {path} (should be str or list): {prompt_template_or_list}"
+                    )
+
+    def get_prompt_template_names(self) -> list[str]:
+        return list(self._multi_lang_prompt_templates.keys())
+
+    def get_prompt_list_names(self) -> list[str]:
+        return list(self._multi_lang_prompt_lists.keys())
+
+    def __len__(self) -> int:
+        return len(self._multi_lang_prompt_templates)
+
+    def get_multilang_prompt_template(self, prompt_name: str) -> MultiLangPromptTemplate:
+        """The MultiLangPromptTemplate object for the given prompt name. For single-language use cases, you should use the `get_prompt_template` method instead."""
+        return self._multi_lang_prompt_templates[prompt_name]
+
+    def get_multilang_prompt_list(self, prompt_name: str) -> MultiLangPromptList:
+        return self._multi_lang_prompt_lists[prompt_name]
+
+    def get_prompt_template(
+        self,
+        prompt_name: str,
+        lang_code: str = DEFAULT_LANG_CODE,
+    ) -> PromptTemplate:
+        """The PromptTemplate object for the given prompt name and language code."""
+        return self.get_multilang_prompt_template(prompt_name).get_prompt_template(lang_code=lang_code, fallback_mode=self.fallback_mode)
+
+    def get_prompt_template_parameters(self, prompt_name: str) -> list[str]:
+        """The parameters of the PromptTemplate object for the given prompt name."""
+        return self.get_multilang_prompt_template(prompt_name).get_parameters()
+
+    def get_prompt_list(self, prompt_name: str, lang_code: str = DEFAULT_LANG_CODE) -> PromptList:
+        """The PromptList object for the given prompt name and language code."""
+        return self.get_multilang_prompt_list(prompt_name).get_item(lang_code)
+
+    def _has_prompt_list(self, prompt_name: str, lang_code: str = DEFAULT_LANG_CODE) -> bool:
+        multi_lang_prompt_list = self._multi_lang_prompt_lists.get(prompt_name)
+        if multi_lang_prompt_list is None:
+            return False
+        return multi_lang_prompt_list.has_item(lang_code)
+
+    def _has_prompt_template(self, prompt_name: str, lang_code: str = DEFAULT_LANG_CODE) -> bool:
+        multi_lang_prompt_template = self._multi_lang_prompt_templates.get(prompt_name)
+        if multi_lang_prompt_template is None:
+            return False
+        return multi_lang_prompt_template.has_item(lang_code)
+
+    def render_prompt_template(
+        self,
+        prompt_name: str,
+        params: dict[str, Any],
+        lang_code: str = DEFAULT_LANG_CODE,
+    ) -> str:
+        """Renders the prompt template for the given prompt name and language code."""
+        return self.get_prompt_template(prompt_name, lang_code=lang_code).render(**params)

projects/ui/serena-new/src/interprompt/prompt_factory.py

@@ -0,0 +1,82 @@
+import logging
+import os
+from typing import Any
+
+from .multilang_prompt import DEFAULT_LANG_CODE, LanguageFallbackMode, MultiLangPromptCollection, PromptList
+
+log = logging.getLogger(__name__)
+
+
+class PromptFactoryBase:
+    """Base class for auto-generated prompt factory classes."""
+
+    def __init__(self, prompts_dir: str | list[str], lang_code: str = DEFAULT_LANG_CODE, fallback_mode=LanguageFallbackMode.EXCEPTION):
+        """
+        :param prompts_dir: the directory containing the prompt templates and prompt lists.
+            If a list is provided, will look for prompt templates in the dirs from left to right
+            (first one containing the desired template wins).
+        :param lang_code: the language code to use for retrieving the prompt templates and prompt lists.
+            Leave as `default` for single-language use cases.
+        :param fallback_mode: the fallback mode to use when a prompt template or prompt list is not found for the requested language.
+            Irrelevant for single-language use cases.
+        """
+        self.lang_code = lang_code
+        self._prompt_collection = MultiLangPromptCollection(prompts_dir, fallback_mode=fallback_mode)
+
+    def _render_prompt(self, prompt_name: str, params: dict[str, Any]) -> str:
+        del params["self"]
+        return self._prompt_collection.render_prompt_template(prompt_name, params, lang_code=self.lang_code)
+
+    def _get_prompt_list(self, prompt_name: str) -> PromptList:
+        return self._prompt_collection.get_prompt_list(prompt_name, self.lang_code)
+
+
+def autogenerate_prompt_factory_module(prompts_dir: str, target_module_path: str) -> None:
+    """
+    Auto-generates a prompt factory module for the given prompt directory.
+    The generated `PromptFactory` class is meant to be the central entry class for retrieving and rendering prompt templates and prompt
+    lists in your application.
+    It will contain one method per prompt template and prompt list, and is useful for both single- and multi-language use cases.
+
+    :param prompts_dir: the directory containing the prompt templates and prompt lists
+    :param target_module_path: the path to the target module file (.py). Important: The module will be overwritten!
+    """
+    generated_code = """
+# 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.
+    \"""
+"""
+    # ---- add methods based on prompt template names and parameters and prompt list names ----
+    prompt_collection = MultiLangPromptCollection(prompts_dir)
+
+    for template_name in prompt_collection.get_prompt_template_names():
+        template_parameters = prompt_collection.get_prompt_template_parameters(template_name)
+        if len(template_parameters) == 0:
+            method_params_str = ""
+        else:
+            method_params_str = ", *, " + ", ".join([f"{param}: Any" for param in template_parameters])
+        generated_code += f"""
+    def create_{template_name}(self{method_params_str}) -> str:
+        return self._render_prompt('{template_name}', locals())
+"""
+    for prompt_list_name in prompt_collection.get_prompt_list_names():
+        generated_code += f"""
+    def get_list_{prompt_list_name}(self) -> PromptList:
+        return self._get_prompt_list('{prompt_list_name}')
+"""
+    os.makedirs(os.path.dirname(target_module_path), exist_ok=True)
+    with open(target_module_path, "w", encoding="utf-8") as f:
+        f.write(generated_code)
+    log.info(f"Prompt factory generated successfully in {target_module_path}")

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

@@ -0,0 +1,23 @@
+__version__ = "0.1.4"
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+def serena_version() -> str:
+    """
+    :return: the version of the package, including git status if available.
+    """
+    from serena.util.git import get_git_status
+
+    version = __version__
+    try:
+        git_status = get_git_status()
+        if git_status is not None:
+            version += f"-{git_status.commit[:8]}"
+            if not git_status.is_clean:
+                version += "-dirty"
+    except:
+        pass
+    return version

projects/ui/serena-new/src/serena/agent.py

@@ -0,0 +1,624 @@
+"""
+The Serena Model Context Protocol (MCP) Server
+"""
+
+import multiprocessing
+import os
+import platform
+import sys
+import threading
+import webbrowser
+from collections import defaultdict
+from collections.abc import Callable
+from concurrent.futures import Future, ThreadPoolExecutor
+from logging import Logger
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
+
+from sensai.util import logging
+from sensai.util.logging import LogTime
+
+from interprompt.jinja_template import JinjaTemplate
+from serena import serena_version
+from serena.analytics import RegisteredTokenCountEstimator, ToolUsageStats
+from serena.config.context_mode import RegisteredContext, SerenaAgentContext, SerenaAgentMode
+from serena.config.serena_config import SerenaConfig, ToolInclusionDefinition, ToolSet, get_serena_managed_in_project_dir
+from serena.dashboard import SerenaDashboardAPI
+from serena.project import Project
+from serena.prompt_factory import SerenaPromptFactory
+from serena.tools import ActivateProjectTool, Tool, ToolMarker, ToolRegistry
+from serena.util.inspection import iter_subclasses
+from serena.util.logging import MemoryLogHandler
+from solidlsp import SolidLanguageServer
+
+if TYPE_CHECKING:
+    from serena.gui_log_viewer import GuiLogViewer
+
+log = logging.getLogger(__name__)
+TTool = TypeVar("TTool", bound="Tool")
+T = TypeVar("T")
+SUCCESS_RESULT = "OK"
+
+
+class ProjectNotFoundError(Exception):
+    pass
+
+
+class LinesRead:
+    def __init__(self) -> None:
+        self.files: dict[str, set[tuple[int, int]]] = defaultdict(lambda: set())
+
+    def add_lines_read(self, relative_path: str, lines: tuple[int, int]) -> None:
+        self.files[relative_path].add(lines)
+
+    def were_lines_read(self, relative_path: str, lines: tuple[int, int]) -> bool:
+        lines_read_in_file = self.files[relative_path]
+        return lines in lines_read_in_file
+
+    def invalidate_lines_read(self, relative_path: str) -> None:
+        if relative_path in self.files:
+            del self.files[relative_path]
+
+
+class MemoriesManager:
+    def __init__(self, project_root: str):
+        self._memory_dir = Path(get_serena_managed_in_project_dir(project_root)) / "memories"
+        self._memory_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_memory_file_path(self, name: str) -> Path:
+        # strip all .md from the name. Models tend to get confused, sometimes passing the .md extension and sometimes not.
+        name = name.replace(".md", "")
+        filename = f"{name}.md"
+        return self._memory_dir / filename
+
+    def load_memory(self, name: str) -> str:
+        memory_file_path = self._get_memory_file_path(name)
+        if not memory_file_path.exists():
+            return f"Memory file {name} not found, consider creating it with the `write_memory` tool if you need it."
+        with open(memory_file_path, encoding="utf-8") as f:
+            return f.read()
+
+    def save_memory(self, name: str, content: str) -> str:
+        memory_file_path = self._get_memory_file_path(name)
+        with open(memory_file_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return f"Memory {name} written."
+
+    def list_memories(self) -> list[str]:
+        return [f.name.replace(".md", "") for f in self._memory_dir.iterdir() if f.is_file()]
+
+    def delete_memory(self, name: str) -> str:
+        memory_file_path = self._get_memory_file_path(name)
+        memory_file_path.unlink()
+        return f"Memory {name} deleted."
+
+
+class AvailableTools:
+    def __init__(self, tools: list[Tool]):
+        """
+        :param tools: the list of available tools
+        """
+        self.tools = tools
+        self.tool_names = [tool.get_name_from_cls() for tool in tools]
+        self.tool_marker_names = set()
+        for marker_class in iter_subclasses(ToolMarker):
+            for tool in tools:
+                if isinstance(tool, marker_class):
+                    self.tool_marker_names.add(marker_class.__name__)
+
+    def __len__(self) -> int:
+        return len(self.tools)
+
+
+class SerenaAgent:
+    def __init__(
+        self,
+        project: str | None = None,
+        project_activation_callback: Callable[[], None] | None = None,
+        serena_config: SerenaConfig | None = None,
+        context: SerenaAgentContext | None = None,
+        modes: list[SerenaAgentMode] | None = None,
+        memory_log_handler: MemoryLogHandler | None = None,
+    ):
+        """
+        :param project: the project to load immediately or None to not load any project; may be a path to the project or a name of
+            an already registered project;
+        :param project_activation_callback: a callback function to be called when a project is activated.
+        :param serena_config: the Serena configuration or None to read the configuration from the default location.
+        :param context: the context in which the agent is operating, None for default context.
+            The context may adjust prompts, tool availability, and tool descriptions.
+        :param modes: list of modes in which the agent is operating (they will be combined), None for default modes.
+            The modes may adjust prompts, tool availability, and tool descriptions.
+        :param memory_log_handler: a MemoryLogHandler instance from which to read log messages; if None, a new one will be created
+            if necessary.
+        """
+        # obtain serena configuration using the decoupled factory function
+        self.serena_config = serena_config or SerenaConfig.from_config_file()
+
+        # adjust log level
+        serena_log_level = self.serena_config.log_level
+        if Logger.root.level > serena_log_level:
+            log.info(f"Changing the root logger level to {serena_log_level}")
+            Logger.root.setLevel(serena_log_level)
+
+        def get_memory_log_handler() -> MemoryLogHandler:
+            nonlocal memory_log_handler
+            if memory_log_handler is None:
+                memory_log_handler = MemoryLogHandler(level=serena_log_level)
+                Logger.root.addHandler(memory_log_handler)
+            return memory_log_handler
+
+        # open GUI log window if enabled
+        self._gui_log_viewer: Optional["GuiLogViewer"] = None
+        if self.serena_config.gui_log_window_enabled:
+            if platform.system() == "Darwin":
+                log.warning("GUI log window is not supported on macOS")
+            else:
+                # even importing on macOS may fail if tkinter dependencies are unavailable (depends on Python interpreter installation
+                # which uv used as a base, unfortunately)
+                from serena.gui_log_viewer import GuiLogViewer
+
+                self._gui_log_viewer = GuiLogViewer("dashboard", title="Serena Logs", memory_log_handler=get_memory_log_handler())
+                self._gui_log_viewer.start()
+
+        # set the agent context
+        if context is None:
+            context = SerenaAgentContext.load_default()
+        self._context = context
+
+        # instantiate all tool classes
+        self._all_tools: dict[type[Tool], Tool] = {tool_class: tool_class(self) for tool_class in ToolRegistry().get_all_tool_classes()}
+        tool_names = [tool.get_name_from_cls() for tool in self._all_tools.values()]
+
+        # If GUI log window is enabled, set the tool names for highlighting
+        if self._gui_log_viewer is not None:
+            self._gui_log_viewer.set_tool_names(tool_names)
+
+        self._tool_usage_stats: ToolUsageStats | None = None
+        if self.serena_config.record_tool_usage_stats:
+            token_count_estimator = RegisteredTokenCountEstimator[self.serena_config.token_count_estimator]
+            log.info(f"Tool usage statistics recording is enabled with token count estimator: {token_count_estimator.name}.")
+            self._tool_usage_stats = ToolUsageStats(token_count_estimator)
+
+        # start the dashboard (web frontend), registering its log handler
+        if self.serena_config.web_dashboard:
+            self._dashboard_thread, port = SerenaDashboardAPI(
+                get_memory_log_handler(), tool_names, tool_usage_stats=self._tool_usage_stats
+            ).run_in_thread()
+            dashboard_url = f"http://127.0.0.1:{port}/dashboard/index.html"
+            log.info("Serena web dashboard started at %s", dashboard_url)
+            if self.serena_config.web_dashboard_open_on_launch:
+                # open the dashboard URL in the default web browser (using a separate process to control
+                # output redirection)
+                process = multiprocessing.Process(target=self._open_dashboard, args=(dashboard_url,))
+                process.start()
+                process.join(timeout=1)
+
+        # log fundamental information
+        log.info(f"Starting Serena server (version={serena_version()}, process id={os.getpid()}, parent process id={os.getppid()})")
+        log.info("Configuration file: %s", self.serena_config.config_file_path)
+        log.info("Available projects: {}".format(", ".join(self.serena_config.project_names)))
+        log.info(f"Loaded tools ({len(self._all_tools)}): {', '.join([tool.get_name_from_cls() for tool in self._all_tools.values()])}")
+
+        self._check_shell_settings()
+
+        # determine the base toolset defining the set of exposed tools (which e.g. the MCP shall see),
+        # limited by the Serena config, the context (which is fixed for the session) and JetBrains mode
+        tool_inclusion_definitions: list[ToolInclusionDefinition] = [self.serena_config, self._context]
+        if self._context.name == RegisteredContext.IDE_ASSISTANT.value:
+            tool_inclusion_definitions.extend(self._ide_context_tool_inclusion_definitions(project))
+        if self.serena_config.jetbrains:
+            tool_inclusion_definitions.append(SerenaAgentMode.from_name_internal("jetbrains"))
+
+        self._base_tool_set = ToolSet.default().apply(*tool_inclusion_definitions)
+        self._exposed_tools = AvailableTools([t for t in self._all_tools.values() if self._base_tool_set.includes_name(t.get_name())])
+        log.info(f"Number of exposed tools: {len(self._exposed_tools)}")
+
+        # create executor for starting the language server and running tools in another thread
+        # This executor is used to achieve linear task execution, so it is important to use a single-threaded executor.
+        self._task_executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="SerenaAgentExecutor")
+        self._task_executor_lock = threading.Lock()
+        self._task_executor_task_index = 1
+
+        # Initialize the prompt factory
+        self.prompt_factory = SerenaPromptFactory()
+        self._project_activation_callback = project_activation_callback
+
+        # project-specific instances, which will be initialized upon project activation
+        self._active_project: Project | None = None
+        self._active_project_root: str | None = None
+        self.language_server: SolidLanguageServer | None = None
+        self.memories_manager: MemoriesManager | None = None
+        self.lines_read: LinesRead | None = None
+
+        # set the active modes
+        if modes is None:
+            modes = SerenaAgentMode.load_default_modes()
+        self._modes = modes
+
+        self._active_tools: dict[type[Tool], Tool] = {}
+        self._update_active_tools()
+
+        # activate a project configuration (if provided or if there is only a single project available)
+        if project is not None:
+            try:
+                self.activate_project_from_path_or_name(project)
+            except Exception as e:
+                log.error(f"Error activating project '{project}' at startup: {e}", exc_info=e)
+
+    def get_context(self) -> SerenaAgentContext:
+        return self._context
+
+    def get_tool_description_override(self, tool_name: str) -> str | None:
+        return self._context.tool_description_overrides.get(tool_name, None)
+
+    def _check_shell_settings(self) -> None:
+        # On Windows, Claude Code sets COMSPEC to Git-Bash (often even with a path containing spaces),
+        # which causes all sorts of trouble, preventing language servers from being launched correctly.
+        # So we make sure that COMSPEC is unset if it has been set to bash specifically.
+        if platform.system() == "Windows":
+            comspec = os.environ.get("COMSPEC", "")
+            if "bash" in comspec:
+                os.environ["COMSPEC"] = ""  # force use of default shell
+                log.info("Adjusting COMSPEC environment variable to use the default shell instead of '%s'", comspec)
+
+    def _ide_context_tool_inclusion_definitions(self, project_root_or_name: str | None) -> list[ToolInclusionDefinition]:
+        """
+        In the IDE assistant context, the agent is assumed to work on a single project, and we thus
+        want to apply that project's tool exclusions/inclusions from the get-go, limiting the set
+        of tools that will be exposed to the client.
+        So if the project exists, we apply all the aforementioned exclusions.
+
+        :param project_root_or_name: the project root path or project name
+        :return:
+        """
+        tool_inclusion_definitions = []
+        if project_root_or_name is not None:
+            # Note: Auto-generation is disabled, because the result must be returned instantaneously
+            #   (project generation could take too much time), so as not to delay MCP server startup
+            #   and provide responses to the client immediately.
+            project = self.load_project_from_path_or_name(project_root_or_name, autogenerate=False)
+            if project is not None:
+                tool_inclusion_definitions.append(ToolInclusionDefinition(excluded_tools=[ActivateProjectTool.get_name_from_cls()]))
+                tool_inclusion_definitions.append(project.project_config)
+        return tool_inclusion_definitions
+
+    def record_tool_usage_if_enabled(self, input_kwargs: dict, tool_result: str | dict, tool: Tool) -> None:
+        """
+        Record the usage of a tool with the given input and output strings if tool usage statistics recording is enabled.
+        """
+        tool_name = tool.get_name()
+        if self._tool_usage_stats is not None:
+            input_str = str(input_kwargs)
+            output_str = str(tool_result)
+            log.debug(f"Recording tool usage for tool '{tool_name}'")
+            self._tool_usage_stats.record_tool_usage(tool_name, input_str, output_str)
+        else:
+            log.debug(f"Tool usage statistics recording is disabled, not recording usage of '{tool_name}'.")
+
+    @staticmethod
+    def _open_dashboard(url: str) -> None:
+        # Redirect stdout and stderr file descriptors to /dev/null,
+        # making sure that nothing can be written to stdout/stderr, even by subprocesses
+        null_fd = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(null_fd, sys.stdout.fileno())
+        os.dup2(null_fd, sys.stderr.fileno())
+        os.close(null_fd)
+
+        # open the dashboard URL in the default web browser
+        webbrowser.open(url)
+
+    def get_project_root(self) -> str:
+        """
+        :return: the root directory of the active project (if any); raises a ValueError if there is no active project
+        """
+        project = self.get_active_project()
+        if project is None:
+            raise ValueError("Cannot get project root if no project is active.")
+        return project.project_root
+
+    def get_exposed_tool_instances(self) -> list["Tool"]:
+        """
+        :return: the tool instances which are exposed (e.g. to the MCP client).
+            Note that the set of exposed tools is fixed for the session, as
+            clients don't react to changes in the set of tools, so this is the superset
+            of tools that can be offered during the session.
+            If a client should attempt to use a tool that is dynamically disabled
+            (e.g. because a project is activated that disables it), it will receive an error.
+        """
+        return list(self._exposed_tools.tools)
+
+    def get_active_project(self) -> Project | None:
+        """
+        :return: the active project or None if no project is active
+        """
+        return self._active_project
+
+    def get_active_project_or_raise(self) -> Project:
+        """
+        :return: the active project or raises an exception if no project is active
+        """
+        project = self.get_active_project()
+        if project is None:
+            raise ValueError("No active project. Please activate a project first.")
+        return project
+
+    def set_modes(self, modes: list[SerenaAgentMode]) -> None:
+        """
+        Set the current mode configurations.
+
+        :param modes: List of mode names or paths to use
+        """
+        self._modes = modes
+        self._update_active_tools()
+
+        log.info(f"Set modes to {[mode.name for mode in modes]}")
+
+    def get_active_modes(self) -> list[SerenaAgentMode]:
+        """
+        :return: the list of active modes
+        """
+        return list(self._modes)
+
+    def _format_prompt(self, prompt_template: str) -> str:
+        template = JinjaTemplate(prompt_template)
+        return template.render(available_tools=self._exposed_tools.tool_names, available_markers=self._exposed_tools.tool_marker_names)
+
+    def create_system_prompt(self) -> str:
+        available_markers = self._exposed_tools.tool_marker_names
+        log.info("Generating system prompt with available_tools=(see exposed tools), available_markers=%s", available_markers)
+        system_prompt = self.prompt_factory.create_system_prompt(
+            context_system_prompt=self._format_prompt(self._context.prompt),
+            mode_system_prompts=[self._format_prompt(mode.prompt) for mode in self._modes],
+            available_tools=self._exposed_tools.tool_names,
+            available_markers=available_markers,
+        )
+        log.info("System prompt:\n%s", system_prompt)
+        return system_prompt
+
+    def _update_active_tools(self) -> None:
+        """
+        Update the active tools based on enabled modes and the active project.
+        The base tool set already takes the Serena configuration and the context into account
+        (as well as any internal modes that are not handled dynamically, such as JetBrains mode).
+        """
+        tool_set = self._base_tool_set.apply(*self._modes)
+        if self._active_project is not None:
+            tool_set = tool_set.apply(self._active_project.project_config)
+            if self._active_project.project_config.read_only:
+                tool_set = tool_set.without_editing_tools()
+
+        self._active_tools = {
+            tool_class: tool_instance
+            for tool_class, tool_instance in self._all_tools.items()
+            if tool_set.includes_name(tool_instance.get_name())
+        }
+
+        log.info(f"Active tools ({len(self._active_tools)}): {', '.join(self.get_active_tool_names())}")
+
+    def issue_task(self, task: Callable[[], Any], name: str | None = None) -> Future:
+        """
+        Issue a task to the executor for asynchronous execution.
+        It is ensured that tasks are executed in the order they are issued, one after another.
+
+        :param task: the task to execute
+        :param name: the name of the task for logging purposes; if None, use the task function's name
+        :return: a Future object representing the execution of the task
+        """
+        with self._task_executor_lock:
+            task_name = f"Task-{self._task_executor_task_index}[{name or task.__name__}]"
+            self._task_executor_task_index += 1
+
+            def task_execution_wrapper() -> Any:
+                with LogTime(task_name, logger=log):
+                    return task()
+
+            log.info(f"Scheduling {task_name}")
+            return self._task_executor.submit(task_execution_wrapper)
+
+    def execute_task(self, task: Callable[[], T]) -> T:
+        """
+        Executes the given task synchronously via the agent's task executor.
+        This is useful for tasks that need to be executed immediately and whose results are needed right away.
+
+        :param task: the task to execute
+        :return: the result of the task execution
+        """
+        future = self.issue_task(task)
+        return future.result()
+
+    def is_using_language_server(self) -> bool:
+        """
+        :return: whether this agent uses language server-based code analysis
+        """
+        return not self.serena_config.jetbrains
+
+    def _activate_project(self, project: Project) -> None:
+        log.info(f"Activating {project.project_name} at {project.project_root}")
+        self._active_project = project
+        self._update_active_tools()
+
+        # initialize project-specific instances which do not depend on the language server
+        self.memories_manager = MemoriesManager(project.project_root)
+        self.lines_read = LinesRead()
+
+        def init_language_server() -> None:
+            # start the language server
+            with LogTime("Language server initialization", logger=log):
+                self.reset_language_server()
+                assert self.language_server is not None
+
+        # initialize the language server in the background (if in language server mode)
+        if self.is_using_language_server():
+            self.issue_task(init_language_server)
+
+        if self._project_activation_callback is not None:
+            self._project_activation_callback()
+
+    def load_project_from_path_or_name(self, project_root_or_name: str, autogenerate: bool) -> Project | None:
+        """
+        Get a project instance from a path or a name.
+
+        :param project_root_or_name: the path to the project root or the name of the project
+        :param autogenerate: whether to autogenerate the project for the case where first argument is a directory
+            which does not yet contain a Serena project configuration file
+        :return: the project instance if it was found/could be created, None otherwise
+        """
+        project_instance: Project | None = self.serena_config.get_project(project_root_or_name)
+        if project_instance is not None:
+            log.info(f"Found registered project '{project_instance.project_name}' at path {project_instance.project_root}")
+        elif autogenerate and os.path.isdir(project_root_or_name):
+            project_instance = self.serena_config.add_project_from_path(project_root_or_name)
+            log.info(f"Added new project {project_instance.project_name} for path {project_instance.project_root}")
+        return project_instance
+
+    def activate_project_from_path_or_name(self, project_root_or_name: str) -> Project:
+        """
+        Activate a project from a path or a name.
+        If the project was already registered, it will just be activated.
+        If the argument is a path at which no Serena project previously existed, the project will be created beforehand.
+        Raises ProjectNotFoundError if the project could neither be found nor created.
+
+        :return: a tuple of the project instance and a Boolean indicating whether the project was newly
+            created
+        """
+        project_instance: Project | None = self.load_project_from_path_or_name(project_root_or_name, autogenerate=True)
+        if project_instance is None:
+            raise ProjectNotFoundError(
+                f"Project '{project_root_or_name}' not found: Not a valid project name or directory. "
+                f"Existing project names: {self.serena_config.project_names}"
+            )
+        self._activate_project(project_instance)
+        return project_instance
+
+    def get_active_tool_classes(self) -> list[type["Tool"]]:
+        """
+        :return: the list of active tool classes for the current project
+        """
+        return list(self._active_tools.keys())
+
+    def get_active_tool_names(self) -> list[str]:
+        """
+        :return: the list of names of the active tools for the current project
+        """
+        return sorted([tool.get_name_from_cls() for tool in self.get_active_tool_classes()])
+
+    def tool_is_active(self, tool_class: type["Tool"] | str) -> bool:
+        """
+        :param tool_class: the class or name of the tool to check
+        :return: True if the tool is active, False otherwise
+        """
+        if isinstance(tool_class, str):
+            return tool_class in self.get_active_tool_names()
+        else:
+            return tool_class in self.get_active_tool_classes()
+
+    def get_current_config_overview(self) -> str:
+        """
+        :return: a string overview of the current configuration, including the active and available configuration options
+        """
+        result_str = "Current configuration:\n"
+        result_str += f"Serena version: {serena_version()}\n"
+        result_str += f"Loglevel: {self.serena_config.log_level}, trace_lsp_communication={self.serena_config.trace_lsp_communication}\n"
+        if self._active_project is not None:
+            result_str += f"Active project: {self._active_project.project_name}\n"
+        else:
+            result_str += "No active project\n"
+        result_str += "Available projects:\n" + "\n".join(list(self.serena_config.project_names)) + "\n"
+        result_str += f"Active context: {self._context.name}\n"
+
+        # Active modes
+        active_mode_names = [mode.name for mode in self.get_active_modes()]
+        result_str += "Active modes: {}\n".format(", ".join(active_mode_names)) + "\n"
+
+        # Available but not active modes
+        all_available_modes = SerenaAgentMode.list_registered_mode_names()
+        inactive_modes = [mode for mode in all_available_modes if mode not in active_mode_names]
+        if inactive_modes:
+            result_str += "Available but not active modes: {}\n".format(", ".join(inactive_modes)) + "\n"
+
+        # Active tools
+        result_str += "Active tools (after all exclusions from the project, context, and modes):\n"
+        active_tool_names = self.get_active_tool_names()
+        # print the tool names in chunks
+        chunk_size = 4
+        for i in range(0, len(active_tool_names), chunk_size):
+            chunk = active_tool_names[i : i + chunk_size]
+            result_str += "  " + ", ".join(chunk) + "\n"
+
+        # Available but not active tools
+        all_tool_names = sorted([tool.get_name_from_cls() for tool in self._all_tools.values()])
+        inactive_tool_names = [tool for tool in all_tool_names if tool not in active_tool_names]
+        if inactive_tool_names:
+            result_str += "Available but not active tools:\n"
+            for i in range(0, len(inactive_tool_names), chunk_size):
+                chunk = inactive_tool_names[i : i + chunk_size]
+                result_str += "  " + ", ".join(chunk) + "\n"
+
+        return result_str
+
+    def is_language_server_running(self) -> bool:
+        return self.language_server is not None and self.language_server.is_running()
+
+    def reset_language_server(self) -> None:
+        """
+        Starts/resets the language server for the current project
+        """
+        tool_timeout = self.serena_config.tool_timeout
+        if tool_timeout is None or tool_timeout < 0:
+            ls_timeout = None
+        else:
+            if tool_timeout < 10:
+                raise ValueError(f"Tool timeout must be at least 10 seconds, but is {tool_timeout} seconds")
+            ls_timeout = tool_timeout - 5  # the LS timeout is for a single call, it should be smaller than the tool timeout
+
+        # stop the language server if it is running
+        if self.is_language_server_running():
+            assert self.language_server is not None
+            log.info(f"Stopping the current language server at {self.language_server.repository_root_path} ...")
+            self.language_server.stop()
+            self.language_server = None
+
+        # instantiate and start the language server
+        assert self._active_project is not None
+        self.language_server = self._active_project.create_language_server(
+            log_level=self.serena_config.log_level,
+            ls_timeout=ls_timeout,
+            trace_lsp_communication=self.serena_config.trace_lsp_communication,
+        )
+        log.info(f"Starting the language server for {self._active_project.project_name}")
+        self.language_server.start()
+        if not self.language_server.is_running():
+            raise RuntimeError(
+                f"Failed to start the language server for {self._active_project.project_name} at {self._active_project.project_root}"
+            )
+
+    def get_tool(self, tool_class: type[TTool]) -> TTool:
+        return self._all_tools[tool_class]  # type: ignore
+
+    def print_tool_overview(self) -> None:
+        ToolRegistry().print_tool_overview(self._active_tools.values())
+
+    def mark_file_modified(self, relative_path: str) -> None:
+        assert self.lines_read is not None
+        self.lines_read.invalidate_lines_read(relative_path)
+
+    def __del__(self) -> None:
+        """
+        Destructor to clean up the language server instance and GUI logger
+        """
+        if not hasattr(self, "_is_initialized"):
+            return
+        log.info("SerenaAgent is shutting down ...")
+        if self.is_language_server_running():
+            log.info("Stopping the language server ...")
+            assert self.language_server is not None
+            self.language_server.save_cache()
+            self.language_server.stop()
+        if self._gui_log_viewer:
+            log.info("Stopping the GUI log window ...")
+            self._gui_log_viewer.stop()
+
+    def get_tool_by_name(self, tool_name: str) -> Tool:
+        tool_class = ToolRegistry().get_tool_class_by_name(tool_name)
+        return self.get_tool(tool_class)

projects/ui/serena-new/src/serena/agno.py

@@ -0,0 +1,145 @@
+import argparse
+import logging
+import os
+import threading
+from pathlib import Path
+from typing import Any
+
+from agno.agent import Agent
+from agno.memory import AgentMemory
+from agno.models.base import Model
+from agno.storage.sqlite import SqliteStorage
+from agno.tools.function import Function
+from agno.tools.toolkit import Toolkit
+from dotenv import load_dotenv
+from sensai.util.logging import LogTime
+
+from serena.agent import SerenaAgent, Tool
+from serena.config.context_mode import SerenaAgentContext
+from serena.constants import REPO_ROOT
+from serena.util.exception import show_fatal_exception_safe
+
+log = logging.getLogger(__name__)
+
+
+class SerenaAgnoToolkit(Toolkit):
+    def __init__(self, serena_agent: SerenaAgent):
+        super().__init__("Serena")
+        for tool in serena_agent.get_exposed_tool_instances():
+            self.functions[tool.get_name_from_cls()] = self._create_agno_function(tool)
+        log.info("Agno agent functions: %s", list(self.functions.keys()))
+
+    @staticmethod
+    def _create_agno_function(tool: Tool) -> Function:
+        def entrypoint(**kwargs: Any) -> str:
+            if "kwargs" in kwargs:
+                # Agno sometimes passes a kwargs argument explicitly, so we merge it
+                kwargs.update(kwargs["kwargs"])
+                del kwargs["kwargs"]
+            log.info(f"Calling tool {tool}")
+            return tool.apply_ex(log_call=True, catch_exceptions=True, **kwargs)
+
+        function = Function.from_callable(tool.get_apply_fn())
+        function.name = tool.get_name_from_cls()
+        function.entrypoint = entrypoint
+        function.skip_entrypoint_processing = True
+        return function
+
+
+class SerenaAgnoAgentProvider:
+    _agent: Agent | None = None
+    _lock = threading.Lock()
+
+    @classmethod
+    def get_agent(cls, model: Model) -> Agent:
+        """
+        Returns the singleton instance of the Serena agent or creates it with the given parameters if it doesn't exist.
+
+        NOTE: This is very ugly with poor separation of concerns, but the way in which the Agno UI works (reloading the
+            module that defines the `app` variable) essentially forces us to do something like this.
+
+        :param model: the large language model to use for the agent
+        :return: the agent instance
+        """
+        with cls._lock:
+            if cls._agent is not None:
+                return cls._agent
+
+            # change to Serena root
+            os.chdir(REPO_ROOT)
+
+            load_dotenv()
+
+            parser = argparse.ArgumentParser(description="Serena coding assistant")
+
+            # Create a mutually exclusive group
+            group = parser.add_mutually_exclusive_group()
+
+            # Add arguments to the group, both pointing to the same destination
+            group.add_argument(
+                "--project-file",
+                required=False,
+                help="Path to the project (or project.yml file).",
+            )
+            group.add_argument(
+                "--project",
+                required=False,
+                help="Path to the project (or project.yml file).",
+            )
+            args = parser.parse_args()
+
+            args_project_file = args.project or args.project_file
+
+            if args_project_file:
+                project_file = Path(args_project_file).resolve()
+                # If project file path is relative, make it absolute by joining with project root
+                if not project_file.is_absolute():
+                    # Get the project root directory (parent of scripts directory)
+                    project_root = Path(REPO_ROOT)
+                    project_file = project_root / args_project_file
+
+                # Ensure the path is normalized and absolute
+                project_file = str(project_file.resolve())
+            else:
+                project_file = None
+
+            with LogTime("Loading Serena agent"):
+                try:
+                    serena_agent = SerenaAgent(project_file, context=SerenaAgentContext.load("agent"))
+                except Exception as e:
+                    show_fatal_exception_safe(e)
+                    raise
+
+            # Even though we don't want to keep history between sessions,
+            # for agno-ui to work as a conversation, we use a persistent storage on disk.
+            # This storage should be deleted between sessions.
+            # Note that this might collide with custom options for the agent, like adding vector-search based tools.
+            # See here for an explanation: https://www.reddit.com/r/agno/comments/1jk6qea/regarding_the_built_in_memory/
+            sql_db_path = (Path("temp") / "agno_agent_storage.db").absolute()
+            sql_db_path.parent.mkdir(exist_ok=True)
+            # delete the db file if it exists
+            log.info(f"Deleting DB from PID {os.getpid()}")
+            if sql_db_path.exists():
+                sql_db_path.unlink()
+
+            agno_agent = Agent(
+                name="Serena",
+                model=model,
+                # See explanation above on why storage is needed
+                storage=SqliteStorage(table_name="serena_agent_sessions", db_file=str(sql_db_path)),
+                description="A fully-featured coding assistant",
+                tools=[SerenaAgnoToolkit(serena_agent)],
+                # The tool calls will be shown in the UI anyway since whether to show them is configurable per tool
+                # To see detailed logs, you should use the serena logger (configure it in the project file path)
+                show_tool_calls=False,
+                markdown=True,
+                system_message=serena_agent.create_system_prompt(),
+                telemetry=False,
+                memory=AgentMemory(),
+                add_history_to_messages=True,
+                num_history_responses=100,  # you might want to adjust this (expense vs. history awareness)
+            )
+            cls._agent = agno_agent
+            log.info(f"Agent instantiated: {agno_agent}")
+
+        return agno_agent

projects/ui/serena-new/src/serena/analytics.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import logging
+import threading
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from copy import copy
+from dataclasses import asdict, dataclass
+from enum import Enum
+
+from anthropic.types import MessageParam, MessageTokensCount
+from dotenv import load_dotenv
+
+log = logging.getLogger(__name__)
+
+
+class TokenCountEstimator(ABC):
+    @abstractmethod
+    def estimate_token_count(self, text: str) -> int:
+        """
+        Estimate the number of tokens in the given text.
+        This is an abstract method that should be implemented by subclasses.
+        """
+
+
+class TiktokenCountEstimator(TokenCountEstimator):
+    """
+    Approximate token count using tiktoken.
+    """
+
+    def __init__(self, model_name: str = "gpt-4o"):
+        """
+        The tokenizer will be downloaded on the first initialization, which may take some time.
+
+        :param model_name: see `tiktoken.model` to see available models.
+        """
+        import tiktoken
+
+        log.info(f"Loading tiktoken encoding for model {model_name}, this may take a while on the first run.")
+        self._encoding = tiktoken.encoding_for_model(model_name)
+
+    def estimate_token_count(self, text: str) -> int:
+        return len(self._encoding.encode(text))
+
+
+class AnthropicTokenCount(TokenCountEstimator):
+    """
+    The exact count using the Anthropic API.
+    Counting is free, but has a rate limit and will require an API key,
+    (typically, set through an env variable).
+    See https://docs.anthropic.com/en/docs/build-with-claude/token-counting
+    """
+
+    def __init__(self, model_name: str = "claude-sonnet-4-20250514", api_key: str | None = None):
+        import anthropic
+
+        self._model_name = model_name
+        if api_key is None:
+            load_dotenv()
+        self._anthropic_client = anthropic.Anthropic(api_key=api_key)
+
+    def _send_count_tokens_request(self, text: str) -> MessageTokensCount:
+        return self._anthropic_client.messages.count_tokens(
+            model=self._model_name,
+            messages=[MessageParam(role="user", content=text)],
+        )
+
+    def estimate_token_count(self, text: str) -> int:
+        return self._send_count_tokens_request(text).input_tokens
+
+
+_registered_token_estimator_instances_cache: dict[RegisteredTokenCountEstimator, TokenCountEstimator] = {}
+
+
+class RegisteredTokenCountEstimator(Enum):
+    TIKTOKEN_GPT4O = "TIKTOKEN_GPT4O"
+    ANTHROPIC_CLAUDE_SONNET_4 = "ANTHROPIC_CLAUDE_SONNET_4"
+
+    @classmethod
+    def get_valid_names(cls) -> list[str]:
+        """
+        Get a list of all registered token count estimator names.
+        """
+        return [estimator.name for estimator in cls]
+
+    def _create_estimator(self) -> TokenCountEstimator:
+        match self:
+            case RegisteredTokenCountEstimator.TIKTOKEN_GPT4O:
+                return TiktokenCountEstimator(model_name="gpt-4o")
+            case RegisteredTokenCountEstimator.ANTHROPIC_CLAUDE_SONNET_4:
+                return AnthropicTokenCount(model_name="claude-sonnet-4-20250514")
+            case _:
+                raise ValueError(f"Unknown token count estimator: {self.value}")
+
+    def load_estimator(self) -> TokenCountEstimator:
+        estimator_instance = _registered_token_estimator_instances_cache.get(self)
+        if estimator_instance is None:
+            estimator_instance = self._create_estimator()
+            _registered_token_estimator_instances_cache[self] = estimator_instance
+        return estimator_instance
+
+
+class ToolUsageStats:
+    """
+    A class to record and manage tool usage statistics.
+    """
+
+    def __init__(self, token_count_estimator: RegisteredTokenCountEstimator = RegisteredTokenCountEstimator.TIKTOKEN_GPT4O):
+        self._token_count_estimator = token_count_estimator.load_estimator()
+        self._token_estimator_name = token_count_estimator.value
+        self._tool_stats: dict[str, ToolUsageStats.Entry] = defaultdict(ToolUsageStats.Entry)
+        self._tool_stats_lock = threading.Lock()
+
+    @property
+    def token_estimator_name(self) -> str:
+        """
+        Get the name of the registered token count estimator used.
+        """
+        return self._token_estimator_name
+
+    @dataclass(kw_only=True)
+    class Entry:
+        num_times_called: int = 0
+        input_tokens: int = 0
+        output_tokens: int = 0
+
+        def update_on_call(self, input_tokens: int, output_tokens: int) -> None:
+            """
+            Update the entry with the number of tokens used for a single call.
+            """
+            self.num_times_called += 1
+            self.input_tokens += input_tokens
+            self.output_tokens += output_tokens
+
+    def _estimate_token_count(self, text: str) -> int:
+        return self._token_count_estimator.estimate_token_count(text)
+
+    def get_stats(self, tool_name: str) -> ToolUsageStats.Entry:
+        """
+        Get (a copy of) the current usage statistics for a specific tool.
+        """
+        with self._tool_stats_lock:
+            return copy(self._tool_stats[tool_name])
+
+    def record_tool_usage(self, tool_name: str, input_str: str, output_str: str) -> None:
+        input_tokens = self._estimate_token_count(input_str)
+        output_tokens = self._estimate_token_count(output_str)
+        with self._tool_stats_lock:
+            entry = self._tool_stats[tool_name]
+            entry.update_on_call(input_tokens, output_tokens)
+
+    def get_tool_stats_dict(self) -> dict[str, dict[str, int]]:
+        with self._tool_stats_lock:
+            return {name: asdict(entry) for name, entry in self._tool_stats.items()}
+
+    def clear(self) -> None:
+        with self._tool_stats_lock:
+            self._tool_stats.clear()

projects/ui/serena-new/src/serena/cli.py

@@ -0,0 +1,831 @@
+import glob
+import json
+import os
+import shutil
+import subprocess
+import sys
+from logging import Logger
+from pathlib import Path
+from typing import Any, Literal
+
+import click
+from sensai.util import logging
+from sensai.util.logging import FileLoggerContext, datetime_tag
+from tqdm import tqdm
+
+from serena.agent import SerenaAgent
+from serena.config.context_mode import SerenaAgentContext, SerenaAgentMode
+from serena.config.serena_config import ProjectConfig, SerenaConfig, SerenaPaths
+from serena.constants import (
+    DEFAULT_CONTEXT,
+    DEFAULT_MODES,
+    PROMPT_TEMPLATES_DIR_IN_USER_HOME,
+    PROMPT_TEMPLATES_DIR_INTERNAL,
+    SERENA_LOG_FORMAT,
+    SERENA_MANAGED_DIR_IN_HOME,
+    SERENAS_OWN_CONTEXT_YAMLS_DIR,
+    SERENAS_OWN_MODE_YAMLS_DIR,
+    USER_CONTEXT_YAMLS_DIR,
+    USER_MODE_YAMLS_DIR,
+)
+from serena.mcp import SerenaMCPFactory, SerenaMCPFactorySingleProcess
+from serena.project import Project
+from serena.tools import FindReferencingSymbolsTool, FindSymbolTool, GetSymbolsOverviewTool, SearchForPatternTool, ToolRegistry
+from serena.util.logging import MemoryLogHandler
+from solidlsp.ls_config import Language
+from solidlsp.util.subprocess_util import subprocess_kwargs
+
+log = logging.getLogger(__name__)
+
+# --------------------- Utilities -------------------------------------
+
+
+def _open_in_editor(path: str) -> None:
+    """Open the given file in the system's default editor or viewer."""
+    editor = os.environ.get("EDITOR")
+    run_kwargs = subprocess_kwargs()
+    try:
+        if editor:
+            subprocess.run([editor, path], check=False, **run_kwargs)
+        elif sys.platform.startswith("win"):
+            try:
+                os.startfile(path)
+            except OSError:
+                subprocess.run(["notepad.exe", path], check=False, **run_kwargs)
+        elif sys.platform == "darwin":
+            subprocess.run(["open", path], check=False, **run_kwargs)
+        else:
+            subprocess.run(["xdg-open", path], check=False, **run_kwargs)
+    except Exception as e:
+        print(f"Failed to open {path}: {e}")
+
+
+class ProjectType(click.ParamType):
+    """ParamType allowing either a project name or a path to a project directory."""
+
+    name = "[PROJECT_NAME|PROJECT_PATH]"
+
+    def convert(self, value: str, param: Any, ctx: Any) -> str:
+        path = Path(value).resolve()
+        if path.exists() and path.is_dir():
+            return str(path)
+        return value
+
+
+PROJECT_TYPE = ProjectType()
+
+
+class AutoRegisteringGroup(click.Group):
+    """
+    A click.Group subclass that automatically registers any click.Command
+    attributes defined on the class into the group.
+
+    After initialization, it inspects its own class for attributes that are
+    instances of click.Command (typically created via @click.command) and
+    calls self.add_command(cmd) on each. This lets you define your commands
+    as static methods on the subclass for IDE-friendly organization without
+    manual registration.
+    """
+
+    def __init__(self, name: str, help: str):
+        super().__init__(name=name, help=help)
+        # Scan class attributes for click.Command instances and register them.
+        for attr in dir(self.__class__):
+            cmd = getattr(self.__class__, attr)
+            if isinstance(cmd, click.Command):
+                self.add_command(cmd)
+
+
+class TopLevelCommands(AutoRegisteringGroup):
+    """Root CLI group containing the core Serena commands."""
+
+    def __init__(self) -> None:
+        super().__init__(name="serena", help="Serena CLI commands. You can run `<command> --help` for more info on each command.")
+
+    @staticmethod
+    @click.command("start-mcp-server", help="Starts the Serena MCP server.")
+    @click.option("--project", "project", type=PROJECT_TYPE, default=None, help="Path or name of project to activate at startup.")
+    @click.option("--project-file", "project", type=PROJECT_TYPE, default=None, help="[DEPRECATED] Use --project instead.")
+    @click.argument("project_file_arg", type=PROJECT_TYPE, required=False, default=None, metavar="")
+    @click.option(
+        "--context", type=str, default=DEFAULT_CONTEXT, show_default=True, help="Built-in context name or path to custom context YAML."
+    )
+    @click.option(
+        "--mode",
+        "modes",
+        type=str,
+        multiple=True,
+        default=DEFAULT_MODES,
+        show_default=True,
+        help="Built-in mode names or paths to custom mode YAMLs.",
+    )
+    @click.option("--transport", type=click.Choice(["stdio", "sse"]), default="stdio", show_default=True, help="Transport protocol.")
+    @click.option("--host", type=str, default="0.0.0.0", show_default=True)
+    @click.option("--port", type=int, default=8000, show_default=True)
+    @click.option("--enable-web-dashboard", type=bool, is_flag=False, default=None, help="Override dashboard setting in config.")
+    @click.option("--enable-gui-log-window", type=bool, is_flag=False, default=None, help="Override GUI log window setting in config.")
+    @click.option(
+        "--log-level",
+        type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]),
+        default=None,
+        help="Override log level in config.",
+    )
+    @click.option("--trace-lsp-communication", type=bool, is_flag=False, default=None, help="Whether to trace LSP communication.")
+    @click.option("--tool-timeout", type=float, default=None, help="Override tool execution timeout in config.")
+    def start_mcp_server(
+        project: str | None,
+        project_file_arg: str | None,
+        context: str,
+        modes: tuple[str, ...],
+        transport: Literal["stdio", "sse"],
+        host: str,
+        port: int,
+        enable_web_dashboard: bool | None,
+        enable_gui_log_window: bool | None,
+        log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None,
+        trace_lsp_communication: bool | None,
+        tool_timeout: float | None,
+    ) -> None:
+        # initialize logging, using INFO level initially (will later be adjusted by SerenaAgent according to the config)
+        #   * memory log handler (for use by GUI/Dashboard)
+        #   * stream handler for stderr (for direct console output, which will also be captured by clients like Claude Desktop)
+        #   * file handler
+        # (Note that stdout must never be used for logging, as it is used by the MCP server to communicate with the client.)
+        Logger.root.setLevel(logging.INFO)
+        formatter = logging.Formatter(SERENA_LOG_FORMAT)
+        memory_log_handler = MemoryLogHandler()
+        Logger.root.addHandler(memory_log_handler)
+        stderr_handler = logging.StreamHandler(stream=sys.stderr)
+        stderr_handler.formatter = formatter
+        Logger.root.addHandler(stderr_handler)
+        log_path = SerenaPaths().get_next_log_file_path("mcp")
+        file_handler = logging.FileHandler(log_path, mode="w")
+        file_handler.formatter = formatter
+        Logger.root.addHandler(file_handler)
+
+        log.info("Initializing Serena MCP server")
+        log.info("Storing logs in %s", log_path)
+        project_file = project_file_arg or project
+        factory = SerenaMCPFactorySingleProcess(context=context, project=project_file, memory_log_handler=memory_log_handler)
+        server = factory.create_mcp_server(
+            host=host,
+            port=port,
+            modes=modes,
+            enable_web_dashboard=enable_web_dashboard,
+            enable_gui_log_window=enable_gui_log_window,
+            log_level=log_level,
+            trace_lsp_communication=trace_lsp_communication,
+            tool_timeout=tool_timeout,
+        )
+        if project_file_arg:
+            log.warning(
+                "Positional project arg is deprecated; use --project instead. Used: %s",
+                project_file,
+            )
+        log.info("Starting MCP server …")
+        server.run(transport=transport)
+
+    @staticmethod
+    @click.command("print-system-prompt", help="Print the system prompt for a project.")
+    @click.argument("project", type=click.Path(exists=True), default=os.getcwd(), required=False)
+    @click.option(
+        "--log-level",
+        type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]),
+        default="WARNING",
+        help="Log level for prompt generation.",
+    )
+    @click.option("--only-instructions", is_flag=True, help="Print only the initial instructions, without prefix/postfix.")
+    @click.option(
+        "--context", type=str, default=DEFAULT_CONTEXT, show_default=True, help="Built-in context name or path to custom context YAML."
+    )
+    @click.option(
+        "--mode",
+        "modes",
+        type=str,
+        multiple=True,
+        default=DEFAULT_MODES,
+        show_default=True,
+        help="Built-in mode names or paths to custom mode YAMLs.",
+    )
+    def print_system_prompt(project: str, log_level: str, only_instructions: bool, context: str, modes: tuple[str, ...]) -> None:
+        prefix = "You will receive access to Serena's symbolic tools. Below are instructions for using them, take them into account."
+        postfix = "You begin by acknowledging that you understood the above instructions and are ready to receive tasks."
+        from serena.tools.workflow_tools import InitialInstructionsTool
+
+        lvl = logging.getLevelNamesMapping()[log_level.upper()]
+        logging.configure(level=lvl)
+        context_instance = SerenaAgentContext.load(context)
+        mode_instances = [SerenaAgentMode.load(mode) for mode in modes]
+        agent = SerenaAgent(
+            project=os.path.abspath(project),
+            serena_config=SerenaConfig(web_dashboard=False, log_level=lvl),
+            context=context_instance,
+            modes=mode_instances,
+        )
+        tool = agent.get_tool(InitialInstructionsTool)
+        instr = tool.apply()
+        if only_instructions:
+            print(instr)
+        else:
+            print(f"{prefix}\n{instr}\n{postfix}")
+
+
+class ModeCommands(AutoRegisteringGroup):
+    """Group for 'mode' subcommands."""
+
+    def __init__(self) -> None:
+        super().__init__(name="mode", help="Manage Serena modes. You can run `mode <command> --help` for more info on each command.")
+
+    @staticmethod
+    @click.command("list", help="List available modes.")
+    def list() -> None:
+        mode_names = SerenaAgentMode.list_registered_mode_names()
+        max_len_name = max(len(name) for name in mode_names) if mode_names else 20
+        for name in mode_names:
+            mode_yml_path = SerenaAgentMode.get_path(name)
+            is_internal = Path(mode_yml_path).is_relative_to(SERENAS_OWN_MODE_YAMLS_DIR)
+            descriptor = "(internal)" if is_internal else f"(at {mode_yml_path})"
+            name_descr_string = f"{name:<{max_len_name + 4}}{descriptor}"
+            click.echo(name_descr_string)
+
+    @staticmethod
+    @click.command("create", help="Create a new mode or copy an internal one.")
+    @click.option(
+        "--name",
+        "-n",
+        type=str,
+        default=None,
+        help="Name for the new mode. If --from-internal is passed may be left empty to create a mode of the same name, which will then override the internal mode.",
+    )
+    @click.option("--from-internal", "from_internal", type=str, default=None, help="Copy from an internal mode.")
+    def create(name: str, from_internal: str) -> None:
+        if not (name or from_internal):
+            raise click.UsageError("Provide at least one of --name or --from-internal.")
+        mode_name = name or from_internal
+        dest = os.path.join(USER_MODE_YAMLS_DIR, f"{mode_name}.yml")
+        src = (
+            os.path.join(SERENAS_OWN_MODE_YAMLS_DIR, f"{from_internal}.yml")
+            if from_internal
+            else os.path.join(SERENAS_OWN_MODE_YAMLS_DIR, "mode.template.yml")
+        )
+        if not os.path.exists(src):
+            raise FileNotFoundError(
+                f"Internal mode '{from_internal}' not found in {SERENAS_OWN_MODE_YAMLS_DIR}. Available modes: {SerenaAgentMode.list_registered_mode_names()}"
+            )
+        os.makedirs(os.path.dirname(dest), exist_ok=True)
+        shutil.copyfile(src, dest)
+        click.echo(f"Created mode '{mode_name}' at {dest}")
+        _open_in_editor(dest)
+
+    @staticmethod
+    @click.command("edit", help="Edit a custom mode YAML file.")
+    @click.argument("mode_name")
+    def edit(mode_name: str) -> None:
+        path = os.path.join(USER_MODE_YAMLS_DIR, f"{mode_name}.yml")
+        if not os.path.exists(path):
+            if mode_name in SerenaAgentMode.list_registered_mode_names(include_user_modes=False):
+                click.echo(
+                    f"Mode '{mode_name}' is an internal mode and cannot be edited directly. "
+                    f"Use 'mode create --from-internal {mode_name}' to create a custom mode that overrides it before editing."
+                )
+            else:
+                click.echo(f"Custom mode '{mode_name}' not found. Create it with: mode create --name {mode_name}.")
+            return
+        _open_in_editor(path)
+
+    @staticmethod
+    @click.command("delete", help="Delete a custom mode file.")
+    @click.argument("mode_name")
+    def delete(mode_name: str) -> None:
+        path = os.path.join(USER_MODE_YAMLS_DIR, f"{mode_name}.yml")
+        if not os.path.exists(path):
+            click.echo(f"Custom mode '{mode_name}' not found.")
+            return
+        os.remove(path)
+        click.echo(f"Deleted custom mode '{mode_name}'.")
+
+
+class ContextCommands(AutoRegisteringGroup):
+    """Group for 'context' subcommands."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            name="context", help="Manage Serena contexts. You can run `context <command> --help` for more info on each command."
+        )
+
+    @staticmethod
+    @click.command("list", help="List available contexts.")
+    def list() -> None:
+        context_names = SerenaAgentContext.list_registered_context_names()
+        max_len_name = max(len(name) for name in context_names) if context_names else 20
+        for name in context_names:
+            context_yml_path = SerenaAgentContext.get_path(name)
+            is_internal = Path(context_yml_path).is_relative_to(SERENAS_OWN_CONTEXT_YAMLS_DIR)
+            descriptor = "(internal)" if is_internal else f"(at {context_yml_path})"
+            name_descr_string = f"{name:<{max_len_name + 4}}{descriptor}"
+            click.echo(name_descr_string)
+
+    @staticmethod
+    @click.command("create", help="Create a new context or copy an internal one.")
+    @click.option(
+        "--name",
+        "-n",
+        type=str,
+        default=None,
+        help="Name for the new context. If --from-internal is passed may be left empty to create a context of the same name, which will then override the internal context",
+    )
+    @click.option("--from-internal", "from_internal", type=str, default=None, help="Copy from an internal context.")
+    def create(name: str, from_internal: str) -> None:
+        if not (name or from_internal):
+            raise click.UsageError("Provide at least one of --name or --from-internal.")
+        ctx_name = name or from_internal
+        dest = os.path.join(USER_CONTEXT_YAMLS_DIR, f"{ctx_name}.yml")
+        src = (
+            os.path.join(SERENAS_OWN_CONTEXT_YAMLS_DIR, f"{from_internal}.yml")
+            if from_internal
+            else os.path.join(SERENAS_OWN_CONTEXT_YAMLS_DIR, "context.template.yml")
+        )
+        if not os.path.exists(src):
+            raise FileNotFoundError(
+                f"Internal context '{from_internal}' not found in {SERENAS_OWN_CONTEXT_YAMLS_DIR}. Available contexts: {SerenaAgentContext.list_registered_context_names()}"
+            )
+        os.makedirs(os.path.dirname(dest), exist_ok=True)
+        shutil.copyfile(src, dest)
+        click.echo(f"Created context '{ctx_name}' at {dest}")
+        _open_in_editor(dest)
+
+    @staticmethod
+    @click.command("edit", help="Edit a custom context YAML file.")
+    @click.argument("context_name")
+    def edit(context_name: str) -> None:
+        path = os.path.join(USER_CONTEXT_YAMLS_DIR, f"{context_name}.yml")
+        if not os.path.exists(path):
+            if context_name in SerenaAgentContext.list_registered_context_names(include_user_contexts=False):
+                click.echo(
+                    f"Context '{context_name}' is an internal context and cannot be edited directly. "
+                    f"Use 'context create --from-internal {context_name}' to create a custom context that overrides it before editing."
+                )
+            else:
+                click.echo(f"Custom context '{context_name}' not found. Create it with: context create --name {context_name}.")
+            return
+        _open_in_editor(path)
+
+    @staticmethod
+    @click.command("delete", help="Delete a custom context file.")
+    @click.argument("context_name")
+    def delete(context_name: str) -> None:
+        path = os.path.join(USER_CONTEXT_YAMLS_DIR, f"{context_name}.yml")
+        if not os.path.exists(path):
+            click.echo(f"Custom context '{context_name}' not found.")
+            return
+        os.remove(path)
+        click.echo(f"Deleted custom context '{context_name}'.")
+
+
+class SerenaConfigCommands(AutoRegisteringGroup):
+    """Group for 'config' subcommands."""
+
+    def __init__(self) -> None:
+        super().__init__(name="config", help="Manage Serena configuration.")
+
+    @staticmethod
+    @click.command(
+        "edit", help="Edit serena_config.yml in your default editor. Will create a config file from the template if no config is found."
+    )
+    def edit() -> None:
+        config_path = os.path.join(SERENA_MANAGED_DIR_IN_HOME, "serena_config.yml")
+        if not os.path.exists(config_path):
+            SerenaConfig.generate_config_file(config_path)
+        _open_in_editor(config_path)
+
+
+class ProjectCommands(AutoRegisteringGroup):
+    """Group for 'project' subcommands."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            name="project", help="Manage Serena projects. You can run `project <command> --help` for more info on each command."
+        )
+
+    @staticmethod
+    @click.command("generate-yml", help="Generate a project.yml file.")
+    @click.argument("project_path", type=click.Path(exists=True, file_okay=False), default=os.getcwd())
+    @click.option("--language", type=str, default=None, help="Programming language; inferred if not specified.")
+    def generate_yml(project_path: str, language: str | None = None) -> None:
+        yml_path = os.path.join(project_path, ProjectConfig.rel_path_to_project_yml())
+        if os.path.exists(yml_path):
+            raise FileExistsError(f"Project file {yml_path} already exists.")
+        lang_inst = None
+        if language:
+            try:
+                lang_inst = Language[language.upper()]
+            except KeyError:
+                all_langs = [l.name.lower() for l in Language.iter_all(include_experimental=True)]
+                raise ValueError(f"Unknown language '{language}'. Supported: {all_langs}")
+        generated_conf = ProjectConfig.autogenerate(project_root=project_path, project_language=lang_inst)
+        print(f"Generated project.yml with language {generated_conf.language.value} at {yml_path}.")
+
+    @staticmethod
+    @click.command("index", help="Index a project by saving symbols to the LSP cache.")
+    @click.argument("project", type=click.Path(exists=True), default=os.getcwd(), required=False)
+    @click.option(
+        "--log-level",
+        type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]),
+        default="WARNING",
+        help="Log level for indexing.",
+    )
+    @click.option("--timeout", type=float, default=10, help="Timeout for indexing a single file.")
+    def index(project: str, log_level: str, timeout: float) -> None:
+        ProjectCommands._index_project(project, log_level, timeout=timeout)
+
+    @staticmethod
+    @click.command("index-deprecated", help="Deprecated alias for 'serena project index'.")
+    @click.argument("project", type=click.Path(exists=True), default=os.getcwd(), required=False)
+    @click.option("--log-level", type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]), default="WARNING")
+    @click.option("--timeout", type=float, default=10, help="Timeout for indexing a single file.")
+    def index_deprecated(project: str, log_level: str, timeout: float) -> None:
+        click.echo("Deprecated! Use `serena project index` instead.")
+        ProjectCommands._index_project(project, log_level, timeout=timeout)
+
+    @staticmethod
+    def _index_project(project: str, log_level: str, timeout: float) -> None:
+        lvl = logging.getLevelNamesMapping()[log_level.upper()]
+        logging.configure(level=lvl)
+        proj = Project.load(os.path.abspath(project))
+        click.echo(f"Indexing symbols in project {project}…")
+        ls = proj.create_language_server(log_level=lvl, ls_timeout=timeout)
+        log_file = os.path.join(project, ".serena", "logs", "indexing.txt")
+
+        collected_exceptions: list[Exception] = []
+        files_failed = []
+        with ls.start_server():
+            files = proj.gather_source_files()
+            for i, f in enumerate(tqdm(files, desc="Indexing")):
+                try:
+                    ls.request_document_symbols(f, include_body=False)
+                    ls.request_document_symbols(f, include_body=True)
+                except Exception as e:
+                    log.error(f"Failed to index {f}, continuing.")
+                    collected_exceptions.append(e)
+                    files_failed.append(f)
+                if (i + 1) % 10 == 0:
+                    ls.save_cache()
+            ls.save_cache()
+        click.echo(f"Symbols saved to {ls.cache_path}")
+        if len(files_failed) > 0:
+            os.makedirs(os.path.dirname(log_file), exist_ok=True)
+            with open(log_file, "w") as f:
+                for file, exception in zip(files_failed, collected_exceptions, strict=True):
+                    f.write(f"{file}\n")
+                    f.write(f"{exception}\n")
+            click.echo(f"Failed to index {len(files_failed)} files, see:\n{log_file}")
+
+    @staticmethod
+    @click.command("is_ignored_path", help="Check if a path is ignored by the project configuration.")
+    @click.argument("path", type=click.Path(exists=False, file_okay=True, dir_okay=True))
+    @click.argument("project", type=click.Path(exists=True, file_okay=False, dir_okay=True), default=os.getcwd())
+    def is_ignored_path(path: str, project: str) -> None:
+        """
+        Check if a given path is ignored by the project configuration.
+
+        :param path: The path to check.
+        :param project: The path to the project directory, defaults to the current working directory.
+        """
+        proj = Project.load(os.path.abspath(project))
+        if os.path.isabs(path):
+            path = os.path.relpath(path, start=proj.project_root)
+        is_ignored = proj.is_ignored_path(path)
+        click.echo(f"Path '{path}' IS {'ignored' if is_ignored else 'IS NOT ignored'} by the project configuration.")
+
+    @staticmethod
+    @click.command("index-file", help="Index a single file by saving its symbols to the LSP cache.")
+    @click.argument("file", type=click.Path(exists=True, file_okay=True, dir_okay=False))
+    @click.argument("project", type=click.Path(exists=True, file_okay=False, dir_okay=True), default=os.getcwd())
+    @click.option("--verbose", "-v", is_flag=True, help="Print detailed information about the indexed symbols.")
+    def index_file(file: str, project: str, verbose: bool) -> None:
+        """
+        Index a single file by saving its symbols to the LSP cache, useful for debugging.
+        :param file: path to the file to index, must be inside the project directory.
+        :param project: path to the project directory, defaults to the current working directory.
+        :param verbose: if set, prints detailed information about the indexed symbols.
+        """
+        proj = Project.load(os.path.abspath(project))
+        if os.path.isabs(file):
+            file = os.path.relpath(file, start=proj.project_root)
+        if proj.is_ignored_path(file, ignore_non_source_files=True):
+            click.echo(f"'{file}' is ignored or declared as non-code file by the project configuration, won't index.")
+            exit(1)
+        ls = proj.create_language_server()
+        with ls.start_server():
+            symbols, _ = ls.request_document_symbols(file, include_body=False)
+            ls.request_document_symbols(file, include_body=True)
+            if verbose:
+                click.echo(f"Symbols in file '{file}':")
+                for symbol in symbols:
+                    click.echo(f"  - {symbol['name']} at line {symbol['selectionRange']['start']['line']} of kind {symbol['kind']}")
+            ls.save_cache()
+            click.echo(f"Successfully indexed file '{file}', {len(symbols)} symbols saved to {ls.cache_path}.")
+
+    @staticmethod
+    @click.command("health-check", help="Perform a comprehensive health check of the project's tools and language server.")
+    @click.argument("project", type=click.Path(exists=True, file_okay=False, dir_okay=True), default=os.getcwd())
+    def health_check(project: str) -> None:
+        """
+        Perform a comprehensive health check of the project's tools and language server.
+
+        :param project: path to the project directory, defaults to the current working directory.
+        """
+        # NOTE: completely written by Claude Code, only functionality was reviewed, not implementation
+        logging.configure(level=logging.INFO)
+        project_path = os.path.abspath(project)
+        proj = Project.load(project_path)
+
+        # Create log file with timestamp
+        timestamp = datetime_tag()
+        log_dir = os.path.join(project_path, ".serena", "logs", "health-checks")
+        os.makedirs(log_dir, exist_ok=True)
+        log_file = os.path.join(log_dir, f"health_check_{timestamp}.log")
+
+        with FileLoggerContext(log_file, append=False, enabled=True):
+            log.info("Starting health check for project: %s", project_path)
+
+            try:
+                # Create SerenaAgent with dashboard disabled
+                log.info("Creating SerenaAgent with disabled dashboard...")
+                config = SerenaConfig(gui_log_window_enabled=False, web_dashboard=False)
+                agent = SerenaAgent(project=project_path, serena_config=config)
+                log.info("SerenaAgent created successfully")
+
+                # Find first non-empty file that can be analyzed
+                log.info("Searching for analyzable files...")
+                files = proj.gather_source_files()
+                target_file = None
+
+                for file_path in files:
+                    try:
+                        full_path = os.path.join(project_path, file_path)
+                        if os.path.getsize(full_path) > 0:
+                            target_file = file_path
+                            log.info("Found analyzable file: %s", target_file)
+                            break
+                    except (OSError, FileNotFoundError):
+                        continue
+
+                if not target_file:
+                    log.error("No analyzable files found in project")
+                    click.echo("❌ Health check failed: No analyzable files found")
+                    click.echo(f"Log saved to: {log_file}")
+                    return
+
+                # Get tools from agent
+                overview_tool = agent.get_tool(GetSymbolsOverviewTool)
+                find_symbol_tool = agent.get_tool(FindSymbolTool)
+                find_refs_tool = agent.get_tool(FindReferencingSymbolsTool)
+                search_pattern_tool = agent.get_tool(SearchForPatternTool)
+
+                # Test 1: Get symbols overview
+                log.info("Testing GetSymbolsOverviewTool on file: %s", target_file)
+                overview_result = agent.execute_task(lambda: overview_tool.apply(target_file))
+                overview_data = json.loads(overview_result)
+                log.info("GetSymbolsOverviewTool returned %d symbols", len(overview_data))
+
+                if not overview_data:
+                    log.error("No symbols found in file %s", target_file)
+                    click.echo("❌ Health check failed: No symbols found in target file")
+                    click.echo(f"Log saved to: {log_file}")
+                    return
+
+                # Extract suitable symbol (prefer class or function over variables)
+                # LSP symbol kinds: 5=class, 12=function, 6=method, 9=constructor
+                preferred_kinds = [5, 12, 6, 9]  # class, function, method, constructor
+
+                selected_symbol = None
+                for symbol in overview_data:
+                    if symbol.get("kind") in preferred_kinds:
+                        selected_symbol = symbol
+                        break
+
+                # If no preferred symbol found, use first available
+                if not selected_symbol:
+                    selected_symbol = overview_data[0]
+                    log.info("No class or function found, using first available symbol")
+
+                symbol_name = selected_symbol.get("name_path", "unknown")
+                symbol_kind = selected_symbol.get("kind", "unknown")
+                log.info("Using symbol for testing: %s (kind: %d)", symbol_name, symbol_kind)
+
+                # Test 2: FindSymbolTool
+                log.info("Testing FindSymbolTool for symbol: %s", symbol_name)
+                find_symbol_result = agent.execute_task(
+                    lambda: find_symbol_tool.apply(symbol_name, relative_path=target_file, include_body=True)
+                )
+                find_symbol_data = json.loads(find_symbol_result)
+                log.info("FindSymbolTool found %d matches for symbol %s", len(find_symbol_data), symbol_name)
+
+                # Test 3: FindReferencingSymbolsTool
+                log.info("Testing FindReferencingSymbolsTool for symbol: %s", symbol_name)
+                try:
+                    find_refs_result = agent.execute_task(lambda: find_refs_tool.apply(symbol_name, relative_path=target_file))
+                    find_refs_data = json.loads(find_refs_result)
+                    log.info("FindReferencingSymbolsTool found %d references for symbol %s", len(find_refs_data), symbol_name)
+                except Exception as e:
+                    log.warning("FindReferencingSymbolsTool failed for symbol %s: %s", symbol_name, str(e))
+                    find_refs_data = []
+
+                # Test 4: SearchForPatternTool to verify references
+                log.info("Testing SearchForPatternTool for pattern: %s", symbol_name)
+                try:
+                    search_result = agent.execute_task(
+                        lambda: search_pattern_tool.apply(substring_pattern=symbol_name, restrict_search_to_code_files=True)
+                    )
+                    search_data = json.loads(search_result)
+                    pattern_matches = sum(len(matches) for matches in search_data.values())
+                    log.info("SearchForPatternTool found %d pattern matches for %s", pattern_matches, symbol_name)
+                except Exception as e:
+                    log.warning("SearchForPatternTool failed for pattern %s: %s", symbol_name, str(e))
+                    pattern_matches = 0
+
+                # Verify tools worked as expected
+                tools_working = True
+                if not find_symbol_data:
+                    log.error("FindSymbolTool returned no results")
+                    tools_working = False
+
+                if len(find_refs_data) == 0 and pattern_matches == 0:
+                    log.warning("Both FindReferencingSymbolsTool and SearchForPatternTool found no matches - this might indicate an issue")
+
+                log.info("Health check completed successfully")
+
+                if tools_working:
+                    click.echo("✅ Health check passed - All tools working correctly")
+                else:
+                    click.echo("⚠️  Health check completed with warnings - Check log for details")
+
+            except Exception as e:
+                log.exception("Health check failed with exception: %s", str(e))
+                click.echo(f"❌ Health check failed: {e!s}")
+
+            finally:
+                click.echo(f"Log saved to: {log_file}")
+
+
+class ToolCommands(AutoRegisteringGroup):
+    """Group for 'tool' subcommands."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            name="tools",
+            help="Commands related to Serena's tools. You can run `serena tools <command> --help` for more info on each command.",
+        )
+
+    @staticmethod
+    @click.command(
+        "list",
+        help="Prints an overview of the tools that are active by default (not just the active ones for your project). For viewing all tools, pass `--all / -a`",
+    )
+    @click.option("--quiet", "-q", is_flag=True)
+    @click.option("--all", "-a", "include_optional", is_flag=True, help="List all tools, including those not enabled by default.")
+    @click.option("--only-optional", is_flag=True, help="List only optional tools (those not enabled by default).")
+    def list(quiet: bool = False, include_optional: bool = False, only_optional: bool = False) -> None:
+        tool_registry = ToolRegistry()
+        if quiet:
+            if only_optional:
+                tool_names = tool_registry.get_tool_names_optional()
+            elif include_optional:
+                tool_names = tool_registry.get_tool_names()
+            else:
+                tool_names = tool_registry.get_tool_names_default_enabled()
+            for tool_name in tool_names:
+                click.echo(tool_name)
+        else:
+            ToolRegistry().print_tool_overview(include_optional=include_optional, only_optional=only_optional)
+
+    @staticmethod
+    @click.command(
+        "description",
+        help="Print the description of a tool, optionally with a specific context (the latter may modify the default description).",
+    )
+    @click.argument("tool_name", type=str)
+    @click.option("--context", type=str, default=None, help="Context name or path to context file.")
+    def description(tool_name: str, context: str | None = None) -> None:
+        # Load the context
+        serena_context = None
+        if context:
+            serena_context = SerenaAgentContext.load(context)
+
+        agent = SerenaAgent(
+            project=None,
+            serena_config=SerenaConfig(web_dashboard=False, log_level=logging.INFO),
+            context=serena_context,
+        )
+        tool = agent.get_tool_by_name(tool_name)
+        mcp_tool = SerenaMCPFactory.make_mcp_tool(tool)
+        click.echo(mcp_tool.description)
+
+
+class PromptCommands(AutoRegisteringGroup):
+    def __init__(self) -> None:
+        super().__init__(name="prompts", help="Commands related to Serena's prompts that are outside of contexts and modes.")
+
+    @staticmethod
+    def _get_user_prompt_yaml_path(prompt_yaml_name: str) -> str:
+        os.makedirs(PROMPT_TEMPLATES_DIR_IN_USER_HOME, exist_ok=True)
+        return os.path.join(PROMPT_TEMPLATES_DIR_IN_USER_HOME, prompt_yaml_name)
+
+    @staticmethod
+    @click.command("list", help="Lists yamls that are used for defining prompts.")
+    def list() -> None:
+        serena_prompt_yaml_names = [os.path.basename(f) for f in glob.glob(PROMPT_TEMPLATES_DIR_INTERNAL + "/*.yml")]
+        for prompt_yaml_name in serena_prompt_yaml_names:
+            user_prompt_yaml_path = PromptCommands._get_user_prompt_yaml_path(prompt_yaml_name)
+            if os.path.exists(user_prompt_yaml_path):
+                click.echo(f"{user_prompt_yaml_path} merged with default prompts in {prompt_yaml_name}")
+            else:
+                click.echo(prompt_yaml_name)
+
+    @staticmethod
+    @click.command("create-override", help="Create an override of an internal prompts yaml for customizing Serena's prompts")
+    @click.argument("prompt_yaml_name")
+    def create_override(prompt_yaml_name: str) -> None:
+        """
+        :param prompt_yaml_name: The yaml name of the prompt you want to override. Call the `list` command for discovering valid prompt yaml names.
+        :return:
+        """
+        # for convenience, we can pass names without .yml
+        if not prompt_yaml_name.endswith(".yml"):
+            prompt_yaml_name = prompt_yaml_name + ".yml"
+        user_prompt_yaml_path = PromptCommands._get_user_prompt_yaml_path(prompt_yaml_name)
+        if os.path.exists(user_prompt_yaml_path):
+            raise FileExistsError(f"{user_prompt_yaml_path} already exists.")
+        serena_prompt_yaml_path = os.path.join(PROMPT_TEMPLATES_DIR_INTERNAL, prompt_yaml_name)
+        shutil.copyfile(serena_prompt_yaml_path, user_prompt_yaml_path)
+        _open_in_editor(user_prompt_yaml_path)
+
+    @staticmethod
+    @click.command("edit-override", help="Edit an existing prompt override file")
+    @click.argument("prompt_yaml_name")
+    def edit_override(prompt_yaml_name: str) -> None:
+        """
+        :param prompt_yaml_name: The yaml name of the prompt override to edit.
+        :return:
+        """
+        # for convenience, we can pass names without .yml
+        if not prompt_yaml_name.endswith(".yml"):
+            prompt_yaml_name = prompt_yaml_name + ".yml"
+        user_prompt_yaml_path = PromptCommands._get_user_prompt_yaml_path(prompt_yaml_name)
+        if not os.path.exists(user_prompt_yaml_path):
+            click.echo(f"Override file '{prompt_yaml_name}' not found. Create it with: prompts create-override {prompt_yaml_name}")
+            return
+        _open_in_editor(user_prompt_yaml_path)
+
+    @staticmethod
+    @click.command("list-overrides", help="List existing prompt override files")
+    def list_overrides() -> None:
+        os.makedirs(PROMPT_TEMPLATES_DIR_IN_USER_HOME, exist_ok=True)
+        serena_prompt_yaml_names = [os.path.basename(f) for f in glob.glob(PROMPT_TEMPLATES_DIR_INTERNAL + "/*.yml")]
+        override_files = glob.glob(os.path.join(PROMPT_TEMPLATES_DIR_IN_USER_HOME, "*.yml"))
+        for file_path in override_files:
+            if os.path.basename(file_path) in serena_prompt_yaml_names:
+                click.echo(file_path)
+
+    @staticmethod
+    @click.command("delete-override", help="Delete a prompt override file")
+    @click.argument("prompt_yaml_name")
+    def delete_override(prompt_yaml_name: str) -> None:
+        """
+
+        :param prompt_yaml_name:  The yaml name of the prompt override to delete."
+        :return:
+        """
+        # for convenience, we can pass names without .yml
+        if not prompt_yaml_name.endswith(".yml"):
+            prompt_yaml_name = prompt_yaml_name + ".yml"
+        user_prompt_yaml_path = PromptCommands._get_user_prompt_yaml_path(prompt_yaml_name)
+        if not os.path.exists(user_prompt_yaml_path):
+            click.echo(f"Override file '{prompt_yaml_name}' not found.")
+            return
+        os.remove(user_prompt_yaml_path)
+        click.echo(f"Deleted override file '{prompt_yaml_name}'.")
+
+
+# Expose groups so we can reference them in pyproject.toml
+mode = ModeCommands()
+context = ContextCommands()
+project = ProjectCommands()
+config = SerenaConfigCommands()
+tools = ToolCommands()
+prompts = PromptCommands()
+
+# Expose toplevel commands for the same reason
+top_level = TopLevelCommands()
+start_mcp_server = top_level.start_mcp_server
+index_project = project.index_deprecated
+
+# needed for the help script to work - register all subcommands to the top-level group
+for subgroup in (mode, context, project, config, tools, prompts):
+    top_level.add_command(subgroup)
+
+
+def get_help() -> str:
+    """Retrieve the help text for the top-level Serena CLI."""
+    return top_level.get_help(click.Context(top_level, info_name="serena"))

projects/ui/serena-new/src/serena/code_editor.py

@@ -0,0 +1,297 @@
+import json
+import logging
+import os
+from abc import ABC, abstractmethod
+from collections.abc import Iterable, Iterator, Reversible
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Generic, Optional, TypeVar
+
+from serena.symbol import JetBrainsSymbol, LanguageServerSymbol, LanguageServerSymbolRetriever, PositionInFile, Symbol
+from solidlsp import SolidLanguageServer
+from solidlsp.ls import LSPFileBuffer
+from solidlsp.ls_utils import TextUtils
+
+from .project import Project
+from .tools.jetbrains_plugin_client import JetBrainsPluginClient
+
+if TYPE_CHECKING:
+    from .agent import SerenaAgent
+
+
+log = logging.getLogger(__name__)
+TSymbol = TypeVar("TSymbol", bound=Symbol)
+
+
+class CodeEditor(Generic[TSymbol], ABC):
+    def __init__(self, project_root: str, agent: Optional["SerenaAgent"] = None) -> None:
+        self.project_root = project_root
+        self.agent = agent
+
+    class EditedFile(ABC):
+        @abstractmethod
+        def get_contents(self) -> str:
+            """
+            :return: the contents of the file.
+            """
+
+        @abstractmethod
+        def delete_text_between_positions(self, start_pos: PositionInFile, end_pos: PositionInFile) -> None:
+            pass
+
+        @abstractmethod
+        def insert_text_at_position(self, pos: PositionInFile, text: str) -> None:
+            pass
+
+    @contextmanager
+    def _open_file_context(self, relative_path: str) -> Iterator["CodeEditor.EditedFile"]:
+        """
+        Context manager for opening a file
+        """
+        raise NotImplementedError("This method must be overridden for each subclass")
+
+    @contextmanager
+    def _edited_file_context(self, relative_path: str) -> Iterator["CodeEditor.EditedFile"]:
+        """
+        Context manager for editing a file.
+        """
+        with self._open_file_context(relative_path) as edited_file:
+            yield edited_file
+            # save the file
+            abs_path = os.path.join(self.project_root, relative_path)
+            with open(abs_path, "w", encoding="utf-8") as f:
+                f.write(edited_file.get_contents())
+            # notify agent (if provided)
+            if self.agent is not None:
+                self.agent.mark_file_modified(relative_path)
+
+    @abstractmethod
+    def _find_unique_symbol(self, name_path: str, relative_file_path: str) -> TSymbol:
+        """
+        Finds the unique symbol with the given name in the given file.
+        If no such symbol exists, raises a ValueError.
+
+        :param name_path: the name path
+        :param relative_file_path: the relative path of the file in which to search for the symbol.
+        :return: the unique symbol
+        """
+
+    def replace_body(self, name_path: str, relative_file_path: str, body: str) -> None:
+        """
+        Replaces the body of the symbol with the given name_path in the given file.
+
+        :param name_path: the name path of the symbol to replace.
+        :param relative_file_path: the relative path of the file in which the symbol is defined.
+        :param body: the new body
+        """
+        symbol = self._find_unique_symbol(name_path, relative_file_path)
+        start_pos = symbol.get_body_start_position_or_raise()
+        end_pos = symbol.get_body_end_position_or_raise()
+
+        with self._edited_file_context(relative_file_path) as edited_file:
+            # make sure the replacement adds no additional newlines (before or after) - all newlines
+            # and whitespace before/after should remain the same, so we strip it entirely
+            body = body.strip()
+
+            edited_file.delete_text_between_positions(start_pos, end_pos)
+            edited_file.insert_text_at_position(start_pos, body)
+
+    @staticmethod
+    def _count_leading_newlines(text: Iterable) -> int:
+        cnt = 0
+        for c in text:
+            if c == "\n":
+                cnt += 1
+            elif c == "\r":
+                continue
+            else:
+                break
+        return cnt
+
+    @classmethod
+    def _count_trailing_newlines(cls, text: Reversible) -> int:
+        return cls._count_leading_newlines(reversed(text))
+
+    def insert_after_symbol(self, name_path: str, relative_file_path: str, body: str) -> None:
+        """
+        Inserts content after the symbol with the given name in the given file.
+        """
+        symbol = self._find_unique_symbol(name_path, relative_file_path)
+
+        # make sure body always ends with at least one newline
+        if not body.endswith("\n"):
+            body += "\n"
+
+        pos = symbol.get_body_end_position_or_raise()
+
+        # start at the beginning of the next line
+        col = 0
+        line = pos.line + 1
+
+        # make sure a suitable number of leading empty lines is used (at least 0/1 depending on the symbol type,
+        # otherwise as many as the caller wanted to insert)
+        original_leading_newlines = self._count_leading_newlines(body)
+        body = body.lstrip("\r\n")
+        min_empty_lines = 0
+        if symbol.is_neighbouring_definition_separated_by_empty_line():
+            min_empty_lines = 1
+        num_leading_empty_lines = max(min_empty_lines, original_leading_newlines)
+        if num_leading_empty_lines:
+            body = ("\n" * num_leading_empty_lines) + body
+
+        # make sure the one line break succeeding the original symbol, which we repurposed as prefix via
+        # `line += 1`, is replaced
+        body = body.rstrip("\r\n") + "\n"
+
+        with self._edited_file_context(relative_file_path) as edited_file:
+            edited_file.insert_text_at_position(PositionInFile(line, col), body)
+
+    def insert_before_symbol(self, name_path: str, relative_file_path: str, body: str) -> None:
+        """
+        Inserts content before the symbol with the given name in the given file.
+        """
+        symbol = self._find_unique_symbol(name_path, relative_file_path)
+        symbol_start_pos = symbol.get_body_start_position_or_raise()
+
+        # insert position is the start of line where the symbol is defined
+        line = symbol_start_pos.line
+        col = 0
+
+        original_trailing_empty_lines = self._count_trailing_newlines(body) - 1
+
+        # ensure eol is present at end
+        body = body.rstrip() + "\n"
+
+        # add suitable number of trailing empty lines after the body (at least 0/1 depending on the symbol type,
+        # otherwise as many as the caller wanted to insert)
+        min_trailing_empty_lines = 0
+        if symbol.is_neighbouring_definition_separated_by_empty_line():
+            min_trailing_empty_lines = 1
+        num_trailing_newlines = max(min_trailing_empty_lines, original_trailing_empty_lines)
+        body += "\n" * num_trailing_newlines
+
+        # apply edit
+        with self._edited_file_context(relative_file_path) as edited_file:
+            edited_file.insert_text_at_position(PositionInFile(line=line, col=col), body)
+
+    def insert_at_line(self, relative_path: str, line: int, content: str) -> None:
+        """
+        Inserts content at the given line in the given file.
+
+        :param relative_path: the relative path of the file in which to insert content
+        :param line: the 0-based index of the line to insert content at
+        :param content: the content to insert
+        """
+        with self._edited_file_context(relative_path) as edited_file:
+            edited_file.insert_text_at_position(PositionInFile(line, 0), content)
+
+    def delete_lines(self, relative_path: str, start_line: int, end_line: int) -> None:
+        """
+        Deletes lines in the given file.
+
+        :param relative_path: the relative path of the file in which to delete lines
+        :param start_line: the 0-based index of the first line to delete (inclusive)
+        :param end_line: the 0-based index of the last line to delete (inclusive)
+        """
+        start_col = 0
+        end_line_for_delete = end_line + 1
+        end_col = 0
+        with self._edited_file_context(relative_path) as edited_file:
+            start_pos = PositionInFile(line=start_line, col=start_col)
+            end_pos = PositionInFile(line=end_line_for_delete, col=end_col)
+            edited_file.delete_text_between_positions(start_pos, end_pos)
+
+    def delete_symbol(self, name_path: str, relative_file_path: str) -> None:
+        """
+        Deletes the symbol with the given name in the given file.
+        """
+        symbol = self._find_unique_symbol(name_path, relative_file_path)
+        start_pos = symbol.get_body_start_position_or_raise()
+        end_pos = symbol.get_body_end_position_or_raise()
+        with self._edited_file_context(relative_file_path) as edited_file:
+            edited_file.delete_text_between_positions(start_pos, end_pos)
+
+
+class LanguageServerCodeEditor(CodeEditor[LanguageServerSymbol]):
+    def __init__(self, symbol_retriever: LanguageServerSymbolRetriever, agent: Optional["SerenaAgent"] = None):
+        super().__init__(project_root=symbol_retriever.get_language_server().repository_root_path, agent=agent)
+        self._symbol_retriever = symbol_retriever
+
+    @property
+    def _lang_server(self) -> SolidLanguageServer:
+        return self._symbol_retriever.get_language_server()
+
+    class EditedFile(CodeEditor.EditedFile):
+        def __init__(self, lang_server: SolidLanguageServer, relative_path: str, file_buffer: LSPFileBuffer):
+            self._lang_server = lang_server
+            self._relative_path = relative_path
+            self._file_buffer = file_buffer
+
+        def get_contents(self) -> str:
+            return self._file_buffer.contents
+
+        def delete_text_between_positions(self, start_pos: PositionInFile, end_pos: PositionInFile) -> None:
+            self._lang_server.delete_text_between_positions(self._relative_path, start_pos.to_lsp_position(), end_pos.to_lsp_position())
+
+        def insert_text_at_position(self, pos: PositionInFile, text: str) -> None:
+            self._lang_server.insert_text_at_position(self._relative_path, pos.line, pos.col, text)
+
+    @contextmanager
+    def _open_file_context(self, relative_path: str) -> Iterator["CodeEditor.EditedFile"]:
+        with self._lang_server.open_file(relative_path) as file_buffer:
+            yield self.EditedFile(self._lang_server, relative_path, file_buffer)
+
+    def _get_code_file_content(self, relative_path: str) -> str:
+        """Get the content of a file using the language server."""
+        return self._lang_server.language_server.retrieve_full_file_content(relative_path)
+
+    def _find_unique_symbol(self, name_path: str, relative_file_path: str) -> LanguageServerSymbol:
+        symbol_candidates = self._symbol_retriever.find_by_name(name_path, within_relative_path=relative_file_path)
+        if len(symbol_candidates) == 0:
+            raise ValueError(f"No symbol with name {name_path} found in file {relative_file_path}")
+        if len(symbol_candidates) > 1:
+            raise ValueError(
+                f"Found multiple {len(symbol_candidates)} symbols with name {name_path} in file {relative_file_path}. "
+                "Their locations are: \n " + json.dumps([s.location.to_dict() for s in symbol_candidates], indent=2)
+            )
+        return symbol_candidates[0]
+
+
+class JetBrainsCodeEditor(CodeEditor[JetBrainsSymbol]):
+    def __init__(self, project: Project, agent: Optional["SerenaAgent"] = None) -> None:
+        self._project = project
+        super().__init__(project_root=project.project_root, agent=agent)
+
+    class EditedFile(CodeEditor.EditedFile):
+        def __init__(self, relative_path: str, project: Project):
+            path = os.path.join(project.project_root, relative_path)
+            log.info("Editing file: %s", path)
+            with open(path, encoding=project.project_config.encoding) as f:
+                self._content = f.read()
+
+        def get_contents(self) -> str:
+            return self._content
+
+        def delete_text_between_positions(self, start_pos: PositionInFile, end_pos: PositionInFile) -> None:
+            self._content, _ = TextUtils.delete_text_between_positions(
+                self._content, start_pos.line, start_pos.col, end_pos.line, end_pos.col
+            )
+
+        def insert_text_at_position(self, pos: PositionInFile, text: str) -> None:
+            self._content, _, _ = TextUtils.insert_text_at_position(self._content, pos.line, pos.col, text)
+
+    @contextmanager
+    def _open_file_context(self, relative_path: str) -> Iterator["CodeEditor.EditedFile"]:
+        yield self.EditedFile(relative_path, self._project)
+
+    def _find_unique_symbol(self, name_path: str, relative_file_path: str) -> JetBrainsSymbol:
+        with JetBrainsPluginClient.from_project(self._project) as client:
+            result = client.find_symbol(name_path, relative_path=relative_file_path, include_body=False, depth=0, include_location=True)
+            symbols = result["symbols"]
+            if not symbols:
+                raise ValueError(f"No symbol with name {name_path} found in file {relative_file_path}")
+            if len(symbols) > 1:
+                raise ValueError(
+                    f"Found multiple {len(symbols)} symbols with name {name_path} in file {relative_file_path}. "
+                    "Their locations are: \n " + json.dumps([s["location"] for s in symbols], indent=2)
+                )
+            return JetBrainsSymbol(symbols[0], self._project)