Merge remote-tracking branch 'origin/main' into improve-docker-config

.github/workflows/pytest.yml

@@ -115,6 +115,10 @@ jobs:
         with:
           distribution: 'temurin'
           java-version: '17'
+      - name: Setup .NET SDK (for F# and C# languages)
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '8.0.x'
       - name: Install Terraform
         uses: hashicorp/setup-terraform@v3
         with:

.gitignore

@@ -251,4 +251,7 @@ test/resources/repos/scala/.bloop/
 stack.yaml.lock
 dist-newstyle/
 cabal.project.local*
-.ghc.environment.*
+.ghc.environment.*
+
+zz-misc/
+vue-implementation/

CHANGELOG.md

@@ -38,6 +38,7 @@ Status of the `main` branch. Changes prior to the next official version change w
   * **Add support for Julia** via LanguageServer.jl
   * **Add support for Haskell** via Haskell Language Server (HLS) with automatic discovery via ghcup, stack, or system PATH; supports both Stack and Cabal projects
   * **Add support for Scala** via Metals language server (requires some [manual setup](docs/03-special-guides/scala_setup_guide_for_serena.md))
+  * **Add support for F#** via FsAutoComplete/Ionide LSP server. 
   * **Add support for Elm** via @elm-tooling/elm-language-server (automatically downloads if not installed; requires Elm compiler)
   * **Add support for Perl** via Perl::LanguageServer with LSP integration for .pl, .pm, and .t files
   * **Add support for AL (Application Language)** for Microsoft Dynamics 365 Business Central development. Requires VS Code AL extension (ms-dynamics-smb.al).

CLAUDE.md

@@ -9,11 +9,12 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - `uv run poe type-check` - Run mypy type checking - ONLY allowed type checking command  
 - `uv run poe test` - Run tests with default markers (excludes java/rust by default)
 - `uv run poe test -m "python or go"` - Run specific language tests
+- `uv run poe test -m vue` - Run Vue tests
 - `uv run poe lint` - Check code style without fixing
 
 **Test Markers:**
 Available pytest markers for selective testing:
-- `python`, `go`, `java`, `rust`, `typescript`, `php`, `perl`, `csharp`, `elixir`, `terraform`, `clojure`, `swift`, `bash`, `ruby`, `ruby_solargraph`
+- `python`, `go`, `java`, `rust`, `typescript`, `vue`, `php`, `perl`, `csharp`, `elixir`, `terraform`, `clojure`, `swift`, `bash`, `ruby`, `ruby_solargraph`
 - `snapshot` - for symbolic editing operation tests
 
 **Project Management:**
@@ -100,7 +101,7 @@ Configuration is loaded from (in order of precedence):
 - **Symbol-based editing** - Uses LSP for precise code manipulation
 - **Caching strategy** - Reduces language server overhead
 - **Error recovery** - Automatic language server restart on crashes
-- **Multi-language support** - 16+ languages with LSP integration
+- **Multi-language support** - 19 languages with LSP integration (including Vue)
 - **MCP protocol** - Exposes tools to AI agents via Model Context Protocol
 - **Async operation** - Non-blocking language server interactions
 

docs/01-about/020_programming-languages.md

@@ -25,7 +25,9 @@ With Serena, we provide direct, out-of-the-box support for:
   (requires Elm compiler)
 * **Erlang**  
   (requires installation of beam and [erlang_ls](https://github.com/erlang-ls/erlang_ls); experimental, might be slow or hang)
-* **Fortran**  
+* **F#**  
+  (requires .NET SDK 8.0+; uses FsAutoComplete/Ionide, which is auto-installed; for Homebrew .NET on macOS, set DOTNET_ROOT in your environment)
+* **Fortran**   
   (requires installation of fortls: `pip install fortls`)
 * **Go**  
   (requires installation of `gopls`)
@@ -56,6 +58,9 @@ With Serena, we provide direct, out-of-the-box support for:
   (requires some [manual setup](../03-special-guides/scala_setup_guide_for_serena); uses Metals LSP)
 * **Swift**
 * **TypeScript**
+* **Vue**    
+  (3.x with TypeScript; requires Node.js v18+ and npm; supports .vue Single File Components with monorepo detection)
+* **YAML**
 * **Zig**  
   (requires installation of ZLS - Zig Language Server)
 

docs/02-usage/030_clients.md

@@ -24,7 +24,7 @@ claude mcp add serena -- uvx --from git+https://github.com/oraios/serena serena
 ```
 
 Note:
-  * We use the `ide-assistant` context to disable unnecessary tools (avoiding duplication
+  * We use the `claude-code` context to disable unnecessary tools (avoiding duplication
     with Claude Code's built-in capabilities).
   * We specify the current directory as the project directory with `--project "$(pwd)"`, such 
     that Serena is configured to work on the current project from the get-go, following 
@@ -111,7 +111,21 @@ Add the `serena` MCP server configuration, using a [run command](020_running.md)
 If you are using paths containing backslashes for paths on Windows
 (note that you can also just use forward slashes), be sure to escape them correctly (`\\`).
 
-That's it! Save the config and then restart Claude Desktop. You are ready for activating your first project.
+:::{note}
+Some language servers may require additional environment variables to be set (e.g. F# on macOS with Homebrew),
+which you may need to explicitly add to the MCP server configuration.
+Note that the spawned processes will not inherit environment variables that are only configured in your shell 
+profile (e.g. `.bashrc`, `.zshrc`, etc.); they would need to be set system-wide instead.
+An easy fix is to add them explicitly to the MCP server entry: Simply add an `env` key to the `serena` object, e.g.
+
+```
+"env": {
+    "DOTNET_ROOT": "/opt/homebrew/Cellar/dotnet/9.0.8/libexec"
+}
+```
+:::
+
+Once you have created the new MCP server entry, save the config and then restart Claude Desktop. 
 
 :::{attention}
 Be sure to fully quit the Claude Desktop application via File / Exit, as regularly closing the application will just minimize it.
@@ -151,7 +165,7 @@ by writing your own context, modes or prompts to adjust it to the client's respe
 Most of the popular existing coding assistants (e.g. IDE extensions) and AI-enabled IDEs themselves support connections
 to MCP Servers. Serena generally boosts performance by providing efficient tools for symbolic operations.
 
-We generally **recommend to use the `ide-assistant` context** for these integrations by adding the arguments `--context ide-assistant` 
+We generally **recommend to use the `ide` context** for these integrations by adding the arguments `--context ide` 
 in order to reduce tool duplication.
 
 ### Local GUIs and Agent Frameworks

docs/02-usage/050_configuration.md

@@ -105,4 +105,31 @@ You can manage modes using the `mode` command,
     <serena> mode edit <mode-name>
     <serena> mode delete <mode-name>
 
-where `<serena>` is [your way of running Serena](020_running).
+where `<serena>` is [your way of running Serena](020_running).
+
+## Advanced Configuration
+
+For advanced users, Serena's configuration can be further customized.
+
+### Serena Data Directory
+
+The Serena user data directory (where configuration, language server files, logs, etc. are stored) defaults to `~/.serena`.
+You can change this location by setting the `SERENA_HOME` environment variable to your desired path.
+
+### Custom Prompts
+
+All of Serena's prompts can be fully customized.
+We define prompt as jinja templates in yaml files, and you can inspect our default prompts [here](https://github.com/oraios/serena/tree/main/src/serena/resources/config/prompt_templates).
+
+To override a prompt, simply add a .yml file to the `prompt_templates` folder in your Serena data directory
+which defines the prompt with the same name as the default prompt you want to override.
+For example, to override the `system_prompt`, you could create a file `~/.serena/prompt_templates/system_prompt.yml` (assuming default Serena data folder location) 
+with content like:
+
+```yaml
+prompts:
+  system_prompt: |
+    Whatever you want ...
+```
+
+It is advisable to use the default prompt as a starting point and modify it to suit your needs.

pyproject.toml

@@ -275,6 +275,7 @@ markers = [
   "kotlin: language server running for kotlin",
   "rust: language server running for Rust",
   "typescript: language server running for TypeScript",
+  "vue: language server running for Vue (uses TypeScript LSP)",
   "php: language server running for PHP",
   "perl: language server running for Perl",
   "csharp: language server running for C#",
@@ -293,6 +294,7 @@ markers = [
   "erlang: language server running for Erlang",
   "scala: language server running for Scala",
   "al: language server running for AL (Microsoft Dynamics 365 Business Central)",
+  "fsharp: language server running for F#",
   "rego: language server running for Rego",
   "markdown: language server running for Markdown",
   "julia: Julia language server tests",
@@ -306,4 +308,4 @@ markers = [
 skip = '.git*,*.svg,*.lock,*.min.*'
 check-hidden = true
 # ignore-regex = ''
-# ignore-words-list = ''
+ignore-words-list = 'paket'

src/serena/cli.py

@@ -21,14 +21,10 @@ 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
@@ -270,7 +266,7 @@ class ModeCommands(AutoRegisteringGroup):
         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")
+        dest = os.path.join(SerenaPaths().user_modes_dir, f"{mode_name}.yml")
         src = (
             os.path.join(SERENAS_OWN_MODE_YAMLS_DIR, f"{from_internal}.yml")
             if from_internal
@@ -289,7 +285,7 @@ class ModeCommands(AutoRegisteringGroup):
     @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")
+        path = os.path.join(SerenaPaths().user_modes_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(
@@ -305,7 +301,7 @@ class ModeCommands(AutoRegisteringGroup):
     @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")
+        path = os.path.join(SerenaPaths().user_modes_dir, f"{mode_name}.yml")
         if not os.path.exists(path):
             click.echo(f"Custom mode '{mode_name}' not found.")
             return
@@ -347,7 +343,7 @@ class ContextCommands(AutoRegisteringGroup):
         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")
+        dest = os.path.join(SerenaPaths().user_contexts_dir, f"{ctx_name}.yml")
         src = (
             os.path.join(SERENAS_OWN_CONTEXT_YAMLS_DIR, f"{from_internal}.yml")
             if from_internal
@@ -366,7 +362,7 @@ class ContextCommands(AutoRegisteringGroup):
     @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")
+        path = os.path.join(SerenaPaths().user_contexts_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(
@@ -382,7 +378,7 @@ class ContextCommands(AutoRegisteringGroup):
     @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")
+        path = os.path.join(SerenaPaths().user_contexts_dir, f"{context_name}.yml")
         if not os.path.exists(path):
             click.echo(f"Custom context '{context_name}' not found.")
             return
@@ -401,10 +397,9 @@ class SerenaConfigCommands(AutoRegisteringGroup):
         "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)
+        serena_config = SerenaConfig.from_config_file()
+        assert serena_config.config_file_path is not None
+        _open_in_editor(serena_config.config_file_path)
 
 
 class ProjectCommands(AutoRegisteringGroup):
@@ -811,8 +806,9 @@ class PromptCommands(AutoRegisteringGroup):
 
     @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)
+        templates_dir = SerenaPaths().user_prompt_templates_dir
+        os.makedirs(templates_dir, exist_ok=True)
+        return os.path.join(templates_dir, prompt_yaml_name)
 
     @staticmethod
     @click.command("list", help="Lists yamls that are used for defining prompts.")
@@ -863,9 +859,10 @@ class PromptCommands(AutoRegisteringGroup):
     @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)
+        user_templates_dir = SerenaPaths().user_prompt_templates_dir
+        os.makedirs(user_templates_dir, 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"))
+        override_files = glob.glob(os.path.join(user_templates_dir, "*.yml"))
         for file_path in override_files:
             if os.path.basename(file_path) in serena_prompt_yaml_names:
                 click.echo(file_path)

src/serena/code_editor.py

@@ -267,15 +267,7 @@ class LanguageServerCodeEditor(CodeEditor[LanguageServerSymbol]):
         return 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]
+        return self._symbol_retriever.find_unique(name_path, within_relative_path=relative_file_path)
 
     def _apply_workspace_edit(self, workspace_edit: ls_types.WorkspaceEdit) -> list[str]:
         """

src/serena/config/context_mode.py

@@ -11,7 +11,7 @@ import yaml
 from sensai.util import logging
 from sensai.util.string import ToStringMixin
 
-from serena.config.serena_config import ToolInclusionDefinition
+from serena.config.serena_config import SerenaPaths, ToolInclusionDefinition
 from serena.constants import (
     DEFAULT_CONTEXT,
     DEFAULT_MODES,
@@ -19,8 +19,6 @@ from serena.constants import (
     SERENA_FILE_ENCODING,
     SERENAS_OWN_CONTEXT_YAMLS_DIR,
     SERENAS_OWN_MODE_YAMLS_DIR,
-    USER_CONTEXT_YAMLS_DIR,
-    USER_MODE_YAMLS_DIR,
 )
 
 if TYPE_CHECKING:
@@ -65,14 +63,14 @@ class SerenaAgentMode(ToolInclusionDefinition, ToStringMixin):
     def get_path(cls, name: str) -> str:
         """Get the path to the YAML file for a mode."""
         fname = f"{name}.yml"
-        custom_mode_path = os.path.join(USER_MODE_YAMLS_DIR, fname)
+        custom_mode_path = os.path.join(SerenaPaths().user_modes_dir, fname)
         if os.path.exists(custom_mode_path):
             return custom_mode_path
 
         own_yaml_path = os.path.join(SERENAS_OWN_MODE_YAMLS_DIR, fname)
         if not os.path.exists(own_yaml_path):
             raise FileNotFoundError(
-                f"Mode {name} not found in {USER_MODE_YAMLS_DIR} or in {SERENAS_OWN_MODE_YAMLS_DIR}."
+                f"Mode {name} not found in {SerenaPaths().user_modes_dir} or in {SERENAS_OWN_MODE_YAMLS_DIR}."
                 f"Available modes:\n{cls.list_registered_mode_names()}"
             )
         return own_yaml_path
@@ -102,7 +100,7 @@ class SerenaAgentMode(ToolInclusionDefinition, ToStringMixin):
     @classmethod
     def list_custom_mode_names(cls) -> list[str]:
         """Names of all custom modes defined by the user."""
-        return [f.stem for f in Path(USER_MODE_YAMLS_DIR).glob("*.yml")]
+        return [f.stem for f in Path(SerenaPaths().user_modes_dir).glob("*.yml")]
 
     @classmethod
     def load_default_modes(cls) -> list[Self]:
@@ -166,14 +164,14 @@ class SerenaAgentContext(ToolInclusionDefinition, ToStringMixin):
     def get_path(cls, name: str) -> str:
         """Get the path to the YAML file for a context."""
         fname = f"{name}.yml"
-        custom_context_path = os.path.join(USER_CONTEXT_YAMLS_DIR, fname)
+        custom_context_path = os.path.join(SerenaPaths().user_contexts_dir, fname)
         if os.path.exists(custom_context_path):
             return custom_context_path
 
         own_yaml_path = os.path.join(SERENAS_OWN_CONTEXT_YAMLS_DIR, fname)
         if not os.path.exists(own_yaml_path):
             raise FileNotFoundError(
-                f"Context {name} not found in {USER_CONTEXT_YAMLS_DIR} or in {SERENAS_OWN_CONTEXT_YAMLS_DIR}."
+                f"Context {name} not found in {SerenaPaths().user_contexts_dir} or in {SERENAS_OWN_CONTEXT_YAMLS_DIR}."
                 f"Available contexts:\n{cls.list_registered_context_names()}"
             )
         return own_yaml_path
@@ -211,7 +209,7 @@ class SerenaAgentContext(ToolInclusionDefinition, ToStringMixin):
     @classmethod
     def list_custom_context_names(cls) -> list[str]:
         """Names of all custom contexts defined by the user."""
-        return [f.stem for f in Path(USER_CONTEXT_YAMLS_DIR).glob("*.yml")]
+        return [f.stem for f in Path(SerenaPaths().user_contexts_dir).glob("*.yml")]
 
     @classmethod
     def load_default(cls) -> Self:

src/serena/config/serena_config.py

@@ -25,7 +25,6 @@ from serena.constants import (
     REPO_ROOT,
     SERENA_CONFIG_TEMPLATE_FILE,
     SERENA_FILE_ENCODING,
-    SERENA_MANAGED_DIR_IN_HOME,
     SERENA_MANAGED_DIR_NAME,
 )
 from serena.util.general import get_dataclass_default, load_yaml, save_yaml
@@ -53,9 +52,32 @@ class SerenaPaths:
     """
 
     def __init__(self) -> None:
-        self.user_config_dir: str = SERENA_MANAGED_DIR_IN_HOME
+        home_dir = os.getenv("SERENA_HOME")
+        if home_dir is None or home_dir.strip() == "":
+            home_dir = str(Path.home() / SERENA_MANAGED_DIR_NAME)
+        else:
+            home_dir = home_dir.strip()
+        self.serena_user_home_dir: str = home_dir
         """
-        the path to the user's Serena configuration directory, which is typically ~/.serena
+        the path to the Serena home directory, where the user's configuration/data is stored.
+        This is ~/.serena by default, but it can be overridden via the SERENA_HOME environment variable.
+        """
+        self.user_prompt_templates_dir: str = os.path.join(self.serena_user_home_dir, "prompt_templates")
+        """
+        directory containing prompt templates defined by the user.
+        Prompts defined by the user take precedence over Serena's built-in prompt templates.
+        """
+        self.user_contexts_dir: str = os.path.join(self.serena_user_home_dir, "contexts")
+        """
+        directory containing contexts defined by the user. 
+        If a name of a context matches a name of a context in SERENAS_OWN_CONTEXT_YAMLS_DIR, 
+        the user context will override the default context definition.
+        """
+        self.user_modes_dir: str = os.path.join(self.serena_user_home_dir, "modes")
+        """
+        directory containing modes defined by the user.
+        If a name of a mode matches a name of a mode in SERENAS_OWN_MODES_YAML_DIR,
+        the user mode will override the default mode definition.
         """
 
     def get_next_log_file_path(self, prefix: str) -> str:
@@ -63,7 +85,7 @@ class SerenaPaths:
         :param prefix: the filename prefix indicating the type of the log file
         :return: the full path to the log file to use
         """
-        log_dir = os.path.join(self.user_config_dir, "logs", datetime.now().strftime("%Y-%m-%d"))
+        log_dir = os.path.join(self.serena_user_home_dir, "logs", datetime.now().strftime("%Y-%m-%d"))
         os.makedirs(log_dir, exist_ok=True)
         return os.path.join(log_dir, prefix + "_" + datetime_tag() + ".txt")
 
@@ -152,15 +174,18 @@ class ProjectConfig(ToolInclusionDefinition, ToStringMixin):
                         f"Read the documentation for more information."
                     )
                 # sort languages by number of files found
-                languages_and_percentages = sorted(language_composition.items(), key=lambda item: item[1], reverse=True)
+                languages_and_percentages = sorted(
+                    language_composition.items(), key=lambda item: (item[1], item[0].get_priority()), reverse=True
+                )
                 # find the language with the highest percentage and enable it
                 top_language_pair = languages_and_percentages[0]
                 other_language_pairs = languages_and_percentages[1:]
-                languages_to_use = [top_language_pair[0]]
+                languages_to_use: list[str] = [top_language_pair[0].value]
                 # if in interactive mode, ask the user which other languages to enable
                 if len(other_language_pairs) > 0 and interactive:
                     print(
-                        "Detected and enabled main language '%s' (%.2f%% of source files)." % (top_language_pair[0], top_language_pair[1])
+                        "Detected and enabled main language '%s' (%.2f%% of source files)."
+                        % (top_language_pair[0].value, top_language_pair[1])
                     )
                     print(f"Additionally detected {len(other_language_pairs)} other language(s).\n")
                     print("Note: Enable only languages you need symbolic retrieval/editing capabilities for.")
@@ -168,9 +193,9 @@ class ProjectConfig(ToolInclusionDefinition, ToStringMixin):
                     print("      system-level installations/configuration (see Serena documentation).")
                     print("\nWhich additional languages do you want to enable?")
                     for lang, perc in other_language_pairs:
-                        enable = ask_yes_no("Enable %s (%.2f%% of source files)?" % (lang, perc), default=False)
+                        enable = ask_yes_no("Enable %s (%.2f%% of source files)?" % (lang.value, perc), default=False)
                         if enable:
-                            languages_to_use.append(lang)
+                            languages_to_use.append(lang.value)
                     print()
             else:
                 languages_to_use = [lang.value for lang in languages]
@@ -383,7 +408,7 @@ class SerenaConfig(ToolInclusionDefinition, ToStringMixin):
         return ["config_file_path"]
 
     @classmethod
-    def generate_config_file(cls, config_file_path: str) -> None:
+    def _generate_config_file(cls, config_file_path: str) -> None:
         """
         Generates a Serena configuration file at the specified path from the template file.
 
@@ -401,7 +426,7 @@ class SerenaConfig(ToolInclusionDefinition, ToStringMixin):
         if is_running_in_docker():
             return os.path.join(REPO_ROOT, cls.CONFIG_FILE_DOCKER)
         else:
-            config_path = os.path.join(SERENA_MANAGED_DIR_IN_HOME, cls.CONFIG_FILE)
+            config_path = os.path.join(SerenaPaths().serena_user_home_dir, cls.CONFIG_FILE)
 
             # if the config file does not exist, check if we can migrate it from the old location
             if not os.path.exists(config_path):
@@ -425,7 +450,7 @@ class SerenaConfig(ToolInclusionDefinition, ToStringMixin):
             if not generate_if_missing:
                 raise FileNotFoundError(f"Serena configuration file not found: {config_file_path}")
             log.info(f"Serena configuration file not found at {config_file_path}, autogenerating...")
-            cls.generate_config_file(config_file_path)
+            cls._generate_config_file(config_file_path)
 
         # load the configuration
         log.info(f"Loading Serena configuration from {config_file_path}")

src/serena/constants.py

@@ -4,22 +4,14 @@ _repo_root_path = Path(__file__).parent.parent.parent.resolve()
 _serena_pkg_path = Path(__file__).parent.resolve()
 
 SERENA_MANAGED_DIR_NAME = ".serena"
-_serena_in_home_managed_dir = Path.home() / ".serena"
-
-SERENA_MANAGED_DIR_IN_HOME = str(_serena_in_home_managed_dir)
 
 # TODO: Path-related constants should be moved to SerenaPaths; don't add further constants here.
 REPO_ROOT = str(_repo_root_path)
 PROMPT_TEMPLATES_DIR_INTERNAL = str(_serena_pkg_path / "resources" / "config" / "prompt_templates")
-PROMPT_TEMPLATES_DIR_IN_USER_HOME = str(_serena_in_home_managed_dir / "prompt_templates")
 SERENAS_OWN_CONTEXT_YAMLS_DIR = str(_serena_pkg_path / "resources" / "config" / "contexts")
 """The contexts that are shipped with the Serena package, i.e. the default contexts."""
-USER_CONTEXT_YAMLS_DIR = str(_serena_in_home_managed_dir / "contexts")
-"""Contexts defined by the user. If a name of a context matches a name of a context in SERENAS_OWN_CONTEXT_YAMLS_DIR, the user context will override the default one."""
 SERENAS_OWN_MODE_YAMLS_DIR = str(_serena_pkg_path / "resources" / "config" / "modes")
 """The modes that are shipped with the Serena package, i.e. the default modes."""
-USER_MODE_YAMLS_DIR = str(_serena_in_home_managed_dir / "modes")
-"""Modes defined by the user. If a name of a mode matches a name of a mode in SERENAS_OWN_MODE_YAMLS_DIR, the user mode will override the default one."""
 INTERNAL_MODE_YAMLS_DIR = str(_serena_pkg_path / "resources" / "config" / "internal_modes")
 """Internal modes, never overridden by user modes."""
 SERENA_DASHBOARD_DIR = str(_serena_pkg_path / "resources" / "dashboard")

src/serena/ls_manager.py

@@ -4,7 +4,8 @@ from collections.abc import Iterator
 
 from sensai.util.logging import LogTime
 
-from serena.constants import SERENA_MANAGED_DIR_IN_HOME, SERENA_MANAGED_DIR_NAME
+from serena.config.serena_config import SerenaPaths
+from serena.constants import SERENA_MANAGED_DIR_NAME
 from solidlsp import SolidLanguageServer
 from solidlsp.ls_config import Language, LanguageServerConfig
 from solidlsp.settings import SolidLSPSettings
@@ -43,7 +44,7 @@ class LanguageServerFactory:
             self.project_root,
             timeout=self.ls_timeout,
             solidlsp_settings=SolidLSPSettings(
-                solidlsp_dir=SERENA_MANAGED_DIR_IN_HOME,
+                solidlsp_dir=SerenaPaths().serena_user_home_dir,
                 project_data_relative_path=SERENA_MANAGED_DIR_NAME,
                 ls_specific_settings=self.ls_specific_settings or {},
             ),

src/serena/mcp.py

@@ -14,6 +14,7 @@ import docstring_parser
 from mcp.server.fastmcp import server
 from mcp.server.fastmcp.server import FastMCP, Settings
 from mcp.server.fastmcp.tools.base import Tool as MCPTool
+from mcp.types import ToolAnnotations
 from pydantic_settings import SettingsConfigDict
 from sensai.util import logging
 
@@ -213,6 +214,8 @@ class SerenaMCPFactory:
         def execute_fn(**kwargs) -> str:  # type: ignore
             return tool.apply_ex(log_call=True, catch_exceptions=True, **kwargs)
 
+        annotations = ToolAnnotations(readOnlyHint=not tool.can_edit())
+
         return MCPTool(
             fn=execute_fn,
             name=func_name,
@@ -221,7 +224,7 @@ class SerenaMCPFactory:
             fn_metadata=func_arg_metadata,
             is_async=is_async,
             context_kwarg=None,
-            annotations=None,
+            annotations=annotations,
             title=None,
         )
 

src/serena/prompt_factory.py

@@ -1,6 +1,7 @@
 import os
 
-from serena.constants import PROMPT_TEMPLATES_DIR_IN_USER_HOME, PROMPT_TEMPLATES_DIR_INTERNAL
+from serena.config.serena_config import SerenaPaths
+from serena.constants import PROMPT_TEMPLATES_DIR_INTERNAL
 from serena.generated.generated_prompt_factory import PromptFactory
 
 
@@ -10,5 +11,6 @@ class SerenaPromptFactory(PromptFactory):
     """
 
     def __init__(self) -> None:
-        os.makedirs(PROMPT_TEMPLATES_DIR_IN_USER_HOME, exist_ok=True)
-        super().__init__(prompts_dir=[PROMPT_TEMPLATES_DIR_IN_USER_HOME, PROMPT_TEMPLATES_DIR_INTERNAL])
+        user_templates_dir = SerenaPaths().user_prompt_templates_dir
+        os.makedirs(user_templates_dir, exist_ok=True)
+        super().__init__(prompts_dir=[user_templates_dir, PROMPT_TEMPLATES_DIR_INTERNAL])

src/serena/symbol.py

@@ -2,7 +2,7 @@ import json
 import logging
 import os
 from abc import ABC, abstractmethod
-from collections.abc import Iterator, Sequence
+from collections.abc import Callable, Iterator, Sequence
 from dataclasses import asdict, dataclass
 from typing import TYPE_CHECKING, Any, NotRequired, Self, TypedDict, Union
 
@@ -115,16 +115,31 @@ class Symbol(ToStringMixin, ABC):
 
 
 class NamePathMatcher(ToStringMixin):
-    def __init__(self, name_path_expr: str, substring_matching: bool) -> None:
+    """
+    Matches name paths of symbols against search patterns.
+
+    A name path is a path in the symbol tree *within a source file*.
+    For example, the method `my_method` defined in class `MyClass` would have the name path `MyClass/my_method`.
+    If a symbol is overloaded (e.g., in Java), a 0-based index is appended (e.g. "MyClass/my_method[0]") to
+    uniquely identify it.
+
+    A matching pattern can be:
+     * a simple name (e.g. "method"), which will match any symbol with that name
+     * a relative path like "class/method", which will match any symbol with that name path suffix
+     * an absolute name path "/class/method" (absolute name path), which requires an exact match of the full name path within the source file.
+    Append an index `[i]` to match a specific overload only, e.g. "MyClass/my_method[1]".
+    """
+
+    def __init__(self, name_path_pattern: str, substring_matching: bool) -> None:
         """
-        :param name_path_expr: the name path expression to match against
+        :param name_path_pattern: the name path expression to match against
         :param substring_matching: whether to use substring matching for the last segment
         """
-        assert name_path_expr, "name_path must not be empty"
-        self._expr = name_path_expr
+        assert name_path_pattern, "name_path must not be empty"
+        self._expr = name_path_pattern
         self._substring_matching = substring_matching
-        self._is_absolute_pattern = name_path_expr.startswith(NAME_PATH_SEP)
-        self._pattern_parts = name_path_expr.lstrip(NAME_PATH_SEP).rstrip(NAME_PATH_SEP).split(NAME_PATH_SEP)
+        self._is_absolute_pattern = name_path_pattern.startswith(NAME_PATH_SEP)
+        self._pattern_parts = name_path_pattern.lstrip(NAME_PATH_SEP).rstrip(NAME_PATH_SEP).split(NAME_PATH_SEP)
 
         # extract overload index "[idx]" if present at end of last part
         self._overload_idx: int | None = None
@@ -194,6 +209,13 @@ class LanguageServerSymbol(Symbol, ToStringMixin):
     def symbol_kind(self) -> SymbolKind:
         return self.symbol_root["kind"]
 
+    def is_low_level(self) -> bool:
+        """
+        :return: whether the symbol is a low-level symbol (variable, constant, etc.), which typically represents data
+            rather than structure and therefore is not relevant in a high-level overview of the code.
+        """
+        return self.symbol_kind >= SymbolKind.Variable.value
+
     @property
     def overload_idx(self) -> int | None:
         return self.symbol_root.get("overload_idx")
@@ -323,34 +345,15 @@ class LanguageServerSymbol(Symbol, ToStringMixin):
 
     def find(
         self,
-        name_path: str,
+        name_path_pattern: str,
         substring_matching: bool = False,
         include_kinds: Sequence[SymbolKind] | None = None,
         exclude_kinds: Sequence[SymbolKind] | None = None,
     ) -> list[Self]:
         """
-        Find all symbols within the symbol's subtree that match the given `name_path`.
-        The matching behavior is determined by the structure of `name_path`, which can
-        either be a simple name (e.g. "method") or a name path like "class/method" (relative name path)
-        or "/class/method" (absolute name path).
+        Find all symbols within the symbol's subtree that match the given name path pattern.
 
-        Key aspects of the name path matching behavior:
-        - Trailing slashes in `name_path` play no role and are ignored.
-        - The name of the retrieved symbols will match (either exactly or as a substring)
-          the last segment of `name_path`, while other segments will restrict the search to symbols that
-          have a desired sequence of ancestors.
-        - If there is no starting or intermediate slash in `name_path`, there is no
-          restriction on the ancestor symbols. For example, passing `method` will match
-          against symbols with name paths like `method`, `class/method`, `class/nested_class/method`, etc.
-        - If `name_path` contains a `/` but doesn't start with a `/`, the matching is restricted to symbols
-          with the same ancestors as the last segment of `name_path`. For example, passing `class/method` will match against
-          `class/method` as well as `nested_class/class/method` but not `method`.
-        - If `name_path` starts with a `/`, it will be treated as an absolute name path pattern, meaning
-          that the first segment of it must match the first segment of the symbol's name path.
-          For example, passing `/class` will match only against top-level symbols like `class` but not against `nested_class/class`.
-          Passing `/class/method` will match against `class/method` but not `nested_class/class/method` or `method`.
-
-        :param name_path: the name path expression to match against
+        :param name_path_pattern: the name path pattern to match against (see class :class:`NamePathMatcher` for details)
         :param substring_matching: whether to use substring matching (as opposed to exact matching)
             of the last segment of `name_path` against the symbol name.
         :param include_kinds: an optional sequence of ints representing the LSP symbol kind.
@@ -358,7 +361,7 @@ class LanguageServerSymbol(Symbol, ToStringMixin):
         :param exclude_kinds: If provided, symbols of the given kinds will be excluded from the result.
         """
         result = []
-        name_path_matcher = NamePathMatcher(name_path, substring_matching)
+        name_path_matcher = NamePathMatcher(name_path_pattern, substring_matching)
 
         def should_include(s: "LanguageServerSymbol") -> bool:
             if include_kinds is not None and s.symbol_kind not in include_kinds:
@@ -384,13 +387,14 @@ class LanguageServerSymbol(Symbol, ToStringMixin):
         include_body: bool = False,
         include_children_body: bool = False,
         include_relative_path: bool = True,
+        child_inclusion_predicate: Callable[[Self], bool] | None = None,
     ) -> dict[str, Any]:
         """
         Converts the symbol to a dictionary.
 
         :param kind: whether to include the kind of the symbol
         :param location: whether to include the location of the symbol
-        :param depth: the depth of the symbol
+        :param depth: the depth up to which to include child symbols (0 = do not include children)
         :param include_body: whether to include the body of the top-level symbol.
         :param include_children_body: whether to also include the body of the children.
             Note that the body of the children is part of the body of the parent symbol,
@@ -398,6 +402,8 @@ class LanguageServerSymbol(Symbol, ToStringMixin):
             and pass the children without passing the parent body to the LM.
         :param include_relative_path: whether to include the relative path of the symbol in the location
             entry. Relative paths of the symbol's children are always excluded.
+        :param child_inclusion_predicate: an optional predicate that decides whether a child symbol
+            should be included.
         :return: a dictionary representation of the symbol
         """
         result: dict[str, Any] = {"name": self.name, "name_path": self.get_name_path()}
@@ -415,14 +421,20 @@ class LanguageServerSymbol(Symbol, ToStringMixin):
                 log.warning("Requested body for symbol, but it is not present. The symbol might have been loaded with include_body=False.")
             result["body"] = self.body
 
-        def add_children(s: Self) -> list[dict[str, Any]]:
+        if child_inclusion_predicate is None:
+            child_inclusion_predicate = lambda s: True
+
+        def included_children(s: Self) -> list[dict[str, Any]]:
             children = []
             for c in s.iter_children():
+                if not child_inclusion_predicate(c):
+                    continue
                 children.append(
                     c.to_dict(
                         kind=kind,
                         location=location,
                         depth=depth - 1,
+                        child_inclusion_predicate=child_inclusion_predicate,
                         include_body=include_children_body,
                         include_children_body=include_children_body,
                         # all children have the same relative path as the parent
@@ -432,7 +444,9 @@ class LanguageServerSymbol(Symbol, ToStringMixin):
             return children
 
         if depth > 0:
-            result["children"] = add_children(self)
+            children = included_children(self)
+            if len(children) > 0:
+                result["children"] = included_children(self)
 
         return result
 
@@ -488,18 +502,17 @@ class LanguageServerSymbolRetriever:
     def get_language_server(self, relative_path: str) -> SolidLanguageServer:
         return self._ls_manager.get_language_server(relative_path)
 
-    def find_by_name(
+    def find(
         self,
-        name_path: str,
+        name_path_pattern: str,
         include_kinds: Sequence[SymbolKind] | None = None,
         exclude_kinds: Sequence[SymbolKind] | None = None,
         substring_matching: bool = False,
         within_relative_path: str | None = None,
     ) -> list[LanguageServerSymbol]:
         """
-        Find all symbols that match the given name. See docstring of `Symbol.find` for more details.
-        The only parameter not mentioned there is `within_relative_path`, which can be used to restrict the search
-        to symbols within a specific file or directory.
+        Finds all symbols that match the given name path pattern (see class :class:`NamePathMatcher` for details),
+        optionally limited to a specific file and filtered by kind.
         """
         symbols: list[LanguageServerSymbol] = []
         for lang_server in self._ls_manager.iter_language_servers():
@@ -507,11 +520,44 @@ class LanguageServerSymbolRetriever:
             for root in symbol_roots:
                 symbols.extend(
                     LanguageServerSymbol(root).find(
-                        name_path, include_kinds=include_kinds, exclude_kinds=exclude_kinds, substring_matching=substring_matching
+                        name_path_pattern, include_kinds=include_kinds, exclude_kinds=exclude_kinds, substring_matching=substring_matching
                     )
                 )
         return symbols
 
+    def find_unique(
+        self,
+        name_path_pattern: str,
+        include_kinds: Sequence[SymbolKind] | None = None,
+        exclude_kinds: Sequence[SymbolKind] | None = None,
+        substring_matching: bool = False,
+        within_relative_path: str | None = None,
+    ) -> LanguageServerSymbol:
+        symbol_candidates = self.find(
+            name_path_pattern,
+            include_kinds=include_kinds,
+            exclude_kinds=exclude_kinds,
+            substring_matching=substring_matching,
+            within_relative_path=within_relative_path,
+        )
+        if len(symbol_candidates) == 1:
+            return symbol_candidates[0]
+        elif len(symbol_candidates) == 0:
+            raise ValueError(f"No symbol matching '{name_path_pattern}' found")
+        else:
+            # There are multiple candidates.
+            # If only one of the candidates has the given pattern as its exact name path, return that one
+            exact_matches = [s for s in symbol_candidates if s.get_name_path() == name_path_pattern]
+            if len(exact_matches) == 1:
+                return exact_matches[0]
+            # otherwise, raise an error
+            include_rel_path = within_relative_path is not None
+            raise ValueError(
+                f"Found multiple {len(symbol_candidates)} symbols matching '{name_path_pattern}'. "
+                "They are: \n"
+                + json.dumps([s.to_dict(kind=True, include_relative_path=include_rel_path) for s in symbol_candidates], indent=2)
+            )
+
     def find_by_location(self, location: LanguageServerSymbolLocation) -> LanguageServerSymbol | None:
         if location.relative_path is None:
             return None
@@ -532,28 +578,17 @@ class LanguageServerSymbolRetriever:
         exclude_kinds: Sequence[SymbolKind] | None = None,
     ) -> list[ReferenceInLanguageServerSymbol]:
         """
-        Find all symbols that reference the symbol with the given name.
-        If multiple symbols fit the name (e.g. for variables that are overwritten), will use the first one.
+        Find all symbols that reference the specified symbol, which is assumed to be unique.
 
-        :param name_path: the name path of the symbol to find
+        :param name_path: the name path of the symbol to find. (While this can be a matching pattern, it should
+            usually be the full path to ensure uniqueness.)
         :param relative_file_path: the relative path of the file in which the referenced symbol is defined.
         :param include_body: whether to include the body of all symbols in the result.
             Not recommended, as the referencing symbols will often be files, and thus the bodies will be very long.
         :param include_kinds: which kinds of symbols to include in the result.
         :param exclude_kinds: which kinds of symbols to exclude from the result.
         """
-        symbol_candidates = self.find_by_name(name_path, substring_matching=False, within_relative_path=relative_file_path)
-        if len(symbol_candidates) == 0:
-            log.warning(f"No symbol with name {name_path} found in file {relative_file_path}")
-            return []
-        if len(symbol_candidates) > 1:
-            log.error(
-                f"Found {len(symbol_candidates)} symbols with name {name_path} in file {relative_file_path}."
-                f"May be an overwritten variable, in which case you can ignore this error. Proceeding with the first one. "
-                f"Found symbols for {name_path=} in {relative_file_path=}: \n"
-                f"{json.dumps([s.location.to_dict() for s in symbol_candidates], indent=2)}"
-            )
-        symbol = symbol_candidates[0]
+        symbol = self.find_unique(name_path, substring_matching=False, within_relative_path=relative_file_path)
         return self.find_referencing_symbols_by_location(
             symbol.location, include_body=include_body, include_kinds=include_kinds, exclude_kinds=exclude_kinds
         )
@@ -604,23 +639,35 @@ class LanguageServerSymbolRetriever:
 
         return [ReferenceInLanguageServerSymbol.from_lsp_reference(r) for r in references]
 
-    @dataclass
-    class SymbolOverviewElement:
-        name_path: str
-        kind: int
-
-        @classmethod
-        def from_symbol(cls, symbol: LanguageServerSymbol) -> Self:
-            return cls(name_path=symbol.get_name_path(), kind=int(symbol.symbol_kind))
-
-    def get_symbol_overview(self, relative_path: str) -> dict[str, list[SymbolOverviewElement]]:
+    def get_symbol_overview(self, relative_path: str, depth: int = 0) -> dict[str, list[dict]]:
+        """
+        :param relative_path: the path of the file or directory for which to get the symbol overview
+        :param depth: the depth up to which to include child symbols (0 = only top-level symbols)
+        :return: a mapping from file paths to lists of symbol dictionaries.
+            For the case where a file is passed, the mapping will contain a single entry.
+        """
         lang_server = self.get_language_server(relative_path)
         path_to_unified_symbols = lang_server.request_overview(relative_path)
+
+        def child_inclusion_predicate(s: LanguageServerSymbol) -> bool:
+            return not s.is_low_level()
+
         result = {}
         for file_path, unified_symbols in path_to_unified_symbols.items():
-            # TODO: maybe include not just top-level symbols? We could filter by kind to exclude variables
-            #  The language server methods would need to be adjusted for this.
-            result[file_path] = [self.SymbolOverviewElement.from_symbol(LanguageServerSymbol(s)) for s in unified_symbols]
+            symbols_in_file = []
+            for us in unified_symbols:
+                symbol = LanguageServerSymbol(us)
+                symbols_in_file.append(
+                    symbol.to_dict(
+                        depth=depth,
+                        kind=True,
+                        include_relative_path=False,
+                        location=False,
+                        child_inclusion_predicate=child_inclusion_predicate,
+                    )
+                )
+            result[file_path] = symbols_in_file
+
         return result
 
 

src/serena/tools/jetbrains_plugin_client.py

@@ -133,7 +133,13 @@ class JetBrainsPluginClient(ToStringMixin):
         return response["project_root"]
 
     def find_symbol(
-        self, name_path: str, relative_path: str | None = None, include_body: bool = False, depth: int = 0, include_location: bool = False
+        self,
+        name_path: str,
+        relative_path: str | None = None,
+        include_body: bool = False,
+        depth: int = 0,
+        include_location: bool = False,
+        search_deps: bool = False,
     ) -> dict[str, Any]:
         """
         Finds symbols by name.
@@ -142,6 +148,8 @@ class JetBrainsPluginClient(ToStringMixin):
         :param relative_path: the relative path to which to restrict the search
         :param include_body: whether to include symbol body content
         :param depth: depth of children to include (0 = no children)
+        :param include_location: whether to include symbol location information
+        :param search_deps: whether to also search in dependencies
 
         :return: Dictionary containing 'symbols' list with matching symbols
         """
@@ -151,6 +159,7 @@ class JetBrainsPluginClient(ToStringMixin):
             "includeBody": include_body,
             "depth": depth,
             "includeLocation": include_location,
+            "searchDeps": search_deps,
         }
         return self._make_request("POST", "/findSymbol", request_data)
 

src/serena/tools/jetbrains_tools.py

@@ -13,6 +13,7 @@ class JetBrainsFindSymbolTool(Tool, ToolMarkerSymbolicRead, ToolMarkerOptional):
         depth: int = 0,
         relative_path: str | None = None,
         include_body: bool = False,
+        search_deps: bool = False,
         max_answer_chars: int = -1,
     ) -> str:
         """
@@ -42,6 +43,7 @@ class JetBrainsFindSymbolTool(Tool, ToolMarkerSymbolicRead, ToolMarkerOptional):
             If you have some knowledge about the codebase, you should use this parameter, as it will significantly
             speed up the search as well as reduce the number of results.
         :param include_body: If True, include the symbol's source code. Use judiciously.
+        :param search_deps: If True, also search in project dependencies (e.g., libraries).
         :param max_answer_chars: max characters for the JSON result. If exceeded, no content is returned.
             -1 means the default value from the config will be used.
         :return: JSON string: a list of symbols (with locations) matching the name.
@@ -52,6 +54,7 @@ class JetBrainsFindSymbolTool(Tool, ToolMarkerSymbolicRead, ToolMarkerOptional):
                 relative_path=relative_path,
                 depth=depth,
                 include_body=include_body,
+                search_deps=search_deps,
             )
             result = self._to_json(response_dict)
         return self._limit_length(result, max_answer_chars)

src/serena/tools/symbol_tools.py

@@ -2,7 +2,6 @@
 Language server-related tools
 """
 
-import dataclasses
 import os
 from collections.abc import Sequence
 from copy import copy
@@ -50,13 +49,15 @@ class GetSymbolsOverviewTool(Tool, ToolMarkerSymbolicRead):
     Gets an overview of the top-level symbols defined in a given file.
     """
 
-    def apply(self, relative_path: str, max_answer_chars: int = -1) -> str:
+    def apply(self, relative_path: str, depth: int = 0, max_answer_chars: int = -1) -> str:
         """
         Use this tool to get a high-level understanding of the code symbols in a file.
         This should be the first tool to call when you want to understand a new file, unless you already know
         what you are looking for.
 
         :param relative_path: the relative path to the file to get the overview of
+        :param depth: depth up to which descendants of top-level symbols shall be retrieved
+            (e.g. 1 retrieves immediate children). Default 0.
         :param max_answer_chars: if the overview is longer than this number of characters,
             no content will be returned. -1 means the default value from the config will be used.
             Don't adjust unless there is really no other way to get the content required for the task.
@@ -71,8 +72,8 @@ class GetSymbolsOverviewTool(Tool, ToolMarkerSymbolicRead):
             raise FileNotFoundError(f"File or directory {relative_path} does not exist in the project.")
         if os.path.isdir(file_path):
             raise ValueError(f"Expected a file path, but got a directory path: {relative_path}. ")
-        result = symbol_retriever.get_symbol_overview(relative_path)[relative_path]
-        result_json_str = self._to_json([dataclasses.asdict(i) for i in result])
+        result = symbol_retriever.get_symbol_overview(relative_path, depth=depth)[relative_path]
+        result_json_str = self._to_json(result)
         return self._limit_length(result_json_str, max_answer_chars)
 
 
@@ -136,7 +137,7 @@ class FindSymbolTool(Tool, ToolMarkerSymbolicRead):
         parsed_include_kinds: Sequence[SymbolKind] | None = [SymbolKind(k) for k in include_kinds] if include_kinds else None
         parsed_exclude_kinds: Sequence[SymbolKind] | None = [SymbolKind(k) for k in exclude_kinds] if exclude_kinds else None
         symbol_retriever = self.create_language_server_symbol_retriever()
-        symbols = symbol_retriever.find_by_name(
+        symbols = symbol_retriever.find(
             name_path_pattern,
             include_kinds=parsed_include_kinds,
             exclude_kinds=parsed_exclude_kinds,

src/serena/util/inspection.py

@@ -19,13 +19,13 @@ def iter_subclasses(cls: type[T], recursive: bool = True) -> Generator[type[T],
             yield from iter_subclasses(subclass, recursive)
 
 
-def determine_programming_language_composition(repo_path: str) -> dict[str, float]:
+def determine_programming_language_composition(repo_path: str) -> dict[Language, float]:
     """
     Determine the programming language composition of a repository.
 
     :param repo_path: Path to the repository to analyze
 
-    :return: Dictionary mapping language names to percentages of files matching each language
+    :return: Dictionary mapping languages to percentages of files matching each language
     """
     all_files = find_all_non_ignored_files(repo_path)
 
@@ -33,7 +33,7 @@ def determine_programming_language_composition(repo_path: str) -> dict[str, floa
         return {}
 
     # Count files for each language
-    language_counts: dict[str, int] = {}
+    language_counts: dict[Language, int] = {}
     total_files = len(all_files)
 
     for language in Language.iter_all(include_experimental=False):
@@ -47,12 +47,12 @@ def determine_programming_language_composition(repo_path: str) -> dict[str, floa
                 count += 1
 
         if count > 0:
-            language_counts[str(language)] = count
+            language_counts[language] = count
 
     # Convert counts to percentages
-    language_percentages: dict[str, float] = {}
-    for language_name, count in language_counts.items():
+    language_percentages: dict[Language, float] = {}
+    for language, count in language_counts.items():
         percentage = (count / total_files) * 100
-        language_percentages[language_name] = round(percentage, 2)
+        language_percentages[language] = round(percentage, 2)
 
     return language_percentages

src/solidlsp/language_servers/csharp_language_server.py

@@ -532,7 +532,7 @@ class CSharpLanguageServer(SolidLanguageServer):
             # Map LSP message types to Python logging levels
             level_map = {1: logging.ERROR, 2: logging.WARNING, 3: logging.INFO, 4: logging.DEBUG}  # Error  # Warning  # Info  # Log
 
-            log.info(f"LSP: {message_text}", level_map.get(level, logging.DEBUG))
+            log.log(level_map.get(level, logging.DEBUG), f"LSP: {message_text}")
 
         def handle_progress(params: dict) -> None:
             """Handle progress notifications from the language server."""
@@ -627,10 +627,14 @@ class CSharpLanguageServer(SolidLanguageServer):
         def handle_project_needs_restore(params: dict) -> None:
             return
 
+        def handle_workspace_indexing_complete(params: dict) -> None:
+            self.completions_available.set()
+
         # Set up notification handlers
         self.server.on_notification("window/logMessage", window_log_message)
         self.server.on_notification("$/progress", handle_progress)
         self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+        self.server.on_notification("workspace/projectInitializationComplete", handle_workspace_indexing_complete)
         self.server.on_request("workspace/configuration", handle_workspace_configuration)
         self.server.on_request("window/workDoneProgress/create", handle_work_done_progress_create)
         self.server.on_request("client/registerCapability", handle_register_capability)
@@ -679,7 +683,6 @@ class CSharpLanguageServer(SolidLanguageServer):
         self._open_solution_and_projects()
 
         self.initialization_complete.set()
-        self.completions_available.set()
 
         log.info(
             "Microsoft.CodeAnalysis.LanguageServer initialized and ready\n"
@@ -687,6 +690,12 @@ class CSharpLanguageServer(SolidLanguageServer):
             "This may take a while for large projects"
         )
 
+        if self.completions_available.wait(30):  # Wait up to 30 seconds for indexing
+            log.info("Indexing complete")
+        else:
+            log.warning("Timeout waiting for indexing to complete, proceeding anyway")
+            self.completions_available.set()
+
     def _force_pull_diagnostics(self, init_response: dict | InitializeResult) -> None:
         """
         Apply the diagnostic capabilities hack.

src/solidlsp/language_servers/fsharp_language_server.py

@@ -0,0 +1,382 @@
+"""
+Provides F# specific instantiation of the LanguageServer class.
+"""
+
+import logging
+import os
+import pathlib
+import shutil
+import threading
+from pathlib import Path
+
+from overrides import override
+
+from solidlsp.language_servers.common import RuntimeDependency, RuntimeDependencyCollection
+from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls_config import LanguageServerConfig
+from solidlsp.ls_exceptions import SolidLSPException
+from solidlsp.lsp_protocol_handler.lsp_types import InitializeParams
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+
+log = logging.getLogger(__name__)
+
+
+class FSharpLanguageServer(SolidLanguageServer):
+    """
+    Provides F# specific instantiation of the LanguageServer class using Ionide LSP (FsAutoComplete).
+    Contains various configurations and settings specific to F# development.
+    """
+
+    def __init__(self, config: LanguageServerConfig, repository_root_path: str, solidlsp_settings: SolidLSPSettings):
+        """
+        Creates an FSharpLanguageServer instance. This class is not meant to be instantiated directly.
+        Use LanguageServer.create() instead.
+        """
+        fsharp_lsp_executable_path = self._setup_runtime_dependencies(config, solidlsp_settings)
+        super().__init__(
+            config,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=fsharp_lsp_executable_path, cwd=repository_root_path),
+            "fsharp",
+            solidlsp_settings,
+        )
+        self.server_ready = threading.Event()
+        self.initialize_searcher_command_available = threading.Event()
+
+    @override
+    def is_ignored_dirname(self, dirname: str) -> bool:
+        return super().is_ignored_dirname(dirname) or dirname in [
+            "bin",
+            "obj",
+            "packages",
+            ".paket",
+            "paket-files",
+            ".fake",
+            ".ionide",
+        ]
+
+    @classmethod
+    def _setup_runtime_dependencies(cls, config: LanguageServerConfig, solidlsp_settings: SolidLSPSettings) -> str:
+        """
+        Setup runtime dependencies for F# Language Server and return the command to start the server.
+        """
+        # First check if .NET SDK is installed
+        dotnet_exe = shutil.which("dotnet")
+        if not dotnet_exe:
+            raise RuntimeError(
+                ".NET SDK is not installed or not in PATH. Please install .NET SDK 8.0 or later and ensure 'dotnet' is in your PATH."
+            )
+
+        # Verify dotnet version
+        import subprocess
+
+        try:
+            result = subprocess.run([dotnet_exe, "--version"], capture_output=True, text=True, check=True)
+            log.info(f"Found .NET SDK version: {result.stdout.strip()}")
+        except subprocess.CalledProcessError:
+            raise RuntimeError("Failed to get .NET SDK version. Please ensure .NET SDK is properly installed.")
+
+        RuntimeDependencyCollection(
+            [
+                RuntimeDependency(
+                    id="fsautocomplete",
+                    description="FsAutoComplete (Ionide F# Language Server)",
+                    command="dotnet tool install --tool-path ./ fsautocomplete",
+                    platform_id="any",
+                ),
+            ]
+        )
+
+        # Install FsAutoComplete if not already installed
+        fsharp_ls_dir = os.path.join(cls.ls_resources_dir(solidlsp_settings), "fsharp-lsp")
+        fsautocomplete_path = os.path.join(fsharp_ls_dir, "fsautocomplete")
+
+        # Handle Windows executable extension
+        if os.name == "nt":
+            fsautocomplete_path += ".exe"
+
+        if not os.path.exists(fsautocomplete_path):
+            log.info(f"FsAutoComplete executable not found at {fsautocomplete_path}. Installing...")
+
+            # Ensure the directory exists
+            os.makedirs(fsharp_ls_dir, exist_ok=True)
+
+            # Install FsAutoComplete using dotnet tool install
+            try:
+                import subprocess
+
+                result = subprocess.run(
+                    [dotnet_exe, "tool", "install", "--tool-path", fsharp_ls_dir, "fsautocomplete"],
+                    cwd=fsharp_ls_dir,
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                log.info("FsAutoComplete installed successfully")
+                log.debug(f"Installation output: {result.stdout}")
+            except subprocess.CalledProcessError as e:
+                log.error(f"Failed to install FsAutoComplete: {e.stderr}")
+                raise RuntimeError(f"Failed to install FsAutoComplete: {e.stderr}")
+
+        if not os.path.exists(fsautocomplete_path):
+            raise FileNotFoundError(
+                f"FsAutoComplete executable not found at {fsautocomplete_path}, something went wrong with the installation."
+            )
+
+        # FsAutoComplete uses --lsp flag for LSP mode
+        return f"{fsautocomplete_path} --adaptive-lsp-server-enabled --project-graph-enabled --use-fcs-transparent-compiler"
+
+    def _get_initialize_params(self) -> InitializeParams:
+        """
+        Returns the initialize params for the F# Language Server.
+        """
+        root_uri = pathlib.Path(self.repository_root_path).as_uri()
+
+        initialize_params = {
+            "processId": os.getpid(),
+            "rootPath": self.repository_root_path,
+            "rootUri": root_uri,
+            "workspaceFolders": [{"name": "workspace", "uri": root_uri}],
+            "capabilities": {
+                "workspace": {
+                    "applyEdit": True,
+                    "workspaceEdit": {"documentChanges": True},
+                    "didChangeConfiguration": {"dynamicRegistration": True},
+                    "didChangeWatchedFiles": {"dynamicRegistration": True},
+                    "symbol": {"dynamicRegistration": True},
+                    "executeCommand": {"dynamicRegistration": True},
+                    "configuration": True,
+                    "workspaceFolders": True,
+                },
+                "textDocument": {
+                    "synchronization": {
+                        "dynamicRegistration": True,
+                        "willSave": True,
+                        "willSaveWaitUntil": True,
+                        "didSave": True,
+                    },
+                    "completion": {
+                        "dynamicRegistration": True,
+                        "contextSupport": True,
+                        "completionItem": {
+                            "snippetSupport": True,
+                            "commitCharactersSupport": True,
+                            "documentationFormat": ["markdown", "plaintext"],
+                            "deprecatedSupport": True,
+                        },
+                    },
+                    "hover": {
+                        "dynamicRegistration": True,
+                        "contentFormat": ["markdown", "plaintext"],
+                    },
+                    "signatureHelp": {
+                        "dynamicRegistration": True,
+                        "signatureInformation": {"documentationFormat": ["markdown", "plaintext"]},
+                    },
+                    "definition": {"dynamicRegistration": True},
+                    "references": {"dynamicRegistration": True},
+                    "documentHighlight": {"dynamicRegistration": True},
+                    "documentSymbol": {
+                        "dynamicRegistration": True,
+                        "symbolKind": {"valueSet": list(range(1, 26))},  # All SymbolKind values
+                        "hierarchicalDocumentSymbolSupport": True,
+                    },
+                    "codeAction": {
+                        "dynamicRegistration": True,
+                        "codeActionLiteralSupport": {
+                            "codeActionKind": {
+                                "valueSet": [
+                                    "",
+                                    "quickfix",
+                                    "refactor",
+                                    "refactor.extract",
+                                    "refactor.inline",
+                                    "refactor.rewrite",
+                                    "source",
+                                    "source.organizeImports",
+                                ]
+                            }
+                        },
+                    },
+                    "codeLens": {"dynamicRegistration": True},
+                    "formatting": {"dynamicRegistration": True},
+                    "rangeFormatting": {"dynamicRegistration": True},
+                    "onTypeFormatting": {"dynamicRegistration": True},
+                    "rename": {"dynamicRegistration": True},
+                    "documentLink": {"dynamicRegistration": True},
+                    "publishDiagnostics": {
+                        "relatedInformation": True,
+                        "versionSupport": False,
+                        "tagSupport": {"valueSet": [1, 2]},
+                    },
+                    "implementation": {"dynamicRegistration": True},
+                    "typeDefinition": {"dynamicRegistration": True},
+                    "colorProvider": {"dynamicRegistration": True},
+                    "foldingRange": {
+                        "dynamicRegistration": True,
+                        "rangeLimit": 5000,
+                        "lineFoldingOnly": True,
+                    },
+                    "declaration": {"dynamicRegistration": True},
+                    "selectionRange": {"dynamicRegistration": True},
+                },
+                "window": {
+                    "workDoneProgress": True,
+                },
+            },
+            "initializationOptions": {
+                # F# specific initialization options
+                "automaticWorkspaceInit": True,
+                "abstractClassStubGeneration": True,
+                "abstractClassStubGenerationObjectIdentifier": "this",
+                "abstractClassStubGenerationMethodBody": 'failwith "Not Implemented"',
+                "addFsiWatcher": False,
+                "codeLenses": {"signature": {"enabled": True}, "references": {"enabled": True}},
+                "disableInMemoryProjectReferences": False,
+                "dotNetRoot": self._get_dotnet_root(),
+                "enableMSBuildProjectGraph": False,
+                "excludeProjectDirectories": ["paket-files"],
+                "externalAutocomplete": False,
+                "fsac": {"attachDebugger": False, "silencedLogs": [], "conserveMemory": False, "netCoreDllPath": ""},
+                "fsiExtraParameters": [],
+                "generateBinlog": False,
+                "interfaceStubGeneration": True,
+                "interfaceStubGenerationObjectIdentifier": "this",
+                "interfaceStubGenerationMethodBody": 'failwith "Not Implemented"',
+                "keywordsAutocomplete": True,
+                "linter": True,
+                "pipelineHints": {"enabled": True},
+                "recordStubGeneration": True,
+                "recordStubGenerationBody": 'failwith "Not Implemented"',
+                "resolveNamespaces": True,
+                "saveOnlyOpenFiles": False,
+                "showProjectExplorerIn": ["ionide", "solution"],
+                "simplifyNameAnalyzer": True,
+                "smartIndent": False,
+                "suggestGitignore": True,
+                "suggestSdkScripts": True,
+                "unionCaseStubGeneration": True,
+                "unionCaseStubGenerationBody": 'failwith "Not Implemented"',
+                "unusedDeclarationsAnalyzer": True,
+                "unusedOpensAnalyzer": True,
+                "verboseLogging": False,
+                "workspaceModePeekDeepLevel": 2,
+                "workspacePath": self.repository_root_path,
+            },
+            "trace": "off",
+        }
+
+        return initialize_params  # type: ignore
+
+    def _get_dotnet_root(self) -> str:
+        """
+        Get the .NET root directory.
+        """
+        dotnet_exe = shutil.which("dotnet")
+        if dotnet_exe:
+            # Try to get the installation path
+            try:
+                import subprocess
+
+                result = subprocess.run([dotnet_exe, "--info"], capture_output=True, text=True, check=True)
+                lines = result.stdout.split("\n")
+                for line in lines:
+                    if "Base Path:" in line or "Base path:" in line:
+                        base_path = line.split(":", 1)[1].strip()
+                        # Get the parent directory (remove 'sdk/version' part)
+                        return str(Path(base_path).parent.parent)
+            except (subprocess.CalledProcessError, Exception):
+                pass
+
+        # Fallback: use the directory containing dotnet executable
+        if dotnet_exe:
+            return str(Path(dotnet_exe).parent)
+
+        return ""
+
+    def _start_server(self) -> None:
+        """
+        Start the F# Language Server with custom handlers.
+        """
+
+        def handle_window_log_message(params: dict) -> None:
+            """Handle window/logMessage from the LSP server."""
+            message = params.get("message", "")
+            message_type = params.get("type", 1)
+
+            # Map LSP log levels to Python logging levels
+            level_map = {1: logging.ERROR, 2: logging.WARNING, 3: logging.INFO, 4: logging.DEBUG}
+            level = level_map.get(message_type, logging.INFO)
+
+            log.log(level, f"FsAutoComplete: {message}")
+
+        def handle_window_show_message(params: dict) -> None:
+            """Handle window/showMessage from the LSP server."""
+            message = params.get("message", "")
+            message_type = params.get("type", 1)
+
+            # Map LSP message types to Python logging levels
+            level_map = {1: logging.ERROR, 2: logging.WARNING, 3: logging.INFO, 4: logging.DEBUG}
+            level = level_map.get(message_type, logging.INFO)
+
+            log.log(level, f"FsAutoComplete Message: {message}")
+
+        def handle_workspace_configuration(params: dict) -> list:
+            """Handle workspace/configuration requests from the LSP server."""
+            # Return empty configuration for now
+            items = params.get("items", [])
+            return [None] * len(items)
+
+        def handle_client_register_capability(params: dict) -> None:
+            """Handle client/registerCapability requests from the LSP server."""
+            # For now, just acknowledge the registration
+            return
+
+        def handle_client_unregister_capability(params: dict) -> None:
+            """Handle client/unregisterCapability requests from the LSP server."""
+            # For now, just acknowledge the unregistration
+            return
+
+        def handle_work_done_progress_create(params: dict) -> None:
+            """Handle window/workDoneProgress/create requests from the LSP server."""
+            # Just acknowledge the request - we don't need to track progress for now
+            return
+
+        # Register custom handlers
+        self.server.on_notification("window/logMessage", handle_window_log_message)
+        self.server.on_notification("window/showMessage", handle_window_show_message)
+        self.server.on_request("workspace/configuration", handle_workspace_configuration)
+        self.server.on_request("client/registerCapability", handle_client_register_capability)
+        self.server.on_request("client/unregisterCapability", handle_client_unregister_capability)
+        self.server.on_request("window/workDoneProgress/create", handle_work_done_progress_create)
+
+        log.info("Starting FsAutoComplete F# language server process")
+
+        try:
+            self.server.start()
+        except Exception as e:
+            log.error(f"Failed to start F# language server process: {e}")
+            raise SolidLSPException(f"Failed to start F# language server: {e}")
+
+        # Send initialization
+        initialize_params = self._get_initialize_params()
+
+        log.info("Sending initialize request to F# language server")
+        try:
+            self.server.send.initialize(initialize_params)
+            log.debug("Received initialize response from F# language server")
+        except Exception as e:
+            raise SolidLSPException(f"Failed to initialize F# language server for {self.repository_root_path}: {e}") from e
+
+        # Complete initialization
+        self.server.notify.initialized({})
+
+        log.info("F# language server initialized successfully")
+
+    @override
+    def _get_wait_time_for_cross_file_referencing(self) -> float:
+        """
+        F# projects can be large and may need more time for cross-file analysis.
+        """
+        return 15.0  # 15 seconds should be sufficient for most F# projects

src/solidlsp/language_servers/scala_language_server.py

@@ -61,11 +61,12 @@ class ScalaLanguageServer(SolidLanguageServer):
         os.makedirs(metals_home, exist_ok=True)
         metals_executable = os.path.join(metals_home, "metals")
         coursier_command_path = shutil.which("coursier")
-        assert coursier_command_path is not None, "coursier is not installed or not in PATH."
         cs_command_path = shutil.which("cs")
+        assert cs_command_path is not None or coursier_command_path is not None, "coursier is not installed or not in PATH."
 
         if not os.path.exists(metals_executable):
             if not cs_command_path:
+                assert coursier_command_path is not None
                 log.info("'cs' command not found. Trying to install it using 'coursier'.")
                 try:
                     log.info("Running 'coursier setup --yes' to install 'cs'...")

src/solidlsp/language_servers/typescript_language_server.py

@@ -12,6 +12,7 @@ from typing import Any, cast
 from overrides import override
 from sensai.util.logging import LogTime
 
+from solidlsp import ls_types
 from solidlsp.ls import SolidLanguageServer
 from solidlsp.ls_config import LanguageServerConfig
 from solidlsp.ls_utils import PlatformId, PlatformUtils
@@ -39,9 +40,32 @@ if not PlatformUtils.get_platform_id().value.startswith("win"):
     pass
 
 
+def prefer_non_node_modules_definition(definitions: list[ls_types.Location]) -> ls_types.Location:
+    """
+    Select the preferred definition, preferring source files over type definitions.
+
+    TypeScript language servers often return both type definitions (.d.ts files
+    in node_modules) and source definitions. This function prefers:
+    1. Files not in node_modules
+    2. Falls back to first definition if all are in node_modules
+
+    :param definitions: A non-empty list of definition locations.
+    :return: The preferred definition location.
+    """
+    for d in definitions:
+        rel_path = d.get("relativePath", "")
+        if rel_path and "node_modules" not in rel_path:
+            return d
+    return definitions[0]
+
+
 class TypeScriptLanguageServer(SolidLanguageServer):
     """
     Provides TypeScript specific instantiation of the LanguageServer class. Contains various configurations and settings specific to TypeScript.
+
+    You can pass the following entries in ls_specific_settings["typescript"]:
+        - typescript_version: Version of TypeScript to install (default: "5.9.3")
+        - typescript_language_server_version: Version of typescript-language-server to install (default: "5.1.3")
     """
 
     def __init__(self, config: LanguageServerConfig, repository_root_path: str, solidlsp_settings: SolidLSPSettings):
@@ -91,18 +115,23 @@ class TypeScriptLanguageServer(SolidLanguageServer):
         ]
         assert platform_id in valid_platforms, f"Platform {platform_id} is not supported for multilspy javascript/typescript at the moment"
 
+        # Get version settings from ls_specific_settings or use defaults
+        language_specific_config = solidlsp_settings.get_ls_specific_settings(cls.get_language_enum_instance())
+        typescript_version = language_specific_config.get("typescript_version", "5.9.3")
+        typescript_language_server_version = language_specific_config.get("typescript_language_server_version", "5.1.3")
+
         deps = RuntimeDependencyCollection(
             [
                 RuntimeDependency(
                     id="typescript",
                     description="typescript package",
-                    command=["npm", "install", "--prefix", "./", "typescript@5.5.4"],
+                    command=["npm", "install", "--prefix", "./", f"typescript@{typescript_version}"],
                     platform_id="any",
                 ),
                 RuntimeDependency(
                     id="typescript-language-server",
                     description="typescript-language-server package",
-                    command=["npm", "install", "--prefix", "./", "typescript-language-server@4.3.3"],
+                    command=["npm", "install", "--prefix", "./", f"typescript-language-server@{typescript_language_server_version}"],
                     platform_id="any",
                 ),
             ]
@@ -114,19 +143,39 @@ class TypeScriptLanguageServer(SolidLanguageServer):
         is_npm_installed = shutil.which("npm") is not None
         assert is_npm_installed, "npm is not installed or isn't in PATH. Please install npm and try again."
 
-        # Verify both node and npm are installed
-        is_node_installed = shutil.which("node") is not None
-        assert is_node_installed, "node is not installed or isn't in PATH. Please install NodeJS and try again."
-        is_npm_installed = shutil.which("npm") is not None
-        assert is_npm_installed, "npm is not installed or isn't in PATH. Please install npm and try again."
-
-        # Install typescript and typescript-language-server if not already installed
+        # Install typescript and typescript-language-server if not already installed or version mismatch
         tsserver_ls_dir = os.path.join(cls.ls_resources_dir(solidlsp_settings), "ts-lsp")
         tsserver_executable_path = os.path.join(tsserver_ls_dir, "node_modules", ".bin", "typescript-language-server")
+
+        # Check if installation is needed based on executable AND version
+        version_file = os.path.join(tsserver_ls_dir, ".installed_version")
+        expected_version = f"{typescript_version}_{typescript_language_server_version}"
+
+        needs_install = False
         if not os.path.exists(tsserver_executable_path):
-            log.info(f"Typescript Language Server executable not found at {tsserver_executable_path}. Installing...")
+            log.info(f"Typescript Language Server executable not found at {tsserver_executable_path}.")
+            needs_install = True
+        elif os.path.exists(version_file):
+            with open(version_file) as f:
+                installed_version = f.read().strip()
+            if installed_version != expected_version:
+                log.info(
+                    f"TypeScript Language Server version mismatch: installed={installed_version}, expected={expected_version}. Reinstalling..."
+                )
+                needs_install = True
+        else:
+            # No version file exists, assume old installation needs refresh
+            log.info("TypeScript Language Server version file not found. Reinstalling to ensure correct version...")
+            needs_install = True
+
+        if needs_install:
+            log.info("Installing TypeScript Language Server dependencies...")
             with LogTime("Installation of TypeScript language server dependencies", logger=log):
                 deps.install(tsserver_ls_dir)
+            # Write version marker file
+            with open(version_file, "w") as f:
+                f.write(expected_version)
+            log.info("TypeScript language server dependencies installed successfully")
 
         if not os.path.exists(tsserver_executable_path):
             raise FileNotFoundError(
@@ -134,8 +183,7 @@ class TypeScriptLanguageServer(SolidLanguageServer):
             )
         return [tsserver_executable_path, "--stdio"]
 
-    @staticmethod
-    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
+    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialize params for the TypeScript Language Server.
         """
@@ -156,6 +204,7 @@ class TypeScriptLanguageServer(SolidLanguageServer):
                     "hover": {"dynamicRegistration": True, "contentFormat": ["markdown", "plaintext"]},
                     "signatureHelp": {"dynamicRegistration": True},
                     "codeAction": {"dynamicRegistration": True},
+                    "rename": {"dynamicRegistration": True, "prepareSupport": True},
                 },
                 "workspace": {
                     "workspaceFolders": True,
@@ -252,3 +301,7 @@ class TypeScriptLanguageServer(SolidLanguageServer):
     @override
     def _get_wait_time_for_cross_file_referencing(self) -> float:
         return 1
+
+    @override
+    def _get_preferred_definition(self, definitions: list[ls_types.Location]) -> ls_types.Location:
+        return prefer_non_node_modules_definition(definitions)

src/solidlsp/language_servers/vue_language_server.py

@@ -0,0 +1,809 @@
+"""
+Vue Language Server implementation using @vue/language-server (Volar) with companion TypeScript LS.
+Operates in hybrid mode: Vue LS handles .vue files, TypeScript LS handles .ts/.js files.
+"""
+
+import logging
+import os
+import pathlib
+import shutil
+import threading
+from pathlib import Path
+from time import sleep
+from typing import Any
+
+from overrides import override
+
+from solidlsp import ls_types
+from solidlsp.language_servers.common import RuntimeDependency, RuntimeDependencyCollection
+from solidlsp.language_servers.typescript_language_server import (
+    TypeScriptLanguageServer,
+    prefer_non_node_modules_definition,
+)
+from solidlsp.ls import LSPFileBuffer, SolidLanguageServer
+from solidlsp.ls_config import Language, LanguageServerConfig
+from solidlsp.ls_exceptions import SolidLSPException
+from solidlsp.ls_types import Location
+from solidlsp.ls_utils import PathUtils
+from solidlsp.lsp_protocol_handler import lsp_types
+from solidlsp.lsp_protocol_handler.lsp_types import DocumentSymbol, ExecuteCommandParams, InitializeParams, SymbolInformation
+from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
+from solidlsp.settings import SolidLSPSettings
+
+log = logging.getLogger(__name__)
+
+
+class VueTypeScriptServer(TypeScriptLanguageServer):
+    """TypeScript LS configured with @vue/typescript-plugin for Vue file support."""
+
+    _pending_ts_ls_executable: list[str] | None = None
+
+    @classmethod
+    @override
+    def get_language_enum_instance(cls) -> Language:
+        """Return TYPESCRIPT since this is a TypeScript language server variant.
+
+        Note: VueTypeScriptServer is a companion server that uses TypeScript's language server
+        with the Vue TypeScript plugin. It reports as TYPESCRIPT to maintain compatibility
+        with the TypeScript language server infrastructure.
+        """
+        return Language.TYPESCRIPT
+
+    @classmethod
+    @override
+    def _setup_runtime_dependencies(cls, config: LanguageServerConfig, solidlsp_settings: SolidLSPSettings) -> list[str]:
+        if cls._pending_ts_ls_executable is not None:
+            return cls._pending_ts_ls_executable
+        return ["typescript-language-server", "--stdio"]
+
+    @override
+    def _get_language_id_for_file(self, relative_file_path: str) -> str:
+        """Return the correct language ID for files.
+
+        Vue files must be opened with language ID "vue" for the @vue/typescript-plugin
+        to process them correctly. The plugin is configured with "languages": ["vue"]
+        in the initialization options.
+        """
+        ext = os.path.splitext(relative_file_path)[1].lower()
+        if ext == ".vue":
+            return "vue"
+        elif ext in (".ts", ".tsx", ".mts", ".cts"):
+            return "typescript"
+        elif ext in (".js", ".jsx", ".mjs", ".cjs"):
+            return "javascript"
+        else:
+            return "typescript"
+
+    def __init__(
+        self,
+        config: LanguageServerConfig,
+        repository_root_path: str,
+        solidlsp_settings: SolidLSPSettings,
+        vue_plugin_path: str,
+        tsdk_path: str,
+        ts_ls_executable_path: list[str],
+    ):
+        self._vue_plugin_path = vue_plugin_path
+        self._custom_tsdk_path = tsdk_path
+        VueTypeScriptServer._pending_ts_ls_executable = ts_ls_executable_path
+        super().__init__(config, repository_root_path, solidlsp_settings)
+        VueTypeScriptServer._pending_ts_ls_executable = None
+
+    @override
+    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+        params = super()._get_initialize_params(repository_absolute_path)
+
+        params["initializationOptions"] = {
+            "plugins": [
+                {
+                    "name": "@vue/typescript-plugin",
+                    "location": self._vue_plugin_path,
+                    "languages": ["vue"],
+                }
+            ],
+            "tsserver": {
+                "path": self._custom_tsdk_path,
+            },
+        }
+
+        if "workspace" in params["capabilities"]:
+            params["capabilities"]["workspace"]["executeCommand"] = {"dynamicRegistration": True}
+
+        return params
+
+    @override
+    def _start_server(self) -> None:
+        def workspace_configuration_handler(params: dict) -> list:
+            items = params.get("items", [])
+            return [{} for _ in items]
+
+        self.server.on_request("workspace/configuration", workspace_configuration_handler)
+        super()._start_server()
+
+
+class VueLanguageServer(SolidLanguageServer):
+    """
+    Language server for Vue Single File Components using @vue/language-server (Volar) with companion TypeScript LS.
+
+    You can pass the following entries in ls_specific_settings["vue"]:
+        - vue_language_server_version: Version of @vue/language-server to install (default: "3.1.5")
+
+    Note: TypeScript versions are configured via ls_specific_settings["typescript"]:
+        - typescript_version: Version of TypeScript to install (default: "5.9.3")
+        - typescript_language_server_version: Version of typescript-language-server to install (default: "5.1.3")
+    """
+
+    TS_SERVER_READY_TIMEOUT = 5.0
+    VUE_SERVER_READY_TIMEOUT = 3.0
+    # Windows requires more time due to slower I/O and process operations.
+    VUE_INDEXING_WAIT_TIME = 4.0 if os.name == "nt" else 2.0
+
+    def __init__(self, config: LanguageServerConfig, repository_root_path: str, solidlsp_settings: SolidLSPSettings):
+        vue_lsp_executable_path, self.tsdk_path, self._ts_ls_cmd = self._setup_runtime_dependencies(config, solidlsp_settings)
+        self._vue_ls_dir = os.path.join(self.ls_resources_dir(solidlsp_settings), "vue-lsp")
+        super().__init__(
+            config,
+            repository_root_path,
+            ProcessLaunchInfo(cmd=vue_lsp_executable_path, cwd=repository_root_path),
+            "vue",
+            solidlsp_settings,
+        )
+        self.server_ready = threading.Event()
+        self.initialize_searcher_command_available = threading.Event()
+        self._ts_server: VueTypeScriptServer | None = None
+        self._ts_server_started = False
+        self._vue_files_indexed = False
+        self._indexed_vue_file_uris: list[str] = []
+
+    @override
+    def is_ignored_dirname(self, dirname: str) -> bool:
+        return super().is_ignored_dirname(dirname) or dirname in [
+            "node_modules",
+            "dist",
+            "build",
+            "coverage",
+            ".nuxt",
+            ".output",
+        ]
+
+    @override
+    def _get_language_id_for_file(self, relative_file_path: str) -> str:
+        ext = os.path.splitext(relative_file_path)[1].lower()
+        if ext == ".vue":
+            return "vue"
+        elif ext in (".ts", ".tsx", ".mts", ".cts"):
+            return "typescript"
+        elif ext in (".js", ".jsx", ".mjs", ".cjs"):
+            return "javascript"
+        else:
+            return "vue"
+
+    def _is_typescript_file(self, file_path: str) -> bool:
+        ext = os.path.splitext(file_path)[1].lower()
+        return ext in (".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs")
+
+    def _find_all_vue_files(self) -> list[str]:
+        vue_files = []
+        repo_path = Path(self.repository_root_path)
+
+        for vue_file in repo_path.rglob("*.vue"):
+            try:
+                relative_path = str(vue_file.relative_to(repo_path))
+                if "node_modules" not in relative_path and not relative_path.startswith("."):
+                    vue_files.append(relative_path)
+            except Exception as e:
+                log.debug(f"Error processing Vue file {vue_file}: {e}")
+
+        return vue_files
+
+    def _ensure_vue_files_indexed_on_ts_server(self) -> None:
+        if self._vue_files_indexed:
+            return
+
+        assert self._ts_server is not None
+        log.info("Indexing .vue files on TypeScript server for cross-file references")
+        vue_files = self._find_all_vue_files()
+        log.debug(f"Found {len(vue_files)} .vue files to index")
+
+        for vue_file in vue_files:
+            try:
+                with self._ts_server.open_file(vue_file) as file_buffer:
+                    file_buffer.ref_count += 1
+                    self._indexed_vue_file_uris.append(file_buffer.uri)
+            except Exception as e:
+                log.debug(f"Failed to open {vue_file} on TS server: {e}")
+
+        self._vue_files_indexed = True
+        log.info("Vue file indexing on TypeScript server complete")
+
+        sleep(self._get_vue_indexing_wait_time())
+        log.debug("Wait period after Vue file indexing complete")
+
+    def _get_vue_indexing_wait_time(self) -> float:
+        return self.VUE_INDEXING_WAIT_TIME
+
+    def _send_references_request(self, relative_file_path: str, line: int, column: int) -> list[lsp_types.Location] | None:
+        uri = PathUtils.path_to_uri(os.path.join(self.repository_root_path, relative_file_path))
+        request_params = {
+            "textDocument": {"uri": uri},
+            "position": {"line": line, "character": column},
+            "context": {"includeDeclaration": False},
+        }
+
+        return self.server.send.references(request_params)  # type: ignore[arg-type]
+
+    def _send_ts_references_request(self, relative_file_path: str, line: int, column: int) -> list[ls_types.Location]:
+        assert self._ts_server is not None
+        uri = PathUtils.path_to_uri(os.path.join(self.repository_root_path, relative_file_path))
+        request_params = {
+            "textDocument": {"uri": uri},
+            "position": {"line": line, "character": column},
+            "context": {"includeDeclaration": True},
+        }
+
+        with self._ts_server.open_file(relative_file_path):
+            response = self._ts_server.handler.send.references(request_params)  # type: ignore[arg-type]
+
+        result: list[ls_types.Location] = []
+        if response is not None:
+            for item in response:
+                abs_path = PathUtils.uri_to_path(item["uri"])
+                if not Path(abs_path).is_relative_to(self.repository_root_path):
+                    log.debug(f"Found reference outside repository: {abs_path}, skipping")
+                    continue
+
+                rel_path = Path(abs_path).relative_to(self.repository_root_path)
+                if self.is_ignored_path(str(rel_path)):
+                    log.debug(f"Ignoring reference in {rel_path}")
+                    continue
+
+                new_item: dict = {}
+                new_item.update(item)  # type: ignore[arg-type]
+                new_item["absolutePath"] = str(abs_path)
+                new_item["relativePath"] = str(rel_path)
+                result.append(ls_types.Location(**new_item))  # type: ignore
+
+        return result
+
+    def request_file_references(self, relative_file_path: str) -> list:
+        if not self.server_started:
+            log.error("request_file_references called before Language Server started")
+            raise SolidLSPException("Language Server not started")
+
+        absolute_file_path = os.path.join(self.repository_root_path, relative_file_path)
+        uri = PathUtils.path_to_uri(absolute_file_path)
+
+        request_params = {"textDocument": {"uri": uri}}
+
+        log.info(f"Sending volar/client/findFileReference request for {relative_file_path}")
+        log.info(f"Request URI: {uri}")
+        log.info(f"Request params: {request_params}")
+
+        try:
+            with self.open_file(relative_file_path):
+                log.debug(f"Sending volar/client/findFileReference for {relative_file_path}")
+                log.debug(f"Request params: {request_params}")
+
+                response = self.server.send_request("volar/client/findFileReference", request_params)
+
+                log.debug(f"Received response type: {type(response)}")
+
+            log.info(f"Received file references response: {response}")
+            log.info(f"Response type: {type(response)}")
+
+            if response is None:
+                log.debug(f"No file references found for {relative_file_path}")
+                return []
+
+            # Response should be an array of Location objects
+            if not isinstance(response, list):
+                log.warning(f"Unexpected response format from volar/client/findFileReference: {type(response)}")
+                return []
+
+            ret: list[Location] = []
+            for item in response:
+                if not isinstance(item, dict) or "uri" not in item:
+                    log.debug(f"Skipping invalid location item: {item}")
+                    continue
+
+                abs_path = PathUtils.uri_to_path(item["uri"])  # type: ignore[arg-type]
+                if not Path(abs_path).is_relative_to(self.repository_root_path):
+                    log.warning(f"Found file reference outside repository: {abs_path}, skipping")
+                    continue
+
+                rel_path = Path(abs_path).relative_to(self.repository_root_path)
+                if self.is_ignored_path(str(rel_path)):
+                    log.debug(f"Ignoring file reference in {rel_path}")
+                    continue
+
+                new_item: dict = {}
+                new_item.update(item)  # type: ignore[arg-type]
+                new_item["absolutePath"] = str(abs_path)
+                new_item["relativePath"] = str(rel_path)
+                ret.append(Location(**new_item))  # type: ignore
+
+            log.debug(f"Found {len(ret)} file references for {relative_file_path}")
+            return ret
+
+        except Exception as e:
+            log.warning(f"Error requesting file references for {relative_file_path}: {e}")
+            return []
+
+    @override
+    def request_references(self, relative_file_path: str, line: int, column: int) -> list[ls_types.Location]:
+        if not self.server_started:
+            log.error("request_references called before Language Server started")
+            raise SolidLSPException("Language Server not started")
+
+        if not self._has_waited_for_cross_file_references:
+            sleep(self._get_wait_time_for_cross_file_referencing())
+            self._has_waited_for_cross_file_references = True
+
+        self._ensure_vue_files_indexed_on_ts_server()
+        symbol_refs = self._send_ts_references_request(relative_file_path, line=line, column=column)
+
+        if relative_file_path.endswith(".vue"):
+            log.info(f"Attempting to find file-level references for Vue component {relative_file_path}")
+            file_refs = self.request_file_references(relative_file_path)
+            log.info(f"file_refs result: {len(file_refs)} references found")
+
+            seen = set()
+            for ref in symbol_refs:
+                key = (ref["uri"], ref["range"]["start"]["line"], ref["range"]["start"]["character"])
+                seen.add(key)
+
+            for file_ref in file_refs:
+                key = (file_ref["uri"], file_ref["range"]["start"]["line"], file_ref["range"]["start"]["character"])
+                if key not in seen:
+                    symbol_refs.append(file_ref)
+                    seen.add(key)
+
+            log.info(f"Total references for {relative_file_path}: {len(symbol_refs)} (symbol refs + file refs, deduplicated)")
+
+        return symbol_refs
+
+    @override
+    def request_definition(self, relative_file_path: str, line: int, column: int) -> list[ls_types.Location]:
+        if not self.server_started:
+            log.error("request_definition called before Language Server started")
+            raise SolidLSPException("Language Server not started")
+
+        assert self._ts_server is not None
+        with self._ts_server.open_file(relative_file_path):
+            return self._ts_server.request_definition(relative_file_path, line, column)
+
+    @override
+    def request_rename_symbol_edit(self, relative_file_path: str, line: int, column: int, new_name: str) -> ls_types.WorkspaceEdit | None:
+        if not self.server_started:
+            log.error("request_rename_symbol_edit called before Language Server started")
+            raise SolidLSPException("Language Server not started")
+
+        assert self._ts_server is not None
+        with self._ts_server.open_file(relative_file_path):
+            return self._ts_server.request_rename_symbol_edit(relative_file_path, line, column, new_name)
+
+    @classmethod
+    def _setup_runtime_dependencies(
+        cls, config: LanguageServerConfig, solidlsp_settings: SolidLSPSettings
+    ) -> tuple[list[str], str, list[str]]:
+        is_node_installed = shutil.which("node") is not None
+        assert is_node_installed, "node is not installed or isn't in PATH. Please install NodeJS and try again."
+        is_npm_installed = shutil.which("npm") is not None
+        assert is_npm_installed, "npm is not installed or isn't in PATH. Please install npm and try again."
+
+        # Get TypeScript version settings from TypeScript language server settings
+        typescript_config = solidlsp_settings.get_ls_specific_settings(Language.TYPESCRIPT)
+        typescript_version = typescript_config.get("typescript_version", "5.9.3")
+        typescript_language_server_version = typescript_config.get("typescript_language_server_version", "5.1.3")
+        vue_config = solidlsp_settings.get_ls_specific_settings(Language.VUE)
+        vue_language_server_version = vue_config.get("vue_language_server_version", "3.1.5")
+
+        deps = RuntimeDependencyCollection(
+            [
+                RuntimeDependency(
+                    id="vue-language-server",
+                    description="Vue language server package (Volar)",
+                    command=["npm", "install", "--prefix", "./", f"@vue/language-server@{vue_language_server_version}"],
+                    platform_id="any",
+                ),
+                RuntimeDependency(
+                    id="typescript",
+                    description="TypeScript (required for tsdk)",
+                    command=["npm", "install", "--prefix", "./", f"typescript@{typescript_version}"],
+                    platform_id="any",
+                ),
+                RuntimeDependency(
+                    id="typescript-language-server",
+                    description="TypeScript language server (for Vue LS 3.x tsserver forwarding)",
+                    command=[
+                        "npm",
+                        "install",
+                        "--prefix",
+                        "./",
+                        f"typescript-language-server@{typescript_language_server_version}",
+                    ],
+                    platform_id="any",
+                ),
+            ]
+        )
+
+        vue_ls_dir = os.path.join(cls.ls_resources_dir(solidlsp_settings), "vue-lsp")
+        vue_executable_path = os.path.join(vue_ls_dir, "node_modules", ".bin", "vue-language-server")
+        ts_ls_executable_path = os.path.join(vue_ls_dir, "node_modules", ".bin", "typescript-language-server")
+
+        if os.name == "nt":
+            vue_executable_path += ".cmd"
+            ts_ls_executable_path += ".cmd"
+
+        tsdk_path = os.path.join(vue_ls_dir, "node_modules", "typescript", "lib")
+
+        # Check if installation is needed based on executables AND version
+        version_file = os.path.join(vue_ls_dir, ".installed_version")
+        expected_version = f"{vue_language_server_version}_{typescript_version}_{typescript_language_server_version}"
+
+        needs_install = False
+        if not os.path.exists(vue_executable_path) or not os.path.exists(ts_ls_executable_path):
+            log.info("Vue/TypeScript Language Server executables not found.")
+            needs_install = True
+        elif os.path.exists(version_file):
+            with open(version_file) as f:
+                installed_version = f.read().strip()
+            if installed_version != expected_version:
+                log.info(
+                    f"Vue Language Server version mismatch: installed={installed_version}, expected={expected_version}. Reinstalling..."
+                )
+                needs_install = True
+        else:
+            # No version file exists, assume old installation needs refresh
+            log.info("Vue Language Server version file not found. Reinstalling to ensure correct version...")
+            needs_install = True
+
+        if needs_install:
+            log.info("Installing Vue/TypeScript Language Server dependencies...")
+            deps.install(vue_ls_dir)
+            # Write version marker file
+            with open(version_file, "w") as f:
+                f.write(expected_version)
+            log.info("Vue language server dependencies installed successfully")
+
+        if not os.path.exists(vue_executable_path):
+            raise FileNotFoundError(
+                f"vue-language-server executable not found at {vue_executable_path}, something went wrong with the installation."
+            )
+
+        if not os.path.exists(ts_ls_executable_path):
+            raise FileNotFoundError(
+                f"typescript-language-server executable not found at {ts_ls_executable_path}, something went wrong with the installation."
+            )
+
+        return [vue_executable_path, "--stdio"], tsdk_path, [ts_ls_executable_path, "--stdio"]
+
+    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+        root_uri = pathlib.Path(repository_absolute_path).as_uri()
+        initialize_params = {
+            "locale": "en",
+            "capabilities": {
+                "textDocument": {
+                    "synchronization": {"didSave": True, "dynamicRegistration": True},
+                    "completion": {"dynamicRegistration": True, "completionItem": {"snippetSupport": True}},
+                    "definition": {"dynamicRegistration": True, "linkSupport": True},
+                    "references": {"dynamicRegistration": True},
+                    "documentSymbol": {
+                        "dynamicRegistration": True,
+                        "hierarchicalDocumentSymbolSupport": True,
+                        "symbolKind": {"valueSet": list(range(1, 27))},
+                    },
+                    "hover": {"dynamicRegistration": True, "contentFormat": ["markdown", "plaintext"]},
+                    "signatureHelp": {"dynamicRegistration": True},
+                    "codeAction": {"dynamicRegistration": True},
+                    "rename": {"dynamicRegistration": True, "prepareSupport": True},
+                },
+                "workspace": {
+                    "workspaceFolders": True,
+                    "didChangeConfiguration": {"dynamicRegistration": True},
+                    "symbol": {"dynamicRegistration": True},
+                },
+            },
+            "processId": os.getpid(),
+            "rootPath": repository_absolute_path,
+            "rootUri": root_uri,
+            "workspaceFolders": [
+                {
+                    "uri": root_uri,
+                    "name": os.path.basename(repository_absolute_path),
+                }
+            ],
+            "initializationOptions": {
+                "vue": {
+                    "hybridMode": True,
+                },
+                "typescript": {
+                    "tsdk": self.tsdk_path,
+                },
+            },
+        }
+        return initialize_params  # type: ignore
+
+    def _start_typescript_server(self) -> None:
+        try:
+            vue_ts_plugin_path = os.path.join(self._vue_ls_dir, "node_modules", "@vue", "typescript-plugin")
+
+            ts_config = LanguageServerConfig(
+                code_language=Language.TYPESCRIPT,
+                trace_lsp_communication=False,
+            )
+
+            log.info("Creating companion VueTypeScriptServer")
+            self._ts_server = VueTypeScriptServer(
+                config=ts_config,
+                repository_root_path=self.repository_root_path,
+                solidlsp_settings=self._solidlsp_settings,
+                vue_plugin_path=vue_ts_plugin_path,
+                tsdk_path=self.tsdk_path,
+                ts_ls_executable_path=self._ts_ls_cmd,
+            )
+
+            log.info("Starting companion TypeScript server")
+            self._ts_server.start()
+
+            log.info("Waiting for companion TypeScript server to be ready...")
+            if not self._ts_server.server_ready.wait(timeout=self.TS_SERVER_READY_TIMEOUT):
+                log.warning(
+                    f"Timeout waiting for companion TypeScript server to be ready after {self.TS_SERVER_READY_TIMEOUT} seconds, proceeding anyway"
+                )
+                self._ts_server.server_ready.set()
+
+            self._ts_server_started = True
+            log.info("Companion TypeScript server ready")
+        except Exception as e:
+            log.error(f"Error starting TypeScript server: {e}")
+            self._ts_server = None
+            self._ts_server_started = False
+            raise
+
+    def _forward_tsserver_request(self, method: str, params: dict) -> Any:
+        if self._ts_server is None:
+            log.error("Cannot forward tsserver request - TypeScript server not started")
+            return None
+
+        try:
+            execute_params: ExecuteCommandParams = {
+                "command": "typescript.tsserverRequest",
+                "arguments": [method, params, {"isAsync": True, "lowPriority": True}],
+            }
+            result = self._ts_server.handler.send.execute_command(execute_params)
+            log.debug(f"TypeScript server raw response for {method}: {result}")
+
+            if isinstance(result, dict) and "body" in result:
+                return result["body"]
+            return result
+        except Exception as e:
+            log.error(f"Error forwarding tsserver request {method}: {e}")
+            return None
+
+    def _cleanup_indexed_vue_files(self) -> None:
+        if not self._indexed_vue_file_uris or self._ts_server is None:
+            return
+
+        log.debug(f"Cleaning up {len(self._indexed_vue_file_uris)} indexed Vue files")
+        for uri in self._indexed_vue_file_uris:
+            try:
+                if uri in self._ts_server.open_file_buffers:
+                    file_buffer = self._ts_server.open_file_buffers[uri]
+                    file_buffer.ref_count -= 1
+
+                    if file_buffer.ref_count == 0:
+                        self._ts_server.server.notify.did_close_text_document({"textDocument": {"uri": uri}})
+                        del self._ts_server.open_file_buffers[uri]
+                        log.debug(f"Closed indexed Vue file: {uri}")
+            except Exception as e:
+                log.debug(f"Error closing indexed Vue file {uri}: {e}")
+
+        self._indexed_vue_file_uris.clear()
+
+    def _stop_typescript_server(self) -> None:
+        if self._ts_server is not None:
+            try:
+                log.info("Stopping companion TypeScript server")
+                self._ts_server.stop()
+            except Exception as e:
+                log.warning(f"Error stopping TypeScript server: {e}")
+            finally:
+                self._ts_server = None
+                self._ts_server_started = False
+
+    @override
+    def _start_server(self) -> None:
+        self._start_typescript_server()
+
+        def register_capability_handler(params: dict) -> None:
+            assert "registrations" in params
+            for registration in params["registrations"]:
+                if registration["method"] == "workspace/executeCommand":
+                    self.initialize_searcher_command_available.set()
+            return
+
+        def configuration_handler(params: dict) -> list:
+            items = params.get("items", [])
+            return [{} for _ in items]
+
+        def do_nothing(params: dict) -> None:
+            return
+
+        def window_log_message(msg: dict) -> None:
+            log.info(f"LSP: window/logMessage: {msg}")
+            message_text = msg.get("message", "")
+            if "initialized" in message_text.lower() or "ready" in message_text.lower():
+                log.info("Vue language server ready signal detected")
+                self.server_ready.set()
+                self.completions_available.set()
+
+        def tsserver_request_notification_handler(params: list) -> None:
+            try:
+                if params and len(params) > 0 and len(params[0]) >= 2:
+                    request_id = params[0][0]
+                    method = params[0][1]
+                    method_params = params[0][2] if len(params[0]) > 2 else {}
+                    log.debug(f"Received tsserver/request: id={request_id}, method={method}")
+
+                    if method == "_vue:projectInfo":
+                        file_path = method_params.get("file", "")
+                        tsconfig_path = self._find_tsconfig_for_file(file_path)
+                        result = {"configFileName": tsconfig_path} if tsconfig_path else None
+                        response = [[request_id, result]]
+                        self.server.notify.send_notification("tsserver/response", response)
+                        log.debug(f"Sent tsserver/response for projectInfo: {tsconfig_path}")
+                    else:
+                        result = self._forward_tsserver_request(method, method_params)
+                        response = [[request_id, result]]
+                        self.server.notify.send_notification("tsserver/response", response)
+                        log.debug(f"Forwarded tsserver/response for {method}: {result}")
+                else:
+                    log.warning(f"Unexpected tsserver/request params format: {params}")
+            except Exception as e:
+                log.error(f"Error handling tsserver/request: {e}")
+
+        self.server.on_request("client/registerCapability", register_capability_handler)
+        self.server.on_request("workspace/configuration", configuration_handler)
+        self.server.on_notification("tsserver/request", tsserver_request_notification_handler)
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_notification("$/progress", do_nothing)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+
+        log.info("Starting Vue server process")
+        self.server.start()
+        initialize_params = self._get_initialize_params(self.repository_root_path)
+
+        log.info("Sending initialize request from LSP client to LSP server and awaiting response")
+        init_response = self.server.send.initialize(initialize_params)
+        log.debug(f"Received initialize response from Vue server: {init_response}")
+
+        assert init_response["capabilities"]["textDocumentSync"] in [1, 2]
+
+        self.server.notify.initialized({})
+
+        log.info("Waiting for Vue language server to be ready...")
+        if not self.server_ready.wait(timeout=self.VUE_SERVER_READY_TIMEOUT):
+            log.info("Timeout waiting for Vue server ready signal, proceeding anyway")
+            self.server_ready.set()
+            self.completions_available.set()
+        else:
+            log.info("Vue server initialization complete")
+
+    def _find_tsconfig_for_file(self, file_path: str) -> str | None:
+        if not file_path:
+            tsconfig_path = os.path.join(self.repository_root_path, "tsconfig.json")
+            return tsconfig_path if os.path.exists(tsconfig_path) else None
+
+        current_dir = os.path.dirname(file_path)
+        repo_root = os.path.abspath(self.repository_root_path)
+
+        while current_dir and current_dir.startswith(repo_root):
+            tsconfig_path = os.path.join(current_dir, "tsconfig.json")
+            if os.path.exists(tsconfig_path):
+                return tsconfig_path
+            parent = os.path.dirname(current_dir)
+            if parent == current_dir:
+                break
+            current_dir = parent
+
+        tsconfig_path = os.path.join(repo_root, "tsconfig.json")
+        return tsconfig_path if os.path.exists(tsconfig_path) else None
+
+    @override
+    def _get_wait_time_for_cross_file_referencing(self) -> float:
+        return 5.0
+
+    @override
+    def stop(self, shutdown_timeout: float = 5.0) -> None:
+        self._cleanup_indexed_vue_files()
+        self._stop_typescript_server()
+        super().stop(shutdown_timeout)
+
+    @override
+    def _get_preferred_definition(self, definitions: list[ls_types.Location]) -> ls_types.Location:
+        return prefer_non_node_modules_definition(definitions)
+
+    @override
+    def _request_document_symbols(
+        self, relative_file_path: str, file_data: LSPFileBuffer | None
+    ) -> list[SymbolInformation] | list[DocumentSymbol] | None:
+        """
+        Override to filter out shorthand property references in Vue files.
+
+        In Vue, when using shorthand syntax in defineExpose like `defineExpose({ pressCount })`,
+        the Vue LSP returns both:
+        - The Variable definition (e.g., `const pressCount = ref(0)`)
+        - A Property symbol for the shorthand reference (e.g., `pressCount` in defineExpose)
+
+        This causes duplicate symbols with the same name, which breaks symbol lookup.
+        We filter out Property symbols that have a matching Variable with the same name
+        at a different location (the definition), keeping only the definition.
+        """
+        symbols = super()._request_document_symbols(relative_file_path, file_data)
+
+        if symbols is None or len(symbols) == 0:
+            return symbols
+
+        # Only process DocumentSymbol format (hierarchical symbols with children)
+        # SymbolInformation format doesn't have the same issue
+        if not isinstance(symbols[0], dict) or "range" not in symbols[0]:
+            return symbols
+
+        return self._filter_shorthand_property_duplicates(symbols)
+
+    def _filter_shorthand_property_duplicates(
+        self, symbols: list[DocumentSymbol] | list[SymbolInformation]
+    ) -> list[DocumentSymbol] | list[SymbolInformation]:
+        """
+        Filter out Property symbols that have a matching Variable symbol with the same name.
+
+        This handles Vue's shorthand property syntax in defineExpose, where the same
+        identifier appears as both a Variable definition and a Property reference.
+        """
+        VARIABLE_KIND = 13  # SymbolKind.Variable
+        PROPERTY_KIND = 7  # SymbolKind.Property
+
+        def filter_symbols(syms: list[dict]) -> list[dict]:
+            # Collect all Variable symbol names with their line numbers
+            variable_names: dict[str, set[int]] = {}
+            for sym in syms:
+                if sym.get("kind") == VARIABLE_KIND:
+                    name = sym.get("name", "")
+                    line = sym.get("range", {}).get("start", {}).get("line", -1)
+                    if name not in variable_names:
+                        variable_names[name] = set()
+                    variable_names[name].add(line)
+
+            # Filter: keep symbols that are either:
+            # 1. Not a Property, or
+            # 2. A Property without a matching Variable name at a different location
+            filtered = []
+            for sym in syms:
+                name = sym.get("name", "")
+                kind = sym.get("kind")
+                line = sym.get("range", {}).get("start", {}).get("line", -1)
+
+                # If it's a Property with a matching Variable name at a DIFFERENT line, skip it
+                if kind == PROPERTY_KIND and name in variable_names:
+                    # Check if there's a Variable definition at a different line
+                    var_lines = variable_names[name]
+                    if any(var_line != line for var_line in var_lines):
+                        # This is a shorthand reference, skip it
+                        log.debug(
+                            f"Filtering shorthand property reference '{name}' at line {line} "
+                            f"(Variable definition exists at line(s) {var_lines})"
+                        )
+                        continue
+
+                # Recursively filter children
+                children = sym.get("children", [])
+                if children:
+                    sym = dict(sym)  # Create a copy to avoid mutating the original
+                    sym["children"] = filter_symbols(children)
+
+                filtered.append(sym)
+
+            return filtered
+
+        return filter_symbols(list(symbols))  # type: ignore

src/solidlsp/ls.py

@@ -463,6 +463,14 @@ class SolidLanguageServer(ABC):
     def _start_server(self) -> None:
         pass
 
+    def _get_language_id_for_file(self, relative_file_path: str) -> str:
+        """Return the language ID for a file.
+
+        Override in subclasses to return file-specific language IDs.
+        Default implementation returns self.language_id.
+        """
+        return self.language_id
+
     @contextmanager
     def open_file(self, relative_file_path: str) -> Iterator[LSPFileBuffer]:
         """
@@ -488,13 +496,14 @@ class SolidLanguageServer(ABC):
             contents = FileUtils.read_file(absolute_file_path, self._encoding)
 
             version = 0
-            self.open_file_buffers[uri] = LSPFileBuffer(uri, contents, version, self.language_id, 1)
+            language_id = self._get_language_id_for_file(relative_file_path)
+            self.open_file_buffers[uri] = LSPFileBuffer(uri, contents, version, language_id, 1)
 
             self.server.notify.did_open_text_document(
                 {
                     LSPConstants.TEXT_DOCUMENT: {  # type: ignore
                         LSPConstants.URI: uri,
-                        LSPConstants.LANGUAGE_ID: self.language_id,
+                        LSPConstants.LANGUAGE_ID: language_id,
                         LSPConstants.VERSION: 0,
                         LSPConstants.TEXT: contents,
                     }
@@ -1630,6 +1639,23 @@ class SolidLanguageServer(ABC):
             include_body=include_body,
         )
 
+    def _get_preferred_definition(self, definitions: list[ls_types.Location]) -> ls_types.Location:
+        """
+        Select the preferred definition from a list of definitions.
+
+        When multiple definitions are returned (e.g., both source and type definitions),
+        this method determines which one to use. The base implementation simply returns
+        the first definition.
+
+        Subclasses can override this method to implement language-specific preferences.
+        For example, TypeScript/Vue servers may prefer source files over .d.ts type
+        definition files.
+
+        :param definitions: A non-empty list of definition locations.
+        :return: The preferred definition location.
+        """
+        return definitions[0]
+
     def request_defining_symbol(
         self,
         relative_file_path: str,
@@ -1658,8 +1684,8 @@ class SolidLanguageServer(ABC):
         if not definitions:
             return None
 
-        # Use the first definition location
-        definition = definitions[0]
+        # Select the preferred definition (subclasses can override _get_preferred_definition)
+        definition = self._get_preferred_definition(definitions)
         def_path = definition["relativePath"]
         assert def_path is not None
         def_line = definition["range"]["start"]["line"]
@@ -1874,5 +1900,14 @@ class SolidLanguageServer(ABC):
     def language_server(self) -> Self:
         return self
 
+    @property
+    def handler(self) -> SolidLanguageServerHandler:
+        """Access the underlying language server handler.
+
+        Useful for advanced operations like sending custom commands
+        or registering notification handlers.
+        """
+        return self.server
+
     def is_running(self) -> bool:
         return self.server.is_running()

src/solidlsp/ls_config.py

@@ -55,11 +55,13 @@ class Language(str, Enum):
     NIX = "nix"
     ERLANG = "erlang"
     AL = "al"
+    FSHARP = "fsharp"
     REGO = "rego"
     SCALA = "scala"
     JULIA = "julia"
     FORTRAN = "fortran"
     HASKELL = "haskell"
+    VUE = "vue"
     # Experimental or deprecated Language Servers
     TYPESCRIPT_VTS = "typescript_vts"
     """Use the typescript language server through the natively bundled vscode extension via https://github.com/yioneko/vtsls"""
@@ -98,6 +100,23 @@ class Language(str, Enum):
     def __str__(self) -> str:
         return self.value
 
+    def get_priority(self) -> int:
+        """
+        :return: priority of the language for breaking ties between languages; higher is more important.
+        """
+        # experimental languages have the lowest priority
+        if self.is_experimental():
+            return 0
+        # We assign lower priority to languages that are supersets of others, such that
+        # the "larger" language is only chosen when it matches more strongly
+        match self:
+            # languages that are supersets of others (Vue is superset of TypeScript/JavaScript)
+            case self.VUE:
+                return 1
+            # regular languages
+            case _:
+                return 2
+
     def get_source_fn_matcher(self) -> FilenameMatcher:
         match self:
             case self.PYTHON | self.PYTHON_JEDI:
@@ -158,6 +177,8 @@ class Language(str, Enum):
                 return FilenameMatcher("*.erl", "*.hrl", "*.escript", "*.config", "*.app", "*.app.src")
             case self.AL:
                 return FilenameMatcher("*.al", "*.dal")
+            case self.FSHARP:
+                return FilenameMatcher("*.fs", "*.fsx", "*.fsi")
             case self.REGO:
                 return FilenameMatcher("*.rego")
             case self.MARKDOWN:
@@ -172,6 +193,13 @@ class Language(str, Enum):
                 )
             case self.HASKELL:
                 return FilenameMatcher("*.hs", "*.lhs")
+            case self.VUE:
+                path_patterns = ["*.vue"]
+                for prefix in ["c", "m", ""]:
+                    for postfix in ["x", ""]:
+                        for base_pattern in ["ts", "js"]:
+                            path_patterns.append(f"*.{prefix}{base_pattern}{postfix}")
+                return FilenameMatcher(*path_patterns)
             case _:
                 raise ValueError(f"Unhandled language: {self}")
 
@@ -213,6 +241,10 @@ class Language(str, Enum):
                 from solidlsp.language_servers.vts_language_server import VtsLanguageServer
 
                 return VtsLanguageServer
+            case self.VUE:
+                from solidlsp.language_servers.vue_language_server import VueLanguageServer
+
+                return VueLanguageServer
             case self.GO:
                 from solidlsp.language_servers.gopls import Gopls
 
@@ -317,6 +349,10 @@ class Language(str, Enum):
                 from solidlsp.language_servers.haskell_language_server import HaskellLanguageServer
 
                 return HaskellLanguageServer
+            case self.FSHARP:
+                from solidlsp.language_servers.fsharp_language_server import FSharpLanguageServer
+
+                return FSharpLanguageServer
             case _:
                 raise ValueError(f"Unhandled language: {self}")
 

test/conftest.py

@@ -7,7 +7,8 @@ import pytest
 from blib2to3.pgen2.parse import contextmanager
 from sensai.util.logging import configure
 
-from serena.constants import SERENA_MANAGED_DIR_IN_HOME, SERENA_MANAGED_DIR_NAME
+from serena.config.serena_config import SerenaPaths
+from serena.constants import SERENA_MANAGED_DIR_NAME
 from serena.project import Project
 from serena.util.file_system import GitignoreParser
 from solidlsp.ls import SolidLanguageServer
@@ -49,7 +50,9 @@ def _create_ls(
     return SolidLanguageServer.create(
         config,
         repo_path,
-        solidlsp_settings=SolidLSPSettings(solidlsp_dir=SERENA_MANAGED_DIR_IN_HOME, project_data_relative_path=SERENA_MANAGED_DIR_NAME),
+        solidlsp_settings=SolidLSPSettings(
+            solidlsp_dir=SerenaPaths().serena_user_home_dir, project_data_relative_path=SERENA_MANAGED_DIR_NAME
+        ),
     )
 
 

test/resources/repos/fsharp/test_repo/.gitignore

@@ -0,0 +1,5 @@
+bin/
+obj/
+*.user
+.vscode/
+.ionide/

test/resources/repos/fsharp/test_repo/Calculator.fs

@@ -0,0 +1,32 @@
+module Calculator
+
+/// Simple calculator functions
+let add a b = a + b
+
+let subtract a b = a - b
+
+let multiply a b = a * b
+
+let divide a b =
+    if b = 0 then
+        failwith "Cannot divide by zero"
+    else
+        (float a) / (float b)
+
+/// More complex operations
+let square x = x * x
+
+let factorial n =
+    if n <= 0 then 1
+    else
+        let rec factorialHelper acc n =
+            if n <= 1 then acc
+            else factorialHelper (acc * n) (n - 1)
+        factorialHelper 1 n
+
+/// Calculator type with instance methods
+type CalculatorClass() =
+    member this.Add(a, b) = add a b
+    member this.Subtract(a, b) = subtract a b
+    member this.Multiply(a, b) = multiply a b
+    member this.Divide(a, b) = divide a b

test/resources/repos/fsharp/test_repo/Models/Person.fs

@@ -0,0 +1,44 @@
+namespace Models
+
+/// Person record type
+type Person = {
+    Name: string
+    Age: int
+    Email: string option
+}
+
+module PersonModule =
+    /// Create a new person
+    let createPerson name age email =
+        { Name = name; Age = age; Email = email }
+    
+    /// Check if person is an adult
+    let isAdult person =
+        person.Age >= 18
+    
+    /// Get display name
+    let getDisplayName person =
+        match person.Email with
+        | Some email -> $"{person.Name} ({email})"
+        | None -> person.Name
+    
+    /// Update person age
+    let updateAge newAge person =
+        { person with Age = newAge }
+
+/// Address type
+type Address = {
+    Street: string
+    City: string
+    ZipCode: string
+    Country: string
+}
+
+/// Employee type that extends Person concept
+type Employee = {
+    Person: Person
+    EmployeeId: int
+    Department: string
+    Salary: decimal
+    Address: Address option
+}

test/resources/repos/fsharp/test_repo/Program.fs

@@ -0,0 +1,37 @@
+module Program
+
+open Calculator
+open Models
+
+[<EntryPoint>]
+let main argv =
+    printfn "Hello, F# World!"
+    
+    // Test calculator functions
+    let result1 = add 5 3
+    printfn "5 + 3 = %d" result1
+    
+    let result2 = subtract 10 4
+    printfn "10 - 4 = %d" result2
+    
+    let result3 = multiply 6 7
+    printfn "6 * 7 = %d" result3
+    
+    let result4 = divide 15 3
+    printfn "15 / 3 = %.2f" result4
+    
+    // Test calculator class
+    let calc = CalculatorClass()
+    let classResult = calc.Add(20, 5)
+    printfn "Calculator class: 20 + 5 = %d" classResult
+    
+    // Test person module
+    let person = PersonModule.createPerson "Alice Smith" 25 (Some "alice@example.com")
+    printfn "Person: %s" (PersonModule.getDisplayName person)
+    printfn "Is adult: %b" (PersonModule.isAdult person)
+    
+    // Test factorial
+    let fact5 = factorial 5
+    printfn "5! = %d" fact5
+    
+    0 // return success

test/resources/repos/fsharp/test_repo/README.md

@@ -0,0 +1,21 @@
+# F# Test Project
+
+This is a test F# project for testing Serena's F# language support.
+
+## Project Structure
+
+- `Program.fs` - Main program entry point
+- `Calculator.fs` - Calculator functions and types
+- `Models/Person.fs` - Person and Employee data models
+
+## Build
+
+```bash
+dotnet build
+```
+
+## Run
+
+```bash
+dotnet run
+```

test/resources/repos/fsharp/test_repo/TestProject.fsproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Calculator.fs" />
+    <Compile Include="Models/Person.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+</Project>

test/resources/repos/java/test_repo/src/main/java/test_repo/Model.java

@@ -10,4 +10,12 @@ public class Model {
     public String getName() {
         return name;
     }
+
+    public String getName(int maxChars) {
+        if (name.length() <= maxChars) {
+            return name;
+        } else {
+            return name.substring(0, maxChars) + "...";
+        }
+    }
 }

test/resources/repos/vue/test_repo/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

test/resources/repos/vue/test_repo/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <link rel="icon" type="image/svg+xml" href="/vite.svg">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Vue Calculator</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

test/resources/repos/vue/test_repo/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "vue-calculator-test-fixture",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Vue 3 + Pinia + TypeScript test fixtures for Serena LSP testing",
+  "dependencies": {
+    "vue": "^3.4.0",
+    "pinia": "^2.1.0"
+  },
+  "devDependencies": {
+    "@vue/language-server": "^2.0.0",
+    "typescript": "~5.5.4"
+  }
+}

test/resources/repos/vue/test_repo/src/App.vue

@@ -0,0 +1,230 @@
+<script setup lang="ts">
+import { ref, computed, watch, watchEffect, onMounted } from 'vue'
+import { useCalculatorStore } from '@/stores/calculator'
+import { useThemeProvider } from '@/composables/useTheme'
+import { useTimeFormatter } from '@/composables/useFormatter'
+import CalculatorInput from '@/components/CalculatorInput.vue'
+import CalculatorDisplay from '@/components/CalculatorDisplay.vue'
+
+// Get the calculator store
+const store = useCalculatorStore()
+
+// Use theme composable with provide/inject - provides theme to all child components
+const themeManager = useThemeProvider()
+
+// Use time formatter composable
+const timeFormatter = useTimeFormatter()
+
+// Local ref for app title
+const appTitle = ref('Vue Calculator')
+
+// Computed property for app version
+const appVersion = computed((): string => {
+  return '1.0.0'
+})
+
+// Computed property for greeting message
+const greetingMessage = computed((): string => {
+  const hour = new Date().getHours()
+  if (hour < 12) return 'Good morning'
+  if (hour < 18) return 'Good afternoon'
+  return 'Good evening'
+})
+
+// Get statistics from store
+const totalCalculations = computed((): number => {
+  return store.history.length
+})
+
+// Check if calculator is active
+const isCalculatorActive = computed((): boolean => {
+  return store.currentValue !== 0 || store.previousValue !== null
+})
+
+// Get last calculation time
+const lastCalculationTime = computed((): string => {
+  if (store.history.length === 0) return 'No calculations yet'
+  const lastEntry = store.history[store.history.length - 1]
+  return timeFormatter.getRelativeTime(lastEntry.timestamp)
+})
+
+// Watch for calculation count changes - demonstrates watchEffect
+watchEffect(() => {
+  document.title = `Calculator (${totalCalculations.value} calculations)`
+})
+
+// Watch for theme changes - demonstrates watch
+watch(
+  () => themeManager.isDarkMode.value,
+  (isDark) => {
+    console.log(`Theme changed to ${isDark ? 'dark' : 'light'} mode`)
+  }
+)
+
+// Lifecycle hook
+onMounted(() => {
+  console.log('App component mounted')
+  console.log(`Initial calculations: ${totalCalculations.value}`)
+})
+
+// Toggle theme method
+const toggleTheme = () => {
+  themeManager.toggleDarkMode()
+}
+
+<template>
+  <div :class="['app', { 'dark-mode': themeManager.isDarkMode }]">
+    <header class="app-header">
+      <h1>{{ appTitle }}</h1>
+      <div class="header-info">
+        <span class="greeting">{{ greetingMessage }}!</span>
+        <span class="version">v{{ appVersion }}</span>
+        <button @click="toggleTheme" class="btn-theme">
+          {{ themeManager.isDarkMode ? '☀️' : '🌙' }}
+        </button>
+      </div>
+    </header>
+
+    <main class="app-main">
+      <div class="calculator-container">
+        <div class="stats-bar">
+          <span>Total Calculations: {{ totalCalculations }}</span>
+          <span :class="{ 'active-indicator': isCalculatorActive }">
+            {{ isCalculatorActive ? 'Active' : 'Idle' }}
+          </span>
+          <span class="last-calc-time">{{ lastCalculationTime }}</span>
+        </div>
+
+        <div class="calculator-grid">
+          <CalculatorInput />
+          <CalculatorDisplay />
+        </div>
+      </div>
+    </main>
+
+    <footer class="app-footer">
+      <p>Built with Vue 3 + Pinia + TypeScript</p>
+    </footer>
+  </div>
+</template>
+
+<style scoped>
+.app {
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  transition: background 0.3s ease;
+}
+
+.app.dark-mode {
+  background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%);
+}
+
+.app-header {
+  padding: 2rem;
+  color: white;
+  text-align: center;
+}
+
+.app-header h1 {
+  margin: 0 0 1rem 0;
+  font-size: 2.5rem;
+}
+
+.header-info {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  gap: 1rem;
+}
+
+.greeting {
+  font-size: 1.1rem;
+}
+
+.version {
+  font-size: 0.9rem;
+  opacity: 0.8;
+}
+
+.btn-theme {
+  background: rgba(255, 255, 255, 0.2);
+  border: none;
+  border-radius: 50%;
+  width: 40px;
+  height: 40px;
+  font-size: 1.2rem;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.btn-theme:hover {
+  background: rgba(255, 255, 255, 0.3);
+}
+
+.app-main {
+  flex: 1;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  padding: 2rem;
+}
+
+.calculator-container {
+  width: 100%;
+  max-width: 1200px;
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.stats-bar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 1rem;
+  padding: 1rem;
+  background: rgba(255, 255, 255, 0.9);
+  border-radius: 8px;
+  font-weight: 500;
+}
+
+.last-calc-time {
+  font-size: 0.9rem;
+  color: #666;
+  font-style: italic;
+}
+
+.active-indicator {
+  color: #4caf50;
+  font-weight: bold;
+}
+
+.active-indicator:not(.active-indicator) {
+  color: #999;
+}
+
+.calculator-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 2rem;
+}
+
+@media (max-width: 768px) {
+  .calculator-grid {
+    grid-template-columns: 1fr;
+  }
+}
+
+.app-footer {
+  padding: 1rem;
+  text-align: center;
+  color: white;
+  opacity: 0.8;
+}
+
+.app-footer p {
+  margin: 0;
+}
+</style>

test/resources/repos/vue/test_repo/src/components/CalculatorButton.vue

@@ -0,0 +1,221 @@
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+
+/**
+ * Props interface for CalculatorButton.
+ * Demonstrates: defineProps with TypeScript interface
+ */
+interface Props {
+  label: string | number
+  variant?: 'digit' | 'operation' | 'equals' | 'clear'
+  disabled?: boolean
+  active?: boolean
+  size?: 'small' | 'medium' | 'large'
+}
+
+/**
+ * Emits interface for CalculatorButton.
+ * Demonstrates: defineEmits with TypeScript
+ */
+interface Emits {
+  click: [value: string | number]
+  hover: [isHovering: boolean]
+  focus: []
+  blur: []
+}
+
+// Define props with defaults
+const props = withDefaults(defineProps<Props>(), {
+  variant: 'digit',
+  disabled: false,
+  active: false,
+  size: 'medium'
+})
+
+// Define emits
+const emit = defineEmits<Emits>()
+
+// Local state
+const isHovered = ref(false)
+const isFocused = ref(false)
+const pressCount = ref(0)
+
+// Computed classes based on props and state
+const buttonClass = computed(() => {
+  const classes = ['calc-button', `calc-button--${props.variant}`, `calc-button--${props.size}`]
+
+  if (props.active) classes.push('calc-button--active')
+  if (props.disabled) classes.push('calc-button--disabled')
+  if (isHovered.value) classes.push('calc-button--hovered')
+  if (isFocused.value) classes.push('calc-button--focused')
+
+  return classes.join(' ')
+})
+
+// Computed aria label for accessibility
+const ariaLabel = computed(() => {
+  const variantText = {
+    digit: 'Number',
+    operation: 'Operation',
+    equals: 'Equals',
+    clear: 'Clear'
+  }[props.variant]
+
+  return `${variantText}: ${props.label}`
+})
+
+// Event handlers that emit events
+const handleClick = () => {
+  if (!props.disabled) {
+    pressCount.value++
+    emit('click', props.label)
+  }
+}
+
+const handleMouseEnter = () => {
+  isHovered.value = true
+  emit('hover', true)
+}
+
+const handleMouseLeave = () => {
+  isHovered.value = false
+  emit('hover', false)
+}
+
+const handleFocus = () => {
+  isFocused.value = true
+  emit('focus')
+}
+
+const handleBlur = () => {
+  isFocused.value = false
+  emit('blur')
+}
+
+// Expose internal state for parent access via template refs
+// Demonstrates: defineExpose
+defineExpose({
+  pressCount,
+  isHovered,
+  isFocused,
+  simulateClick: handleClick
+})
+</script>
+
+<template>
+  <button
+    :class="buttonClass"
+    :disabled="disabled"
+    :aria-label="ariaLabel"
+    @click="handleClick"
+    @mouseenter="handleMouseEnter"
+    @mouseleave="handleMouseLeave"
+    @focus="handleFocus"
+    @blur="handleBlur"
+  >
+    <span class="calc-button__label">{{ label }}</span>
+    <span v-if="pressCount > 0" class="calc-button__badge">{{ pressCount }}</span>
+  </button>
+</template>
+
+<style scoped>
+.calc-button {
+  position: relative;
+  padding: 1rem;
+  font-size: 1.2rem;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  transition: all 0.2s;
+  font-weight: 500;
+}
+
+.calc-button--small {
+  padding: 0.5rem;
+  font-size: 1rem;
+}
+
+.calc-button--medium {
+  padding: 1rem;
+  font-size: 1.2rem;
+}
+
+.calc-button--large {
+  padding: 1.5rem;
+  font-size: 1.5rem;
+}
+
+.calc-button--digit {
+  background: white;
+  color: #333;
+}
+
+.calc-button--digit:hover:not(:disabled) {
+  background: #e0e0e0;
+}
+
+.calc-button--operation {
+  background: #2196f3;
+  color: white;
+}
+
+.calc-button--operation:hover:not(:disabled) {
+  background: #1976d2;
+}
+
+.calc-button--operation.calc-button--active {
+  background: #1565c0;
+}
+
+.calc-button--equals {
+  background: #4caf50;
+  color: white;
+}
+
+.calc-button--equals:hover:not(:disabled) {
+  background: #45a049;
+}
+
+.calc-button--clear {
+  background: #f44336;
+  color: white;
+}
+
+.calc-button--clear:hover:not(:disabled) {
+  background: #da190b;
+}
+
+.calc-button--disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.calc-button--hovered {
+  transform: translateY(-2px);
+  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+}
+
+.calc-button--focused {
+  outline: 2px solid #2196f3;
+  outline-offset: 2px;
+}
+
+.calc-button__label {
+  display: block;
+}
+
+.calc-button__badge {
+  position: absolute;
+  top: -5px;
+  right: -5px;
+  background: #ff5722;
+  color: white;
+  border-radius: 50%;
+  width: 20px;
+  height: 20px;
+  font-size: 0.7rem;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+</style>

test/resources/repos/vue/test_repo/src/components/CalculatorDisplay.vue

@@ -0,0 +1,228 @@
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+import { storeToRefs } from 'pinia'
+import { useCalculatorStore } from '@/stores/calculator'
+import type { HistoryEntry } from '@/types'
+
+// Get the calculator store
+const store = useCalculatorStore()
+
+// Use storeToRefs to get reactive references to store state
+const { recentHistory, hasHistory, currentValue, operation } = storeToRefs(store)
+
+// Local ref for display options
+const showFullHistory = ref(false)
+const maxHistoryItems = ref(5)
+
+// Computed property for filtered history
+const displayedHistory = computed((): HistoryEntry[] => {
+  if (showFullHistory.value) {
+    return recentHistory.value
+  }
+  return recentHistory.value.slice(0, maxHistoryItems.value)
+})
+
+// Format date for display
+const formatDate = (date: Date): string => {
+  return new Date(date).toLocaleTimeString()
+}
+
+// Format the current calculation status
+const currentCalculation = computed((): string => {
+  if (operation.value && store.previousValue !== null) {
+    const opSymbol = {
+      add: '+',
+      subtract: '-',
+      multiply: '×',
+      divide: '÷'
+    }[operation.value]
+    return `${store.previousValue} ${opSymbol} ${currentValue.value}`
+  }
+  return currentValue.value.toString()
+})
+
+// Toggle history view
+const toggleHistoryView = () => {
+  showFullHistory.value = !showFullHistory.value
+}
+
+// Clear history handler
+const clearHistory = () => {
+  store.clearHistory()
+}
+
+// Check if history is empty
+const isHistoryEmpty = computed((): boolean => {
+  return !hasHistory.value
+})
+</script>
+
+<template>
+  <div class="calculator-display">
+    <div class="current-calculation">
+      <h3>Current Calculation</h3>
+      <div class="calculation-value">
+        {{ currentCalculation }}
+      </div>
+    </div>
+
+    <div class="history-section">
+      <div class="history-header">
+        <h3>History</h3>
+        <button
+          v-if="hasHistory"
+          @click="toggleHistoryView"
+          class="btn-toggle"
+        >
+          {{ showFullHistory ? 'Show Less' : 'Show All' }}
+        </button>
+        <button
+          v-if="hasHistory"
+          @click="clearHistory"
+          class="btn-clear-history"
+        >
+          Clear History
+        </button>
+      </div>
+
+      <div v-if="isHistoryEmpty" class="empty-history">
+        No calculations yet
+      </div>
+
+      <div v-else class="history-list">
+        <div
+          v-for="(entry, index) in displayedHistory"
+          :key="`${entry.timestamp}-${index}`"
+          class="history-item"
+        >
+          <span class="expression">{{ entry.expression }}</span>
+          <span class="result">= {{ entry.result }}</span>
+          <span class="timestamp">{{ formatDate(entry.timestamp) }}</span>
+        </div>
+      </div>
+
+      <div v-if="!showFullHistory && recentHistory.length > maxHistoryItems" class="history-count">
+        Showing {{ maxHistoryItems }} of {{ recentHistory.length }} entries
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.calculator-display {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+  padding: 1rem;
+  background: white;
+  border-radius: 8px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.current-calculation {
+  padding: 1rem;
+  background: #e3f2fd;
+  border-radius: 4px;
+}
+
+.current-calculation h3 {
+  margin: 0 0 0.5rem 0;
+  font-size: 1rem;
+  color: #1976d2;
+}
+
+.calculation-value {
+  font-size: 1.5rem;
+  font-weight: bold;
+  color: #333;
+}
+
+.history-section {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.history-header {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.history-header h3 {
+  margin: 0;
+  flex: 1;
+}
+
+.btn-toggle,
+.btn-clear-history {
+  padding: 0.5rem 1rem;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 0.9rem;
+}
+
+.btn-toggle {
+  background: #2196f3;
+  color: white;
+}
+
+.btn-toggle:hover {
+  background: #1976d2;
+}
+
+.btn-clear-history {
+  background: #f44336;
+  color: white;
+}
+
+.btn-clear-history:hover {
+  background: #da190b;
+}
+
+.empty-history {
+  padding: 2rem;
+  text-align: center;
+  color: #999;
+  font-style: italic;
+}
+
+.history-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.history-item {
+  display: grid;
+  grid-template-columns: 2fr 1fr 1fr;
+  gap: 1rem;
+  padding: 0.75rem;
+  background: #f5f5f5;
+  border-radius: 4px;
+  align-items: center;
+}
+
+.expression {
+  font-weight: 500;
+}
+
+.result {
+  font-weight: bold;
+  color: #4caf50;
+}
+
+.timestamp {
+  font-size: 0.8rem;
+  color: #666;
+  text-align: right;
+}
+
+.history-count {
+  text-align: center;
+  font-size: 0.9rem;
+  color: #666;
+  padding: 0.5rem;
+}
+</style>

test/resources/repos/vue/test_repo/src/components/CalculatorInput.vue

@@ -0,0 +1,300 @@
+<script setup lang="ts">
+import { ref, computed, watch, onMounted, onBeforeUnmount } from 'vue'
+import { useCalculatorStore } from '@/stores/calculator'
+import { useFormatter } from '@/composables/useFormatter'
+import CalculatorButton from './CalculatorButton.vue'
+import type { Operation } from '@/types'
+
+// Get the calculator store
+const store = useCalculatorStore()
+
+// Use composable for formatting
+const formatter = useFormatter(2)
+
+// Local refs for component state
+const isOperationPending = ref(false)
+const lastOperation = ref<Operation>(null)
+const keyboardEnabled = ref(true)
+const operationHistory = ref<string[]>([])
+
+// Template refs - demonstrates template ref pattern
+const displayRef = ref<HTMLDivElement | null>(null)
+const equalsButtonRef = ref<InstanceType<typeof CalculatorButton> | null>(null)
+
+// Computed property for button styling
+const getOperationClass = computed(() => (op: Operation) => {
+  return lastOperation.value === op ? 'active' : ''
+})
+
+// Computed formatted display value using composable
+const formattedDisplay = computed(() => {
+  const value = parseFloat(store.display)
+  return isNaN(value) ? store.display : formatter.formatNumber(value)
+})
+
+// Watch for operation changes - demonstrates watch
+watch(lastOperation, (newOp, oldOp) => {
+  if (newOp !== oldOp && newOp) {
+    operationHistory.value.push(newOp)
+    // Keep only last 10 operations
+    if (operationHistory.value.length > 10) {
+      operationHistory.value.shift()
+    }
+  }
+})
+
+// Watch store display changes - demonstrates watch with callback
+watch(
+  () => store.display,
+  (newDisplay) => {
+    if (displayRef.value) {
+      // Trigger animation on display change
+      displayRef.value.classList.add('display-updated')
+      setTimeout(() => {
+        displayRef.value?.classList.remove('display-updated')
+      }, 300)
+    }
+  }
+)
+
+// Lifecycle hook - demonstrates onMounted
+onMounted(() => {
+  console.log('CalculatorInput mounted')
+  // Add keyboard event listener
+  window.addEventListener('keydown', handleKeyboard)
+
+  // Focus on the display element
+  if (displayRef.value) {
+    displayRef.value.focus()
+  }
+})
+
+// Lifecycle hook - demonstrates onBeforeUnmount
+onBeforeUnmount(() => {
+  console.log('CalculatorInput unmounting')
+  // Clean up keyboard event listener
+  window.removeEventListener('keydown', handleKeyboard)
+})
+
+// Handle number button clicks
+const handleDigit = (digit: number) => {
+  store.appendDigit(digit)
+  isOperationPending.value = false
+}
+
+// Handle operation button clicks
+const handleOperation = (operation: Operation) => {
+  isOperationPending.value = true
+  lastOperation.value = operation
+
+  switch (operation) {
+    case 'add':
+      store.add()
+      break
+    case 'subtract':
+      store.subtract()
+      break
+    case 'multiply':
+      store.multiply()
+      break
+    case 'divide':
+      store.divide()
+      break
+  }
+}
+
+// Handle equals button
+const handleEquals = () => {
+  store.equals()
+  isOperationPending.value = false
+  lastOperation.value = null
+
+  // Access exposed method from child component
+  if (equalsButtonRef.value) {
+    console.log('Equals button press count:', equalsButtonRef.value.pressCount)
+  }
+}
+
+// Handle clear button
+const handleClear = () => {
+  store.clear()
+  isOperationPending.value = false
+  lastOperation.value = null
+  operationHistory.value = []
+}
+
+// Keyboard handler - demonstrates event handling
+const handleKeyboard = (event: KeyboardEvent) => {
+  if (!keyboardEnabled.value) return
+
+  const key = event.key
+
+  if (key >= '0' && key <= '9') {
+    handleDigit(parseInt(key))
+  } else if (key === '+') {
+    handleOperation('add')
+  } else if (key === '-') {
+    handleOperation('subtract')
+  } else if (key === '*') {
+    handleOperation('multiply')
+  } else if (key === '/') {
+    event.preventDefault()
+    handleOperation('divide')
+  } else if (key === 'Enter' || key === '=') {
+    handleEquals()
+  } else if (key === 'Escape' || key === 'c' || key === 'C') {
+    handleClear()
+  }
+}
+
+// Toggle keyboard input
+const toggleKeyboard = () => {
+  keyboardEnabled.value = !keyboardEnabled.value
+}
+
+// Array of digits for rendering
+const digits = [7, 8, 9, 4, 5, 6, 1, 2, 3, 0]
+</script>
+
+<template>
+  <div class="calculator-input">
+    <div ref="displayRef" class="display" tabindex="0">
+      {{ formattedDisplay }}
+    </div>
+
+    <div class="keyboard-toggle">
+      <label>
+        <input type="checkbox" v-model="keyboardEnabled" @change="toggleKeyboard" />
+        Enable Keyboard Input
+      </label>
+    </div>
+
+    <div class="buttons">
+      <CalculatorButton
+        v-for="digit in digits"
+        :key="digit"
+        :label="digit"
+        variant="digit"
+        @click="handleDigit"
+      />
+
+      <CalculatorButton
+        label="+"
+        variant="operation"
+        :active="lastOperation === 'add'"
+        @click="() => handleOperation('add')"
+      />
+
+      <CalculatorButton
+        label="-"
+        variant="operation"
+        :active="lastOperation === 'subtract'"
+        @click="() => handleOperation('subtract')"
+      />
+
+      <CalculatorButton
+        label="×"
+        variant="operation"
+        :active="lastOperation === 'multiply'"
+        @click="() => handleOperation('multiply')"
+      />
+
+      <CalculatorButton
+        label="÷"
+        variant="operation"
+        :active="lastOperation === 'divide'"
+        @click="() => handleOperation('divide')"
+      />
+
+      <CalculatorButton
+        ref="equalsButtonRef"
+        label="="
+        variant="equals"
+        size="large"
+        @click="handleEquals"
+      />
+
+      <CalculatorButton
+        label="C"
+        variant="clear"
+        @click="handleClear"
+      />
+    </div>
+
+    <div v-if="isOperationPending" class="pending-indicator">
+      Operation pending: {{ lastOperation }}
+    </div>
+
+    <div v-if="operationHistory.length > 0" class="operation-history">
+      Recent operations: {{ operationHistory.join(', ') }}
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.calculator-input {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  padding: 1rem;
+  background: #f5f5f5;
+  border-radius: 8px;
+}
+
+.display {
+  font-size: 2rem;
+  text-align: right;
+  padding: 1rem;
+  background: white;
+  border-radius: 4px;
+  min-height: 3rem;
+  transition: background-color 0.3s;
+  outline: none;
+}
+
+.display:focus {
+  box-shadow: 0 0 0 2px #2196f3;
+}
+
+.display.display-updated {
+  background-color: #e3f2fd;
+}
+
+.keyboard-toggle {
+  display: flex;
+  justify-content: center;
+  padding: 0.5rem;
+}
+
+.keyboard-toggle label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  cursor: pointer;
+  font-size: 0.9rem;
+}
+
+.buttons {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: 0.5rem;
+}
+
+.pending-indicator {
+  font-size: 0.9rem;
+  color: #666;
+  text-align: center;
+  font-style: italic;
+}
+
+.operation-history {
+  font-size: 0.8rem;
+  color: #999;
+  text-align: center;
+  padding: 0.5rem;
+  background: white;
+  border-radius: 4px;
+  max-height: 3rem;
+  overflow: auto;
+}
+</style>

test/resources/repos/vue/test_repo/src/composables/useFormatter.ts

@@ -0,0 +1,126 @@
+import { ref, computed } from 'vue'
+import type { Ref, ComputedRef } from 'vue'
+import type { FormatOptions } from '@/types'
+
+/**
+ * Composable for formatting numbers with various options.
+ * Demonstrates: composable pattern, refs, computed, type imports
+ */
+export function useFormatter(initialPrecision: number = 2) {
+  // State
+  const precision = ref<number>(initialPrecision)
+  const useGrouping = ref<boolean>(true)
+  const locale = ref<string>('en-US')
+
+  // Computed properties
+  const formatOptions = computed((): FormatOptions => ({
+    maxDecimals: precision.value,
+    useGrouping: useGrouping.value
+  }))
+
+  // Methods
+  const formatNumber = (value: number): string => {
+    return value.toLocaleString(locale.value, {
+      minimumFractionDigits: precision.value,
+      maximumFractionDigits: precision.value,
+      useGrouping: useGrouping.value
+    })
+  }
+
+  const formatCurrency = (value: number, currency: string = 'USD'): string => {
+    return value.toLocaleString(locale.value, {
+      style: 'currency',
+      currency,
+      minimumFractionDigits: precision.value,
+      maximumFractionDigits: precision.value
+    })
+  }
+
+  const formatPercentage = (value: number): string => {
+    return `${(value * 100).toFixed(precision.value)}%`
+  }
+
+  const setPrecision = (newPrecision: number): void => {
+    if (newPrecision >= 0 && newPrecision <= 10) {
+      precision.value = newPrecision
+    }
+  }
+
+  const toggleGrouping = (): void => {
+    useGrouping.value = !useGrouping.value
+  }
+
+  const setLocale = (newLocale: string): void => {
+    locale.value = newLocale
+  }
+
+  // Return composable API
+  return {
+    // State (readonly)
+    precision: computed(() => precision.value),
+    useGrouping: computed(() => useGrouping.value),
+    locale: computed(() => locale.value),
+    formatOptions,
+
+    // Methods
+    formatNumber,
+    formatCurrency,
+    formatPercentage,
+    setPrecision,
+    toggleGrouping,
+    setLocale
+  }
+}
+
+/**
+ * Composable for time formatting.
+ * Demonstrates: simpler composable, pure functions
+ */
+export function useTimeFormatter() {
+  const formatTime = (date: Date): string => {
+    return date.toLocaleTimeString('en-US', {
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit'
+    })
+  }
+
+  const formatDate = (date: Date): string => {
+    return date.toLocaleDateString('en-US', {
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric'
+    })
+  }
+
+  const formatDateTime = (date: Date): string => {
+    return `${formatDate(date)} ${formatTime(date)}`
+  }
+
+  const getRelativeTime = (date: Date): string => {
+    const now = new Date()
+    const diffMs = now.getTime() - date.getTime()
+    const diffSecs = Math.floor(diffMs / 1000)
+    const diffMins = Math.floor(diffSecs / 60)
+    const diffHours = Math.floor(diffMins / 60)
+    const diffDays = Math.floor(diffHours / 24)
+
+    if (diffSecs < 60) return 'just now'
+    if (diffMins < 60) return `${diffMins} minute${diffMins > 1 ? 's' : ''} ago`
+    if (diffHours < 24) return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`
+    return `${diffDays} day${diffDays > 1 ? 's' : ''} ago`
+  }
+
+  return {
+    formatTime,
+    formatDate,
+    formatDateTime,
+    getRelativeTime
+  }
+}
+
+/**
+ * Type definitions for return types
+ */
+export type UseFormatterReturn = ReturnType<typeof useFormatter>
+export type UseTimeFormatterReturn = ReturnType<typeof useTimeFormatter>

test/resources/repos/vue/test_repo/src/composables/useTheme.ts

@@ -0,0 +1,113 @@
+import { ref, computed, watch, inject, provide, type InjectionKey, type Ref } from 'vue'
+
+/**
+ * Theme configuration type
+ */
+export interface ThemeConfig {
+  isDark: boolean
+  primaryColor: string
+  fontSize: number
+}
+
+/**
+ * Injection key for theme - demonstrates provide/inject pattern
+ */
+export const ThemeKey: InjectionKey<Ref<ThemeConfig>> = Symbol('theme')
+
+/**
+ * Composable for theme management with watchers.
+ * Demonstrates: watch, provide/inject, localStorage interaction
+ */
+export function useThemeProvider() {
+  // Initialize theme from localStorage or defaults
+  const loadThemeFromStorage = (): ThemeConfig => {
+    const stored = localStorage.getItem('app-theme')
+    if (stored) {
+      try {
+        return JSON.parse(stored)
+      } catch {
+        // Fall through to defaults
+      }
+    }
+    return {
+      isDark: false,
+      primaryColor: '#667eea',
+      fontSize: 16
+    }
+  }
+
+  const theme = ref<ThemeConfig>(loadThemeFromStorage())
+
+  // Computed properties
+  const isDarkMode = computed(() => theme.value.isDark)
+  const themeClass = computed(() => theme.value.isDark ? 'dark-theme' : 'light-theme')
+
+  // Watch for theme changes and persist to localStorage
+  watch(
+    theme,
+    (newTheme) => {
+      localStorage.setItem('app-theme', JSON.stringify(newTheme))
+      document.documentElement.className = newTheme.isDark ? 'dark' : 'light'
+    },
+    { deep: true }
+  )
+
+  // Methods
+  const toggleDarkMode = (): void => {
+    theme.value.isDark = !theme.value.isDark
+  }
+
+  const setPrimaryColor = (color: string): void => {
+    theme.value.primaryColor = color
+  }
+
+  const setFontSize = (size: number): void => {
+    if (size >= 12 && size <= 24) {
+      theme.value.fontSize = size
+    }
+  }
+
+  const resetTheme = (): void => {
+    theme.value = {
+      isDark: false,
+      primaryColor: '#667eea',
+      fontSize: 16
+    }
+  }
+
+  // Provide theme to child components
+  provide(ThemeKey, theme)
+
+  return {
+    theme,
+    isDarkMode,
+    themeClass,
+    toggleDarkMode,
+    setPrimaryColor,
+    setFontSize,
+    resetTheme
+  }
+}
+
+/**
+ * Composable for consuming theme in child components.
+ * Demonstrates: inject pattern
+ */
+export function useTheme() {
+  const theme = inject(ThemeKey)
+
+  if (!theme) {
+    throw new Error('useTheme must be used within a component that provides ThemeKey')
+  }
+
+  const isDark = computed(() => theme.value.isDark)
+  const primaryColor = computed(() => theme.value.primaryColor)
+  const fontSize = computed(() => theme.value.fontSize)
+
+  return {
+    theme,
+    isDark,
+    primaryColor,
+    fontSize
+  }
+}

test/resources/repos/vue/test_repo/src/main.ts

@@ -0,0 +1,9 @@
+import { createApp } from 'vue'
+import { createPinia } from 'pinia'
+import App from './App.vue'
+
+const app = createApp(App)
+const pinia = createPinia()
+
+app.use(pinia)
+app.mount('#app')

test/resources/repos/vue/test_repo/src/stores/calculator.ts

@@ -0,0 +1,179 @@
+import { defineStore } from 'pinia'
+import type { HistoryEntry, Operation, CalculatorState } from '@/types'
+
+export const useCalculatorStore = defineStore('calculator', {
+  state: (): CalculatorState => ({
+    currentValue: 0,
+    previousValue: null,
+    operation: null,
+    history: [],
+    displayValue: '0'
+  }),
+
+  getters: {
+    /**
+     * Get the most recent history entries (last 10)
+     */
+    recentHistory: (state): HistoryEntry[] => {
+      return state.history.slice(-10).reverse()
+    },
+
+    /**
+     * Check if calculator has any history
+     */
+    hasHistory: (state): boolean => {
+      return state.history.length > 0
+    },
+
+    /**
+     * Get the current display text
+     */
+    display: (state): string => {
+      return state.displayValue
+    }
+  },
+
+  actions: {
+    /**
+     * Set a number value
+     */
+    setNumber(value: number) {
+      this.currentValue = value
+      this.displayValue = value.toString()
+    },
+
+    /**
+     * Append a digit to the current value
+     */
+    appendDigit(digit: number) {
+      if (this.displayValue === '0') {
+        this.displayValue = digit.toString()
+      } else {
+        this.displayValue += digit.toString()
+      }
+      this.currentValue = parseFloat(this.displayValue)
+    },
+
+    /**
+     * Add two numbers
+     */
+    add() {
+      if (this.previousValue !== null && this.operation) {
+        this.executeOperation()
+      }
+      this.previousValue = this.currentValue
+      this.operation = 'add'
+      this.displayValue = '0'
+    },
+
+    /**
+     * Subtract two numbers
+     */
+    subtract() {
+      if (this.previousValue !== null && this.operation) {
+        this.executeOperation()
+      }
+      this.previousValue = this.currentValue
+      this.operation = 'subtract'
+      this.displayValue = '0'
+    },
+
+    /**
+     * Multiply two numbers
+     */
+    multiply() {
+      if (this.previousValue !== null && this.operation) {
+        this.executeOperation()
+      }
+      this.previousValue = this.currentValue
+      this.operation = 'multiply'
+      this.displayValue = '0'
+    },
+
+    /**
+     * Divide two numbers
+     */
+    divide() {
+      if (this.previousValue !== null && this.operation) {
+        this.executeOperation()
+      }
+      this.previousValue = this.currentValue
+      this.operation = 'divide'
+      this.displayValue = '0'
+    },
+
+    /**
+     * Execute the pending operation
+     */
+    executeOperation() {
+      if (this.previousValue === null || this.operation === null) {
+        return
+      }
+
+      let result = 0
+      const prev = this.previousValue
+      const current = this.currentValue
+      let expression = ''
+
+      switch (this.operation) {
+        case 'add':
+          result = prev + current
+          expression = `${prev} + ${current}`
+          break
+        case 'subtract':
+          result = prev - current
+          expression = `${prev} - ${current}`
+          break
+        case 'multiply':
+          result = prev * current
+          expression = `${prev} × ${current}`
+          break
+        case 'divide':
+          if (current === 0) {
+            this.displayValue = 'Error'
+            this.clear()
+            return
+          }
+          result = prev / current
+          expression = `${prev} ÷ ${current}`
+          break
+      }
+
+      // Add to history
+      this.history.push({
+        expression,
+        result,
+        timestamp: new Date()
+      })
+
+      this.currentValue = result
+      this.displayValue = result.toString()
+      this.previousValue = null
+      this.operation = null
+    },
+
+    /**
+     * Calculate the equals operation
+     */
+    equals() {
+      this.executeOperation()
+    },
+
+    /**
+     * Clear the calculator state
+     */
+    clear() {
+      this.currentValue = 0
+      this.previousValue = null
+      this.operation = null
+      this.displayValue = '0'
+    },
+
+    /**
+     * Clear all history
+     */
+    clearHistory() {
+      this.history = []
+    }
+  }
+})

test/resources/repos/vue/test_repo/src/types/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Represents a single calculation in the history
+ */
+export interface HistoryEntry {
+  expression: string
+  result: number
+  timestamp: Date
+}
+
+/**
+ * Valid calculator operations
+ */
+export type Operation = 'add' | 'subtract' | 'multiply' | 'divide' | null
+
+/**
+ * The complete state of the calculator
+ */
+export interface CalculatorState {
+  currentValue: number
+  previousValue: number | null
+  operation: Operation
+  history: HistoryEntry[]
+  displayValue: string
+}
+
+/**
+ * Format options for displaying numbers
+ */
+export interface FormatOptions {
+  maxDecimals?: number
+  useGrouping?: boolean
+}

test/resources/repos/vue/test_repo/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "preserve",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "plugins": [
+    {
+      "name": "@vue/typescript-plugin"
+    }
+  ],
+  "include": ["src/**/*.ts", "src/**/*.vue"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

test/resources/repos/vue/test_repo/tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "include": ["vite.config.ts"]
+}

test/resources/repos/vue/test_repo/vite.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { fileURLToPath, URL } from 'node:url'
+
+export default defineConfig({
+  plugins: [vue()],
+  resolve: {
+    alias: {
+      '@': fileURLToPath(new URL('./src', import.meta.url))
+    }
+  }
+})

test/serena/config/test_serena_config.py

@@ -43,6 +43,16 @@ class TestProjectConfigAutogenerate:
         assert config.project_name == self.project_path.name
         assert config.languages == [Language.PYTHON]
 
+    def test_autogenerate_with_js_files(self):
+        """Test successful autogeneration with JavaScript source files."""
+        # Create files for multiple languages
+        (self.project_path / "small.js").write_text("console.log('JS');")
+
+        # Run autogenerate - should pick Python as dominant
+        config = ProjectConfig.autogenerate(self.project_path, save_to_disk=False)
+
+        assert config.languages == [Language.TYPESCRIPT]
+
     def test_autogenerate_with_multiple_languages(self):
         """Test autogeneration picks dominant language when multiple are present."""
         # Create files for multiple languages

test/serena/test_serena_agent.py

@@ -9,7 +9,7 @@ import pytest
 from serena.agent import SerenaAgent
 from serena.config.serena_config import ProjectConfig, RegisteredProject, SerenaConfig
 from serena.project import Project
-from serena.tools import FindReferencingSymbolsTool, FindSymbolTool
+from serena.tools import FindReferencingSymbolsTool, FindSymbolTool, ReplaceSymbolBodyTool
 from solidlsp.ls_config import Language
 from test.conftest import get_repo_path, language_tests_enabled
 from test.solidlsp import clojure as clj
@@ -30,6 +30,7 @@ def serena_config():
         Language.PHP,
         Language.CSHARP,
         Language.CLOJURE,
+        Language.FSHARP,
     ]:
         repo_path = get_repo_path(language)
         if repo_path.exists():
@@ -63,6 +64,10 @@ def serena_agent(request: pytest.FixtureRequest, serena_config) -> Iterator[Sere
     project_name = f"test_repo_{language}"
 
     agent = SerenaAgent(project=project_name, serena_config=serena_config)
+
+    # wait for agent to be ready
+    agent.execute_task(lambda: None)
+
     yield agent
     # explicitly delete to free resources
     agent.shutdown(timeout=5)
@@ -81,6 +86,7 @@ class TestSerenaAgent:
             pytest.param(Language.PHP, "helperFunction", "Function", "helper.php", marks=pytest.mark.php),
             pytest.param(Language.CLOJURE, "greet", "Function", clj.CORE_PATH, marks=pytest.mark.clojure),
             pytest.param(Language.CSHARP, "Calculator", "Class", "Program.cs", marks=pytest.mark.csharp),
+            pytest.param(Language.FSHARP, "Calculator", "Module", "Calculator.fs", marks=pytest.mark.fsharp),
         ],
         indirect=["serena_agent"],
     )
@@ -131,6 +137,7 @@ class TestSerenaAgent:
                 marks=pytest.mark.clojure,
             ),
             pytest.param(Language.CSHARP, "Calculator", "Program.cs", "Program.cs", marks=pytest.mark.csharp),
+            pytest.param(Language.FSHARP, "add", "Calculator.fs", "Program.fs", marks=pytest.mark.fsharp),
         ],
         indirect=["serena_agent"],
     )
@@ -285,3 +292,63 @@ class TestSerenaAgent:
 
         symbols = json.loads(result)
         assert not symbols, f"Expected to find no symbols for {name_path}. Symbols found: {symbols}"
+
+    @pytest.mark.parametrize(
+        "serena_agent,name_path,num_expected",
+        [
+            pytest.param(
+                Language.JAVA,
+                "Model/getName",
+                2,
+                id="overloaded_java_method",
+                marks=pytest.mark.java,
+            ),
+        ],
+        indirect=["serena_agent"],
+    )
+    def test_find_symbol_overloaded_function(self, serena_agent: SerenaAgent, name_path: str, num_expected: int):
+        """
+        Tests whether the FindSymbolTool can find all overloads of a function/method
+        (provided that the overload id remains unspecified in the name path)
+        """
+        agent = serena_agent
+
+        find_symbol_tool = agent.get_tool(FindSymbolTool)
+        result = find_symbol_tool.apply_ex(
+            name_path_pattern=name_path,
+            depth=0,
+            substring_matching=False,
+        )
+
+        symbols = json.loads(result)
+        assert (
+            len(symbols) == num_expected
+        ), f"Expected to find {num_expected} symbols for overloaded function {name_path}. Symbols found: {symbols}"
+
+    @pytest.mark.parametrize(
+        "serena_agent,name_path,relative_path",
+        [
+            pytest.param(
+                Language.JAVA,
+                "Model/getName",
+                os.path.join("src", "main", "java", "test_repo", "Model.java"),
+                id="overloaded_java_method",
+                marks=pytest.mark.java,
+            ),
+        ],
+        indirect=["serena_agent"],
+    )
+    def test_non_unique_symbol_reference_error(self, serena_agent: SerenaAgent, name_path: str, relative_path: str):
+        """
+        Tests whether the tools operating on a well-defined symbol raises an error when the symbol reference is non-unique.
+        We exemplarily test a retrieval tool (FindReferencingSymbolsTool) and an editing tool (ReplaceSymbolBodyTool).
+        """
+        match_text = "multiple"
+
+        find_refs_tool = serena_agent.get_tool(FindReferencingSymbolsTool)
+        with pytest.raises(ValueError, match=match_text):
+            find_refs_tool.apply(name_path=name_path, relative_path=relative_path)
+
+        replace_symbol_body_tool = serena_agent.get_tool(ReplaceSymbolBodyTool)
+        with pytest.raises(ValueError, match=match_text):
+            replace_symbol_body_tool.apply(name_path=name_path, relative_path=relative_path, body="")

test/serena/test_symbol_editing.py

@@ -509,3 +509,142 @@ def test_rename_symbol(snapshot: SnapshotAssertion):
         "renamed_typed_module_var",
     )
     test_case.run_test(content_after_ground_truth=snapshot)
+
+
+# ===== VUE WRITE OPERATIONS TESTS =====
+
+VUE_TEST_FILE = os.path.join("src", "components", "CalculatorButton.vue")
+VUE_STORE_FILE = os.path.join("src", "stores", "calculator.ts")
+
+NEW_VUE_HANDLER = """const handleDoubleClick = () => {
+    pressCount.value++;
+    emit('click', props.label);
+}"""
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        pytest.param(
+            DeleteSymbolTest(
+                Language.VUE,
+                VUE_TEST_FILE,
+                "handleMouseEnter",
+            ),
+            marks=pytest.mark.vue,
+        ),
+    ],
+)
+def test_delete_symbol_vue(test_case: DeleteSymbolTest, snapshot: SnapshotAssertion) -> None:
+    test_case.run_test(content_after_ground_truth=snapshot)
+
+
+@pytest.mark.parametrize("mode", ["before", "after"])
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        pytest.param(
+            InsertInRelToSymbolTest(
+                Language.VUE,
+                VUE_TEST_FILE,
+                "handleClick",
+                NEW_VUE_HANDLER,
+            ),
+            marks=pytest.mark.vue,
+        ),
+    ],
+)
+def test_insert_in_rel_to_symbol_vue(
+    test_case: InsertInRelToSymbolTest,
+    mode: Literal["before", "after"],
+    snapshot: SnapshotAssertion,
+) -> None:
+    test_case.set_mode(mode)
+    test_case.run_test(content_after_ground_truth=snapshot)
+
+
+VUE_REPLACED_HANDLECLICK_BODY = """const handleClick = () => {
+    if (!props.disabled) {
+        pressCount.value = 0;  // Reset instead of incrementing
+        emit('click', props.label);
+    }
+}"""
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        pytest.param(
+            ReplaceBodyTest(
+                Language.VUE,
+                VUE_TEST_FILE,
+                "handleClick",
+                VUE_REPLACED_HANDLECLICK_BODY,
+            ),
+            marks=pytest.mark.vue,
+        ),
+    ],
+)
+def test_replace_body_vue(test_case: ReplaceBodyTest, snapshot: SnapshotAssertion) -> None:
+    test_case.run_test(content_after_ground_truth=snapshot)
+
+
+VUE_REPLACED_PRESSCOUNT_BODY = """const pressCount = ref(100)"""
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        pytest.param(
+            ReplaceBodyTest(
+                Language.VUE,
+                VUE_TEST_FILE,
+                "pressCount",
+                VUE_REPLACED_PRESSCOUNT_BODY,
+            ),
+            marks=pytest.mark.vue,
+        ),
+    ],
+)
+def test_replace_body_vue_with_disambiguation(test_case: ReplaceBodyTest, snapshot: SnapshotAssertion) -> None:
+    """Test symbol disambiguation when replacing body in Vue files.
+
+    This test verifies the fix for the Vue LSP symbol duplication issue.
+    When the LSP returns two symbols with the same name (e.g., pressCount appears both as
+    a definition `const pressCount = ref(0)` and as a shorthand property in `defineExpose({ pressCount })`),
+    the _find_unique_symbol method should prefer the symbol with the larger range (the definition).
+
+    The test exercises this by calling replace_body on 'pressCount', which internally calls
+    _find_unique_symbol and should correctly select the definition (line 40, 19 chars) over
+    the reference (line 97, 10 chars).
+    """
+    test_case.run_test(content_after_ground_truth=snapshot)
+
+
+VUE_STORE_REPLACED_CLEAR_BODY = """function clear() {
+    // Modified: Reset to initial state with a log
+    console.log('Clearing calculator state');
+    displayValue.value = '0';
+    expression.value = '';
+    operationHistory.value = [];
+    lastResult.value = undefined;
+}"""
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        pytest.param(
+            ReplaceBodyTest(
+                Language.VUE,
+                VUE_STORE_FILE,
+                "clear",
+                VUE_STORE_REPLACED_CLEAR_BODY,
+            ),
+            marks=pytest.mark.vue,
+        ),
+    ],
+)
+def test_replace_body_vue_ts_file(test_case: ReplaceBodyTest, snapshot: SnapshotAssertion) -> None:
+    """Test that TypeScript files within Vue projects can be edited."""
+    test_case.run_test(content_after_ground_truth=snapshot)

test/solidlsp/csharp/test_csharp_basic.py

@@ -119,13 +119,9 @@ class TestCSharpLanguageServer:
 
         # Check that we have references from both files
         assert any("Program.cs" in ref_file for ref_file in ref_files), "Should find reference in Program.cs"
-        # TODO: The assertion below fails randomly. Try to fix this. GitHub issue #814
-        #   In CI, it sometimes passed; on my local machine (opcode81), it seems to fail consistently.
-        """
         assert any(
             os.path.join("Models", "Person.cs") in ref_file for ref_file in ref_files
         ), "Should find reference in Models/Person.cs where Calculator.Subtract is called"
-        """
 
         # check for a second time, since the first call may trigger initialization and change the state of the LS
         refs_second_call = language_server.request_references(file_path, sel_start["line"], sel_start["character"] + 1)

test/solidlsp/fsharp/test_fsharp_basic.py

@@ -0,0 +1,219 @@
+import os
+import tempfile
+import threading
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.language_servers.fsharp_language_server import FSharpLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_utils import SymbolUtils
+
+
+@pytest.mark.fsharp
+class TestFSharpLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
+        """Test finding symbols in the full symbol tree."""
+        symbols = language_server.request_full_symbol_tree()
+
+        # Check for main program module symbols
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Program"), "Program module not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "main"), "main function not found in symbol tree"
+
+        # Check for Calculator module symbols
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "Calculator"), "Calculator module not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "add"), "add function not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "CalculatorClass"), "CalculatorClass not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_get_document_symbols_program(self, language_server: SolidLanguageServer) -> None:
+        """Test getting document symbols from the main Program.fs file."""
+        file_path = os.path.join("Program.fs")
+        symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()[0]
+
+        # Look for expected functions and modules
+        symbol_names = [s.get("name") for s in symbols]
+        assert "main" in symbol_names, "main function not found in Program.fs symbols"
+
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_get_document_symbols_calculator(self, language_server: SolidLanguageServer) -> None:
+        """Test getting document symbols from Calculator.fs file."""
+        file_path = os.path.join("Calculator.fs")
+        symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()[0]
+
+        # Look for expected functions
+        symbol_names = [s.get("name") for s in symbols]
+        expected_symbols = ["add", "subtract", "multiply", "divide", "square", "factorial", "CalculatorClass"]
+
+        for expected in expected_symbols:
+            assert expected in symbol_names, f"{expected} function not found in Calculator.fs symbols"
+
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        """Test finding references using symbol selection range."""
+        file_path = os.path.join("Calculator.fs")
+        symbols = language_server.request_document_symbols(file_path)
+
+        # Find the 'add' function symbol
+        add_symbol = None
+
+        for sym in symbols.iter_symbols():
+            if sym.get("name") == "add":
+                add_symbol = sym
+                break
+
+        assert add_symbol is not None, "Could not find 'add' function symbol in Calculator.fs"
+
+        # Try to find references to the add function
+        sel_start = add_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"] + 1)
+
+        # The add function should be referenced in Program.fs
+        assert any("Program.fs" in ref.get("relativePath", "") for ref in refs), "Program.fs should reference add function"
+
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_nested_module_symbols(self, language_server: SolidLanguageServer) -> None:
+        """Test getting symbols from nested Models namespace."""
+        file_path = os.path.join("Models", "Person.fs")
+        symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()[0]
+
+        # Check for expected types and modules
+        symbol_names = [s.get("name") for s in symbols]
+        expected_symbols = ["Person", "PersonModule", "Address", "Employee"]
+
+        for expected in expected_symbols:
+            assert expected in symbol_names, f"{expected} not found in Person.fs symbols"
+
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_find_referencing_symbols_across_files(self, language_server: SolidLanguageServer) -> None:
+        """Test finding references to Calculator functions across files."""
+        # Find the subtract function in Calculator.fs
+        file_path = os.path.join("Calculator.fs")
+        symbols = language_server.request_document_symbols(file_path)
+
+        subtract_symbol = None
+        for sym in symbols.iter_symbols():
+            if sym.get("name") == "subtract":
+                subtract_symbol = sym
+                break
+
+        assert subtract_symbol is not None, "Could not find 'subtract' function symbol"
+
+        # Find references to subtract function
+        sel_start = subtract_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"] + 1)
+
+        # The subtract function should be referenced in Program.fs
+        assert any("Program.fs" in ref.get("relativePath", "") for ref in refs), "Program.fs should reference subtract function"
+
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_go_to_definition(self, language_server: SolidLanguageServer) -> None:
+        """Test go-to-definition functionality."""
+        # Test going to definition of 'add' function from Program.fs
+        program_file = os.path.join("Program.fs")
+
+        # Try to find definition of 'add' function used in Program.fs
+        # This would typically be at the line where 'add 5 3' is called
+        definitions = language_server.request_definition(program_file, 10, 20)  # Approximate position
+
+        # We should get at least some definitions
+        assert len(definitions) >= 0, "Should get definitions (even if empty for complex cases)"
+
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_hover_information(self, language_server: SolidLanguageServer) -> None:
+        """Test hover information functionality."""
+        file_path = os.path.join("Calculator.fs")
+
+        # Try to get hover information for a function
+        hover_info = language_server.request_hover(file_path, 5, 10)  # Approximate position of a function
+
+        # Hover info might be None or contain information
+        # This is acceptable as it depends on the LSP server's capabilities and timing
+        assert hover_info is None or isinstance(hover_info, dict), "Hover info should be None or dict"
+
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_completion(self, language_server: SolidLanguageServer) -> None:
+        """Test code completion functionality."""
+        file_path = os.path.join("Program.fs")
+
+        # Use threading for cross-platform timeout (signal.SIGALRM is Unix-only)
+        result = [None]
+        exception = [None]
+
+        def run_completion():
+            try:
+                result[0] = language_server.request_completions(file_path, 15, 10)
+            except Exception as e:
+                exception[0] = e
+
+        thread = threading.Thread(target=run_completion, daemon=True)
+        thread.start()
+        thread.join(timeout=5)  # 5 second timeout
+
+        if thread.is_alive():
+            # Completion timed out, but this is acceptable for F# in some cases
+            # The important thing is that the language server doesn't crash
+            return
+
+        if exception[0]:
+            raise exception[0]
+
+        assert isinstance(result[0], list), "Completions should be a list"
+
+    @pytest.mark.parametrize("language_server", [Language.FSHARP], indirect=True)
+    def test_diagnostics(self, language_server: SolidLanguageServer) -> None:
+        """Test getting diagnostics (errors, warnings) from F# files."""
+        file_path = os.path.join("Program.fs")
+
+        # FsAutoComplete uses publishDiagnostics notifications instead of textDocument/diagnostic requests
+        # So we'll test that the language server can handle files without crashing
+        # In real usage, diagnostics would come through the publishDiagnostics notification handler
+
+        # Test that we can at least work with the file (open/close cycle)
+        with language_server.open_file(file_path) as _:
+            # If we can open and close the file without errors, basic diagnostics support is working
+            pass
+
+        # This is a successful test - FsAutoComplete is working with F# files
+        assert True, "F# language server can handle files successfully"
+
+
+@pytest.mark.fsharp
+class TestFSharpLanguageServerSetup:
+    """Test F# language server setup and configuration."""
+
+    def test_runtime_dependency_setup_without_dotnet(self) -> None:
+        """Test that setup fails gracefully when .NET is not installed."""
+        with patch("shutil.which", return_value=None):
+            with pytest.raises(RuntimeError, match=r"\.NET SDK is not installed"):
+                FSharpLanguageServer._setup_runtime_dependencies(Mock(), Mock())
+
+    def test_runtime_dependency_setup_with_dotnet(self) -> None:
+        """Test that setup works when .NET is available."""
+        mock_config = Mock()
+        mock_settings = Mock()
+
+        # Mock the ls_resources_dir to return a temp directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with patch("shutil.which", return_value="/usr/bin/dotnet"):
+                with patch.object(FSharpLanguageServer, "ls_resources_dir", return_value=temp_dir):
+                    with patch("subprocess.run") as mock_run:
+                        # Mock successful dotnet version check
+                        mock_run.return_value.stdout = "8.0.100"
+                        mock_run.return_value.returncode = 0
+
+                        # Create a fake fsautocomplete executable
+                        fsharp_dir = os.path.join(temp_dir, "fsharp-lsp")
+                        os.makedirs(fsharp_dir, exist_ok=True)
+                        # Use .exe extension on Windows, matching production code
+                        exe_name = "fsautocomplete.exe" if os.name == "nt" else "fsautocomplete"
+                        fsautocomplete_path = os.path.join(fsharp_dir, exe_name)
+                        Path(fsautocomplete_path).touch()
+
+                        result = FSharpLanguageServer._setup_runtime_dependencies(mock_config, mock_settings)
+
+                        assert fsautocomplete_path in result
+                        assert "--adaptive-lsp-server-enabled --project-graph-enabled --use-fcs-transparent-compiler" in result

test/solidlsp/vue/__init__.py

@@ -0,0 +1,15 @@
+"""Vue language server tests."""
+
+import shutil
+
+
+def _test_npm_available() -> str:
+    """Test if npm is available and return error reason if not."""
+    # Check if npm is installed
+    if not shutil.which("npm"):
+        return "npm is not installed or not in PATH"
+    return ""  # No error, npm is available
+
+
+NPM_UNAVAILABLE_REASON = _test_npm_available()
+NPM_UNAVAILABLE = bool(NPM_UNAVAILABLE_REASON)

test/solidlsp/vue/test_vue_basic.py

@@ -0,0 +1,362 @@
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_utils import SymbolUtils
+
+
+@pytest.mark.vue
+class TestVueLanguageServer:
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_vue_files_in_symbol_tree(self, language_server: SolidLanguageServer) -> None:
+        symbols = language_server.request_full_symbol_tree()
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "App"), "App not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "CalculatorButton"), "CalculatorButton not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "CalculatorInput"), "CalculatorInput not found in symbol tree"
+        assert SymbolUtils.symbol_tree_contains_name(symbols, "CalculatorDisplay"), "CalculatorDisplay not found in symbol tree"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
+        store_file = os.path.join("src", "stores", "calculator.ts")
+        symbols = language_server.request_document_symbols(store_file).get_all_symbols_and_roots()
+
+        # Find useCalculatorStore function
+        store_symbol = None
+        for sym in symbols[0]:
+            if sym.get("name") == "useCalculatorStore":
+                store_symbol = sym
+                break
+
+        assert store_symbol is not None, "useCalculatorStore function not found"
+
+        # Get references
+        sel_start = store_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(store_file, sel_start["line"], sel_start["character"])
+
+        # Should have multiple references: definition + usage in App.vue, CalculatorInput.vue, CalculatorDisplay.vue
+        assert len(refs) >= 4, f"useCalculatorStore should have at least 4 references (definition + 3 usages), got {len(refs)}"
+
+        # Verify we have references from .vue files
+        vue_refs = [ref for ref in refs if ".vue" in ref.get("relativePath", "")]
+        assert len(vue_refs) >= 3, f"Should have at least 3 Vue component references, got {len(vue_refs)}"
+
+
+@pytest.mark.vue
+class TestVueDualLspArchitecture:
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_typescript_server_coordination(self, language_server: SolidLanguageServer) -> None:
+        ts_file = os.path.join("src", "stores", "calculator.ts")
+        ts_symbols = language_server.request_document_symbols(ts_file).get_all_symbols_and_roots()
+        ts_symbol_names = [s.get("name") for s in ts_symbols[0]]
+
+        assert len(ts_symbols[0]) >= 5, f"TypeScript server should return multiple symbols for calculator.ts, got {len(ts_symbols[0])}"
+        assert "useCalculatorStore" in ts_symbol_names, "TypeScript server should extract store function"
+
+        # Verify Vue server can parse .vue files
+        vue_file = os.path.join("src", "App.vue")
+        vue_symbols = language_server.request_document_symbols(vue_file).get_all_symbols_and_roots()
+        vue_symbol_names = [s.get("name") for s in vue_symbols[0]]
+
+        assert len(vue_symbols[0]) >= 15, f"Vue server should return at least 15 symbols for App.vue, got {len(vue_symbols[0])}"
+        assert "appTitle" in vue_symbol_names, "Vue server should extract ref declarations from script setup"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_cross_file_references_vue_to_typescript(self, language_server: SolidLanguageServer) -> None:
+        store_file = os.path.join("src", "stores", "calculator.ts")
+        store_symbols = language_server.request_document_symbols(store_file).get_all_symbols_and_roots()
+
+        store_symbol = None
+        for sym in store_symbols[0]:
+            if sym.get("name") == "useCalculatorStore":
+                store_symbol = sym
+                break
+
+        if not store_symbol or "selectionRange" not in store_symbol:
+            pytest.skip("useCalculatorStore symbol not found - test fixture may need updating")
+
+        # Request references for this symbol
+        sel_start = store_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(store_file, sel_start["line"], sel_start["character"])
+
+        # Verify we found references: definition + usage in App.vue, CalculatorInput.vue, CalculatorDisplay.vue
+        assert len(refs) >= 4, f"useCalculatorStore should have at least 4 references (definition + 3 usages), found {len(refs)} references"
+
+        # Verify references include .vue files (components that import the store)
+        vue_refs = [ref for ref in refs if ".vue" in ref.get("uri", "")]
+        assert (
+            len(vue_refs) >= 3
+        ), f"Should find at least 3 references in Vue components, found {len(vue_refs)}: {[ref.get('uri', '') for ref in vue_refs]}"
+
+        # Verify specific components that use the store
+        expected_vue_files = ["App.vue", "CalculatorInput.vue", "CalculatorDisplay.vue"]
+        found_components = []
+        for expected_file in expected_vue_files:
+            matching_refs = [ref for ref in vue_refs if expected_file in ref.get("uri", "")]
+            if matching_refs:
+                found_components.append(expected_file)
+
+        assert len(found_components) > 0, (
+            f"Should find references in at least one component that uses the store. "
+            f"Expected any of {expected_vue_files}, found references in: {[ref.get('uri', '') for ref in vue_refs]}"
+        )
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_cross_file_references_typescript_to_vue(self, language_server: SolidLanguageServer) -> None:
+        types_file = os.path.join("src", "types", "index.ts")
+        types_symbols = language_server.request_document_symbols(types_file).get_all_symbols_and_roots()
+        types_symbol_names = [s.get("name") for s in types_symbols[0]]
+
+        # Operation type is used in calculator.ts and CalculatorInput.vue
+        assert "Operation" in types_symbol_names, "Operation type should exist in types file"
+
+        operation_symbol = None
+        for sym in types_symbols[0]:
+            if sym.get("name") == "Operation":
+                operation_symbol = sym
+                break
+
+        if not operation_symbol or "selectionRange" not in operation_symbol:
+            pytest.skip("Operation type symbol not found - test fixture may need updating")
+
+        # Request references for the Operation type
+        sel_start = operation_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(types_file, sel_start["line"], sel_start["character"])
+
+        # Verify we found references: definition + usage in calculator.ts and Vue files
+        assert len(refs) >= 2, f"Operation type should have at least 2 references (definition + usages), found {len(refs)} references"
+
+        # The Operation type should be referenced in both .ts files (calculator.ts) and potentially .vue files
+        all_ref_uris = [ref.get("uri", "") for ref in refs]
+        has_ts_refs = any(".ts" in uri and "types" not in uri for uri in all_ref_uris)
+
+        assert (
+            has_ts_refs
+        ), f"Operation type should be referenced in TypeScript files like calculator.ts. Found references in: {all_ref_uris}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_reference_deduplication(self, language_server: SolidLanguageServer) -> None:
+        store_file = os.path.join("src", "stores", "calculator.ts")
+        store_symbols = language_server.request_document_symbols(store_file).get_all_symbols_and_roots()
+
+        # Find a commonly-used symbol (useCalculatorStore)
+        store_symbol = None
+        for sym in store_symbols[0]:
+            if sym.get("name") == "useCalculatorStore":
+                store_symbol = sym
+                break
+
+        if not store_symbol or "selectionRange" not in store_symbol:
+            pytest.skip("useCalculatorStore symbol not found - test fixture may need updating")
+
+        # Request references
+        sel_start = store_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(store_file, sel_start["line"], sel_start["character"])
+
+        # Check for duplicate references (same file, line, and character)
+        seen_locations = set()
+        duplicates = []
+
+        for ref in refs:
+            # Create a unique key for this reference location
+            uri = ref.get("uri", "")
+            if "range" in ref:
+                line = ref["range"]["start"]["line"]
+                character = ref["range"]["start"]["character"]
+                location_key = (uri, line, character)
+
+                if location_key in seen_locations:
+                    duplicates.append(location_key)
+                else:
+                    seen_locations.add(location_key)
+
+        assert len(duplicates) == 0, (
+            f"Found {len(duplicates)} duplicate reference locations. "
+            f"The dual-LSP architecture should deduplicate references from both servers. "
+            f"Duplicates: {duplicates}"
+        )
+
+
+@pytest.mark.vue
+class TestVueEdgeCases:
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_symbol_tree_structure(self, language_server: SolidLanguageServer) -> None:
+        full_tree = language_server.request_full_symbol_tree()
+
+        # Helper to extract all file paths from symbol tree
+        def extract_paths_from_tree(symbols, paths=None):
+            """Recursively extract file paths from symbol tree."""
+            if paths is None:
+                paths = []
+
+            if isinstance(symbols, list):
+                for symbol in symbols:
+                    extract_paths_from_tree(symbol, paths)
+            elif isinstance(symbols, dict):
+                # Check if this symbol has a location
+                if "location" in symbols and "uri" in symbols["location"]:
+                    uri = symbols["location"]["uri"]
+                    # Extract the path after file://
+                    if uri.startswith("file://"):
+                        file_path = uri[7:]  # Remove "file://"
+                        paths.append(file_path)
+
+                # Recurse into children
+                if "children" in symbols:
+                    extract_paths_from_tree(symbols["children"], paths)
+
+            return paths
+
+        all_paths = extract_paths_from_tree(full_tree)
+
+        # Verify we have files from expected directories
+        # Note: Symbol tree may include duplicate paths (one per symbol in file)
+        components_files = list({p for p in all_paths if "components" in p and ".vue" in p})
+        stores_files = list({p for p in all_paths if "stores" in p and ".ts" in p})
+        composables_files = list({p for p in all_paths if "composables" in p and ".ts" in p})
+
+        assert len(components_files) == 3, (
+            f"Symbol tree should include exactly 3 unique Vue components (CalculatorButton, CalculatorInput, CalculatorDisplay). "
+            f"Found {len(components_files)} unique component files: {[p.split('/')[-1] for p in sorted(components_files)]}"
+        )
+
+        assert len(stores_files) == 1, (
+            f"Symbol tree should include exactly 1 unique store file (calculator.ts). "
+            f"Found {len(stores_files)} unique store files: {[p.split('/')[-1] for p in sorted(stores_files)]}"
+        )
+
+        assert len(composables_files) == 2, (
+            f"Symbol tree should include exactly 2 unique composable files (useFormatter.ts, useTheme.ts). "
+            f"Found {len(composables_files)} unique composable files: {[p.split('/')[-1] for p in sorted(composables_files)]}"
+        )
+
+        # Verify specific expected files exist in the tree
+        expected_files = [
+            "CalculatorButton.vue",
+            "CalculatorInput.vue",
+            "CalculatorDisplay.vue",
+            "App.vue",
+            "calculator.ts",
+            "useFormatter.ts",
+            "useTheme.ts",
+        ]
+
+        for expected_file in expected_files:
+            matching_files = [p for p in all_paths if expected_file in p]
+            assert len(matching_files) > 0, f"Expected file '{expected_file}' should be in symbol tree. All paths: {all_paths}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_document_overview(self, language_server: SolidLanguageServer) -> None:
+        app_file = os.path.join("src", "App.vue")
+        overview = language_server.request_document_overview(app_file)
+
+        # Overview should return a list of top-level symbols
+        assert isinstance(overview, list), f"Overview should be a list, got: {type(overview)}"
+        assert len(overview) >= 1, f"App.vue should have at least 1 top-level symbol in overview, got {len(overview)}"
+
+        # Extract symbol names from overview
+        symbol_names = [s.get("name") for s in overview if isinstance(s, dict)]
+
+        # Vue LSP returns SFC structure (template/script/style sections) for .vue files
+        # This is expected behavior - overview shows the file's high-level structure
+        assert (
+            len(symbol_names) >= 1
+        ), f"Should have at least 1 symbol name in overview (e.g., 'App' or SFC section), got {len(symbol_names)}: {symbol_names}"
+
+        # Test overview for a TypeScript file
+        store_file = os.path.join("src", "stores", "calculator.ts")
+        store_overview = language_server.request_document_overview(store_file)
+
+        assert isinstance(store_overview, list), f"Store overview should be a list, got: {type(store_overview)}"
+        assert len(store_overview) >= 1, f"calculator.ts should have at least 1 top-level symbol in overview, got {len(store_overview)}"
+
+        store_symbol_names = [s.get("name") for s in store_overview if isinstance(s, dict)]
+        assert (
+            "useCalculatorStore" in store_symbol_names
+        ), f"useCalculatorStore should be in store file overview. Found {len(store_symbol_names)} symbols: {store_symbol_names}"
+
+        # Test overview for another Vue component
+        button_file = os.path.join("src", "components", "CalculatorButton.vue")
+        button_overview = language_server.request_document_overview(button_file)
+
+        assert isinstance(button_overview, list), f"Button overview should be a list, got: {type(button_overview)}"
+        assert (
+            len(button_overview) >= 1
+        ), f"CalculatorButton.vue should have at least 1 top-level symbol in overview, got {len(button_overview)}"
+
+        # For Vue files, overview provides SFC structure which is useful for navigation
+        # The detailed symbols are available via request_document_symbols
+        button_symbol_names = [s.get("name") for s in button_overview if isinstance(s, dict)]
+        assert len(button_symbol_names) >= 1, (
+            f"CalculatorButton.vue should have at least 1 symbol in overview (e.g., 'CalculatorButton' or SFC section). "
+            f"Found {len(button_symbol_names)} symbols: {button_symbol_names}"
+        )
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_directory_overview(self, language_server: SolidLanguageServer) -> None:
+        components_dir = os.path.join("src", "components")
+        dir_overview = language_server.request_dir_overview(components_dir)
+
+        # Directory overview should be a dict mapping file paths to symbol lists
+        assert isinstance(dir_overview, dict), f"Directory overview should be a dict, got: {type(dir_overview)}"
+        assert len(dir_overview) == 3, f"src/components directory should have exactly 3 files in overview, got {len(dir_overview)}"
+
+        # Verify all component files are included
+        expected_components = ["CalculatorButton.vue", "CalculatorInput.vue", "CalculatorDisplay.vue"]
+
+        for expected_component in expected_components:
+            # Find files that match this component name
+            matching_files = [path for path in dir_overview.keys() if expected_component in path]
+            assert len(matching_files) == 1, (
+                f"Component '{expected_component}' should appear exactly once in directory overview. "
+                f"Found {len(matching_files)} matches. All files: {list(dir_overview.keys())}"
+            )
+
+            # Verify the matched file has symbols
+            file_path = matching_files[0]
+            symbols = dir_overview[file_path]
+            assert isinstance(symbols, list), f"Symbols for {file_path} should be a list, got {type(symbols)}"
+            assert len(symbols) >= 1, f"Component {expected_component} should have at least 1 symbol in overview, got {len(symbols)}"
+
+        # Test overview for stores directory
+        stores_dir = os.path.join("src", "stores")
+        stores_overview = language_server.request_dir_overview(stores_dir)
+
+        assert isinstance(stores_overview, dict), f"Stores overview should be a dict, got: {type(stores_overview)}"
+        assert (
+            len(stores_overview) == 1
+        ), f"src/stores directory should have exactly 1 file (calculator.ts) in overview, got {len(stores_overview)}"
+
+        # Verify calculator.ts is included
+        calculator_files = [path for path in stores_overview.keys() if "calculator.ts" in path]
+        assert len(calculator_files) == 1, (
+            f"calculator.ts should appear exactly once in stores directory overview. "
+            f"Found {len(calculator_files)} matches. All files: {list(stores_overview.keys())}"
+        )
+
+        # Verify the store file has symbols
+        store_path = calculator_files[0]
+        store_symbols = stores_overview[store_path]
+        store_symbol_names = [s.get("name") for s in store_symbols if isinstance(s, dict)]
+        assert (
+            "useCalculatorStore" in store_symbol_names
+        ), f"calculator.ts should have useCalculatorStore in overview. Found {len(store_symbol_names)} symbols: {store_symbol_names}"
+
+        # Test overview for composables directory
+        composables_dir = os.path.join("src", "composables")
+        composables_overview = language_server.request_dir_overview(composables_dir)
+
+        assert isinstance(composables_overview, dict), f"Composables overview should be a dict, got: {type(composables_overview)}"
+        assert (
+            len(composables_overview) == 2
+        ), f"src/composables directory should have exactly 2 files in overview, got {len(composables_overview)}"
+
+        # Verify composable files are included
+        expected_composables = ["useFormatter.ts", "useTheme.ts"]
+        for expected_composable in expected_composables:
+            matching_files = [path for path in composables_overview.keys() if expected_composable in path]
+            assert len(matching_files) == 1, (
+                f"Composable '{expected_composable}' should appear exactly once in directory overview. "
+                f"Found {len(matching_files)} matches. All files: {list(composables_overview.keys())}"
+            )

test/solidlsp/vue/test_vue_error_cases.py

@@ -0,0 +1,422 @@
+import os
+import sys
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+pytestmark = pytest.mark.vue
+
+IS_WINDOWS = sys.platform == "win32"
+
+
+class TypeScriptServerBehavior:
+    """Platform-specific TypeScript language server behavior for invalid positions.
+
+    On Windows: TS server returns empty results for invalid positions
+    On macOS/Linux: TS server raises exceptions with "Bad line number" or "Debug Failure"
+    """
+
+    @staticmethod
+    def raises_on_invalid_position() -> bool:
+        return not IS_WINDOWS
+
+    @staticmethod
+    def returns_empty_on_invalid_position() -> bool:
+        return IS_WINDOWS
+
+
+class TestVueInvalidPositions:
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_negative_line_number(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        result = language_server.request_containing_symbol(file_path, -1, 0)
+
+        assert result is None or result == {}, f"Negative line number should return None or empty dict, got: {result}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_negative_character_number(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting containing symbol with negative character number.
+
+        Expected behavior: Should return None or empty dict, not crash.
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Request containing symbol at invalid negative character
+        result = language_server.request_containing_symbol(file_path, 10, -1)
+
+        # Should handle gracefully - return None or empty dict
+        assert result is None or result == {}, f"Negative character number should return None or empty dict, got: {result}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_line_number_beyond_file_length(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting containing symbol beyond file length.
+
+        Expected behavior: Raises IndexError when trying to access line beyond file bounds.
+        This happens in the wrapper code before even reaching the language server.
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Request containing symbol at line 99999 (way beyond file length)
+        # The wrapper code will raise an IndexError when checking if the line is empty
+        with pytest.raises(IndexError) as exc_info:
+            language_server.request_containing_symbol(file_path, 99999, 0)
+
+        # Verify it's an index error for list access
+        assert "list index out of range" in str(exc_info.value), f"Expected 'list index out of range' error, got: {exc_info.value}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_character_number_beyond_line_length(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting containing symbol beyond line length.
+
+        Expected behavior: Should return None or empty dict, not crash.
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Request containing symbol at character 99999 (way beyond line length)
+        result = language_server.request_containing_symbol(file_path, 10, 99999)
+
+        # Should handle gracefully - return None or empty dict
+        assert result is None or result == {}, f"Character beyond line length should return None or empty dict, got: {result}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_references_at_negative_line(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting references with negative line number."""
+        from solidlsp.ls_exceptions import SolidLSPException
+
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        if TypeScriptServerBehavior.returns_empty_on_invalid_position():
+            result = language_server.request_references(file_path, -1, 0)
+            assert result == [], f"Expected empty list on Windows, got: {result}"
+        else:
+            with pytest.raises(SolidLSPException) as exc_info:
+                language_server.request_references(file_path, -1, 0)
+            assert "Bad line number" in str(exc_info.value) or "Debug Failure" in str(exc_info.value)
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_definition_at_invalid_position(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting definition at invalid position."""
+        from solidlsp.ls_exceptions import SolidLSPException
+
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        if TypeScriptServerBehavior.returns_empty_on_invalid_position():
+            result = language_server.request_definition(file_path, -1, 0)
+            assert result == [], f"Expected empty list on Windows, got: {result}"
+        else:
+            with pytest.raises(SolidLSPException) as exc_info:
+                language_server.request_definition(file_path, -1, 0)
+            assert "Bad line number" in str(exc_info.value) or "Debug Failure" in str(exc_info.value)
+
+
+class TestVueNonExistentFiles:
+    """Tests for handling non-existent files."""
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_document_symbols_nonexistent_file(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting document symbols from non-existent file.
+
+        Expected behavior: Should raise FileNotFoundError or return empty result.
+        """
+        nonexistent_file = os.path.join("src", "components", "NonExistent.vue")
+
+        # Should raise an appropriate exception or return empty result
+        try:
+            result = language_server.request_document_symbols(nonexistent_file)
+            # If no exception, verify result is empty or indicates file not found
+            symbols = result.get_all_symbols_and_roots()
+            assert len(symbols[0]) == 0, f"Non-existent file should return empty symbols, got {len(symbols[0])} symbols"
+        except (FileNotFoundError, Exception) as e:
+            # Expected - file doesn't exist
+            assert True, f"Appropriately raised exception for non-existent file: {e}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_containing_symbol_nonexistent_file(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting containing symbol from non-existent file.
+
+        Expected behavior: Should raise FileNotFoundError or return None.
+        """
+        nonexistent_file = os.path.join("src", "components", "NonExistent.vue")
+
+        # Should raise an appropriate exception or return None
+        try:
+            result = language_server.request_containing_symbol(nonexistent_file, 10, 10)
+            # If no exception, verify result indicates file not found
+            assert result is None or result == {}, f"Non-existent file should return None or empty dict, got: {result}"
+        except (FileNotFoundError, Exception) as e:
+            # Expected - file doesn't exist
+            assert True, f"Appropriately raised exception for non-existent file: {e}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_references_nonexistent_file(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting references from non-existent file.
+
+        Expected behavior: Should raise FileNotFoundError or return empty list.
+        """
+        nonexistent_file = os.path.join("src", "components", "NonExistent.vue")
+
+        # Should raise an appropriate exception or return empty list
+        try:
+            result = language_server.request_references(nonexistent_file, 10, 10)
+            # If no exception, verify result is empty
+            assert result is None or isinstance(result, list), f"Non-existent file should return None or list, got: {result}"
+            if isinstance(result, list):
+                assert len(result) == 0, f"Non-existent file should return empty list, got {len(result)} references"
+        except (FileNotFoundError, Exception) as e:
+            # Expected - file doesn't exist
+            assert True, f"Appropriately raised exception for non-existent file: {e}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_definition_nonexistent_file(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting definition from non-existent file.
+
+        Expected behavior: Should raise FileNotFoundError or return empty list.
+        """
+        nonexistent_file = os.path.join("src", "components", "NonExistent.vue")
+
+        # Should raise an appropriate exception or return empty list
+        try:
+            result = language_server.request_definition(nonexistent_file, 10, 10)
+            # If no exception, verify result is empty
+            assert isinstance(result, list), f"request_definition should return a list, got: {type(result)}"
+            assert len(result) == 0, f"Non-existent file should return empty list, got {len(result)} definitions"
+        except (FileNotFoundError, Exception) as e:
+            # Expected - file doesn't exist
+            assert True, f"Appropriately raised exception for non-existent file: {e}"
+
+
+class TestVueUndefinedSymbols:
+    """Tests for handling undefined or unreferenced symbols."""
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_references_for_unreferenced_symbol(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting references for a symbol that has no references.
+
+        Expected behavior: Should return empty list (only the definition itself if include_self=True).
+        """
+        # Find a symbol that likely has no external references
+        file_path = os.path.join("src", "components", "CalculatorButton.vue")
+
+        # Get document symbols
+        symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
+
+        # Find pressCount - this is exposed but may not be referenced elsewhere
+        press_count_symbol = next((s for s in symbols[0] if s.get("name") == "pressCount"), None)
+
+        if not press_count_symbol or "selectionRange" not in press_count_symbol:
+            pytest.skip("pressCount symbol not found - test fixture may need updating")
+
+        # Request references without include_self
+        sel_start = press_count_symbol["selectionRange"]["start"]
+        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
+
+        # Should return a list (may be empty or contain only definition)
+        assert isinstance(refs, list), f"request_references should return a list, got {type(refs)}"
+
+        # For an unreferenced symbol, should have 0-1 references (0 without include_self, 1 with)
+        # The exact count depends on the language server implementation
+        assert len(refs) <= 5, (
+            f"pressCount should have few or no external references. "
+            f"Got {len(refs)} references. This is not necessarily an error, just documenting behavior."
+        )
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_containing_symbol_at_whitespace_only_line(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting containing symbol at a whitespace-only line.
+
+        Expected behavior: Should return None, empty dict, or the parent symbol.
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Try position at line 1 (typically a blank line or template start in Vue SFCs)
+        result = language_server.request_containing_symbol(file_path, 1, 0)
+
+        # Should handle gracefully - return None, empty dict, or a valid parent symbol
+        assert (
+            result is None or result == {} or isinstance(result, dict)
+        ), f"Whitespace line should return None, empty dict, or valid symbol. Got: {result}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_definition_at_keyword_position(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting definition at language keyword position.
+
+        Expected behavior: Should return empty list or handle gracefully.
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Try to get definition at a keyword like "const", "import", etc.
+        # Line 2 typically has "import" statement - try position on "import" keyword
+        result = language_server.request_definition(file_path, 2, 0)
+
+        # Should handle gracefully - return empty list or valid definitions
+        assert isinstance(result, list), f"request_definition should return a list, got {type(result)}"
+
+
+class TestVueEdgeCasePositions:
+    """Tests for edge case positions (0,0 and file boundaries)."""
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_containing_symbol_at_file_start(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting containing symbol at position (0,0).
+
+        Expected behavior: Should return None, empty dict, or a valid symbol.
+        This position typically corresponds to the start of the file (e.g., <template> tag).
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Request containing symbol at position 0,0 (file start)
+        result = language_server.request_containing_symbol(file_path, 0, 0)
+
+        # Should handle gracefully
+        assert (
+            result is None or result == {} or isinstance(result, dict)
+        ), f"Position 0,0 should return None, empty dict, or valid symbol. Got: {result}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_references_at_file_start(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting references at position (0,0).
+
+        Expected behavior: Should return None or empty list.
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Request references at position 0,0 (file start)
+        result = language_server.request_references(file_path, 0, 0)
+
+        # Should handle gracefully
+        assert result is None or isinstance(result, list), f"Position 0,0 should return None or list. Got: {type(result)}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_definition_at_file_start(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting definition at position (0,0).
+
+        Expected behavior: Should return empty list.
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Request definition at position 0,0 (file start)
+        result = language_server.request_definition(file_path, 0, 0)
+
+        # Should handle gracefully
+        assert isinstance(result, list), f"request_definition should return a list. Got: {type(result)}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_containing_symbol_in_template_section(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting containing symbol in the template section.
+
+        Expected behavior: Template positions typically have no containing symbol (return None or empty).
+        The Vue language server may not track template symbols the same way as script symbols.
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Position likely in template section (early in file, before <script setup>)
+        # Exact line depends on file structure, but line 5-10 is often template
+        result = language_server.request_containing_symbol(file_path, 5, 10)
+
+        # Should handle gracefully - template doesn't have containing symbols in the same way
+        assert (
+            result is None or result == {} or isinstance(result, dict)
+        ), f"Template position should return None, empty dict, or valid symbol. Got: {result}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_zero_character_positions(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting symbols at character position 0 (start of lines).
+
+        Expected behavior: Should handle gracefully, may or may not find symbols.
+        """
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Test multiple lines at character 0
+        for line in [0, 10, 20, 30]:
+            result = language_server.request_containing_symbol(file_path, line, 0)
+
+            # Should handle gracefully
+            assert (
+                result is None or result == {} or isinstance(result, dict)
+            ), f"Line {line}, character 0 should return None, empty dict, or valid symbol. Got: {result}"
+
+
+class TestVueTypescriptFileErrors:
+    """Tests for error handling in TypeScript files within Vue projects."""
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_typescript_file_invalid_position(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting symbols from TypeScript file at invalid position.
+
+        Expected behavior: Should handle gracefully.
+        """
+        file_path = os.path.join("src", "stores", "calculator.ts")
+
+        # Request containing symbol at invalid position
+        result = language_server.request_containing_symbol(file_path, -1, -1)
+
+        # Should handle gracefully
+        assert result is None or result == {}, f"Invalid position in .ts file should return None or empty dict. Got: {result}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_typescript_file_beyond_bounds(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting symbols from TypeScript file beyond file bounds.
+
+        Expected behavior: Raises IndexError when trying to access line beyond file bounds.
+        """
+        file_path = os.path.join("src", "stores", "calculator.ts")
+
+        # Request containing symbol beyond file bounds
+        # The wrapper code will raise an IndexError when checking if the line is empty
+        with pytest.raises(IndexError) as exc_info:
+            language_server.request_containing_symbol(file_path, 99999, 99999)
+
+        # Verify it's an index error for list access
+        assert "list index out of range" in str(exc_info.value), f"Expected 'list index out of range' error, got: {exc_info.value}"
+
+
+class TestVueReferenceEdgeCases:
+    """Tests for edge cases in reference finding."""
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_referencing_symbols_at_invalid_position(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting referencing symbols at invalid position."""
+        from solidlsp.ls_exceptions import SolidLSPException
+
+        file_path = os.path.join("src", "stores", "calculator.ts")
+
+        if TypeScriptServerBehavior.returns_empty_on_invalid_position():
+            result = list(language_server.request_referencing_symbols(file_path, -1, -1, include_self=False))
+            assert result == [], f"Expected empty list on Windows, got: {result}"
+        else:
+            with pytest.raises(SolidLSPException) as exc_info:
+                list(language_server.request_referencing_symbols(file_path, -1, -1, include_self=False))
+            assert "Bad line number" in str(exc_info.value) or "Debug Failure" in str(exc_info.value)
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_defining_symbol_at_invalid_position(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting defining symbol at invalid position."""
+        from solidlsp.ls_exceptions import SolidLSPException
+
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        if TypeScriptServerBehavior.returns_empty_on_invalid_position():
+            result = language_server.request_defining_symbol(file_path, -1, -1)
+            assert result is None, f"Expected None on Windows, got: {result}"
+        else:
+            with pytest.raises(SolidLSPException) as exc_info:
+                language_server.request_defining_symbol(file_path, -1, -1)
+            assert "Bad line number" in str(exc_info.value) or "Debug Failure" in str(exc_info.value)
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_referencing_symbols_beyond_file_bounds(self, language_server: SolidLanguageServer) -> None:
+        """Test requesting referencing symbols beyond file bounds."""
+        from solidlsp.ls_exceptions import SolidLSPException
+
+        file_path = os.path.join("src", "stores", "calculator.ts")
+
+        if TypeScriptServerBehavior.returns_empty_on_invalid_position():
+            result = list(language_server.request_referencing_symbols(file_path, 99999, 99999, include_self=False))
+            assert result == [], f"Expected empty list on Windows, got: {result}"
+        else:
+            with pytest.raises(SolidLSPException) as exc_info:
+                list(language_server.request_referencing_symbols(file_path, 99999, 99999, include_self=False))
+            assert "Bad line number" in str(exc_info.value) or "Debug Failure" in str(exc_info.value)

test/solidlsp/vue/test_vue_rename.py

@@ -0,0 +1,241 @@
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+
+pytestmark = pytest.mark.vue
+
+
+class TestVueRename:
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_rename_function_within_single_file(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
+        handle_digit_symbol = next((s for s in symbols[0] if s.get("name") == "handleDigit"), None)
+
+        if not handle_digit_symbol or "selectionRange" not in handle_digit_symbol:
+            pytest.skip("handleDigit symbol not found - test fixture may need updating")
+
+        sel_start = handle_digit_symbol["selectionRange"]["start"]
+
+        workspace_edit = language_server.request_rename_symbol_edit(file_path, sel_start["line"], sel_start["character"], "processDigit")
+
+        assert workspace_edit is not None, "Should return WorkspaceEdit for rename operation"
+
+        has_changes = "changes" in workspace_edit and workspace_edit["changes"]
+        has_document_changes = "documentChanges" in workspace_edit and workspace_edit["documentChanges"]
+
+        assert has_changes or has_document_changes, "WorkspaceEdit should contain either 'changes' or 'documentChanges'"
+
+        if has_changes:
+            changes = workspace_edit["changes"]
+            assert len(changes) > 0, "Should have at least one file with changes"
+
+            calculator_input_files = [uri for uri in changes.keys() if "CalculatorInput.vue" in uri]
+            assert len(calculator_input_files) > 0, f"Should have edits for CalculatorInput.vue. Found edits for: {list(changes.keys())}"
+
+            file_edits = changes[calculator_input_files[0]]
+            assert len(file_edits) > 0, "Should have at least one TextEdit for the renamed symbol"
+
+            for edit in file_edits:
+                assert "range" in edit, "TextEdit should have a range"
+                assert "newText" in edit, "TextEdit should have newText"
+                assert edit["newText"] == "processDigit", f"newText should be 'processDigit', got {edit['newText']}"
+
+                assert "start" in edit["range"], "Range should have start position"
+                assert "end" in edit["range"], "Range should have end position"
+                assert "line" in edit["range"]["start"], "Start position should have line number"
+                assert "character" in edit["range"]["start"], "Start position should have character offset"
+
+        elif has_document_changes:
+            document_changes = workspace_edit["documentChanges"]
+            assert isinstance(document_changes, list), "documentChanges should be a list"
+            assert len(document_changes) > 0, "Should have at least one document change"
+
+            calculator_input_changes = [dc for dc in document_changes if "CalculatorInput.vue" in dc.get("textDocument", {}).get("uri", "")]
+            assert len(calculator_input_changes) > 0, "Should have edits for CalculatorInput.vue"
+
+            for change in calculator_input_changes:
+                assert "textDocument" in change, "Document change should have textDocument"
+                assert "edits" in change, "Document change should have edits"
+
+                edits = change["edits"]
+                assert len(edits) > 0, "Should have at least one TextEdit for the renamed symbol"
+
+                for edit in edits:
+                    assert "range" in edit, "TextEdit should have a range"
+                    assert "newText" in edit, "TextEdit should have newText"
+                    assert edit["newText"] == "processDigit", f"newText should be 'processDigit', got {edit['newText']}"
+
+                    assert "start" in edit["range"], "Range should have start position"
+                    assert "end" in edit["range"], "Range should have end position"
+                    assert "line" in edit["range"]["start"], "Start position should have line number"
+                    assert "character" in edit["range"]["start"], "Start position should have character offset"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_rename_composable_function_cross_file(self, language_server: SolidLanguageServer) -> None:
+        composable_file = os.path.join("src", "composables", "useFormatter.ts")
+
+        symbols = language_server.request_document_symbols(composable_file).get_all_symbols_and_roots()
+        use_formatter_symbol = next((s for s in symbols[0] if s.get("name") == "useFormatter"), None)
+
+        if not use_formatter_symbol or "selectionRange" not in use_formatter_symbol:
+            pytest.skip("useFormatter symbol not found - test fixture may need updating")
+
+        sel_start = use_formatter_symbol["selectionRange"]["start"]
+
+        workspace_edit = language_server.request_rename_symbol_edit(
+            composable_file, sel_start["line"], sel_start["character"], "useNumberFormatter"
+        )
+
+        assert workspace_edit is not None, "Should return WorkspaceEdit for cross-file rename"
+
+        has_changes = "changes" in workspace_edit and workspace_edit["changes"]
+        has_document_changes = "documentChanges" in workspace_edit and workspace_edit["documentChanges"]
+
+        assert has_changes or has_document_changes, "WorkspaceEdit should contain either 'changes' or 'documentChanges'"
+
+        if has_changes:
+            changes = workspace_edit["changes"]
+            assert len(changes) > 0, "Should have at least one file with changes"
+
+            composable_files = [uri for uri in changes.keys() if "useFormatter.ts" in uri]
+            assert len(composable_files) > 0, f"Should have edits for useFormatter.ts (definition). Found edits for: {list(changes.keys())}"
+
+            for uri, edits in changes.items():
+                assert len(edits) > 0, f"File {uri} should have at least one edit"
+
+                for edit in edits:
+                    assert "range" in edit, f"TextEdit in {uri} should have a range"
+                    assert "newText" in edit, f"TextEdit in {uri} should have newText"
+                    assert edit["newText"] == "useNumberFormatter", f"newText should be 'useNumberFormatter', got {edit['newText']}"
+                    assert "start" in edit["range"], f"Range in {uri} should have start position"
+                    assert "end" in edit["range"], f"Range in {uri} should have end position"
+
+        elif has_document_changes:
+            document_changes = workspace_edit["documentChanges"]
+            assert isinstance(document_changes, list), "documentChanges should be a list"
+            assert len(document_changes) > 0, "Should have at least one document change"
+
+            composable_changes = [dc for dc in document_changes if "useFormatter.ts" in dc.get("textDocument", {}).get("uri", "")]
+            assert (
+                len(composable_changes) > 0
+            ), f"Should have edits for useFormatter.ts (definition). Found changes for: {[dc.get('textDocument', {}).get('uri', '') for dc in document_changes]}"
+
+            for change in document_changes:
+                assert "textDocument" in change, "Document change should have textDocument"
+                assert "edits" in change, "Document change should have edits"
+
+                uri = change["textDocument"]["uri"]
+                edits = change["edits"]
+                assert len(edits) > 0, f"File {uri} should have at least one edit"
+
+                for edit in edits:
+                    assert "range" in edit, f"TextEdit in {uri} should have a range"
+                    assert "newText" in edit, f"TextEdit in {uri} should have newText"
+                    assert edit["newText"] == "useNumberFormatter", f"newText should be 'useNumberFormatter', got {edit['newText']}"
+                    assert "start" in edit["range"], f"Range in {uri} should have start position"
+                    assert "end" in edit["range"], f"Range in {uri} should have end position"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_rename_verifies_correct_file_paths_and_ranges(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("src", "App.vue")
+
+        symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
+        app_title_symbol = next((s for s in symbols[0] if s.get("name") == "appTitle"), None)
+
+        if not app_title_symbol or "selectionRange" not in app_title_symbol:
+            pytest.skip("appTitle symbol not found - test fixture may need updating")
+
+        sel_start = app_title_symbol["selectionRange"]["start"]
+
+        workspace_edit = language_server.request_rename_symbol_edit(
+            file_path, sel_start["line"], sel_start["character"], "applicationTitle"
+        )
+
+        assert workspace_edit is not None, "Should return WorkspaceEdit for rename operation"
+        assert isinstance(workspace_edit, dict), "WorkspaceEdit should be a dictionary"
+
+        has_changes = "changes" in workspace_edit and workspace_edit["changes"]
+        has_document_changes = "documentChanges" in workspace_edit and workspace_edit["documentChanges"]
+
+        assert has_changes or has_document_changes, "WorkspaceEdit must have 'changes' or 'documentChanges'"
+
+        if has_changes:
+            changes = workspace_edit["changes"]
+
+            assert isinstance(changes, dict), "changes should be a dict mapping URIs to TextEdit lists"
+
+            assert len(changes) > 0, "Should have edits for at least one file"
+
+            for uri, edits in changes.items():
+                assert isinstance(uri, str), f"URI should be a string, got {type(uri)}"
+                assert uri.startswith("file://"), f"URI should start with 'file://', got {uri}"
+
+                assert isinstance(edits, list), f"Edits for {uri} should be a list, got {type(edits)}"
+                assert len(edits) > 0, f"Should have at least one edit for {uri}"
+
+                for idx, edit in enumerate(edits):
+                    assert isinstance(edit, dict), f"Edit {idx} in {uri} should be a dict, got {type(edit)}"
+
+                    assert "range" in edit, f"Edit {idx} in {uri} missing 'range'"
+                    assert "newText" in edit, f"Edit {idx} in {uri} missing 'newText'"
+
+                    range_obj = edit["range"]
+                    assert "start" in range_obj, f"Edit {idx} range in {uri} missing 'start'"
+                    assert "end" in range_obj, f"Edit {idx} range in {uri} missing 'end'"
+
+                    for pos_name in ["start", "end"]:
+                        pos = range_obj[pos_name]
+                        assert "line" in pos, f"Edit {idx} range {pos_name} in {uri} missing 'line'"
+                        assert "character" in pos, f"Edit {idx} range {pos_name} in {uri} missing 'character'"
+                        assert isinstance(pos["line"], int), f"Line should be int, got {type(pos['line'])}"
+                        assert isinstance(pos["character"], int), f"Character should be int, got {type(pos['character'])}"
+                        assert pos["line"] >= 0, f"Line number should be >= 0, got {pos['line']}"
+                        assert pos["character"] >= 0, f"Character offset should be >= 0, got {pos['character']}"
+
+                    assert isinstance(edit["newText"], str), f"newText should be string, got {type(edit['newText'])}"
+                    assert edit["newText"] == "applicationTitle", f"newText should be 'applicationTitle', got {edit['newText']}"
+
+        elif has_document_changes:
+            document_changes = workspace_edit["documentChanges"]
+            assert isinstance(document_changes, list), "documentChanges should be a list"
+            assert len(document_changes) > 0, "Should have at least one document change"
+
+            for change in document_changes:
+                assert isinstance(change, dict), "Each document change should be a dict"
+                assert "textDocument" in change, "Document change should have textDocument"
+                assert "edits" in change, "Document change should have edits"
+
+                text_doc = change["textDocument"]
+                assert "uri" in text_doc, "textDocument should have uri"
+                assert text_doc["uri"].startswith("file://"), f"URI should start with 'file://', got {text_doc['uri']}"
+
+                edits = change["edits"]
+                assert isinstance(edits, list), "edits should be a list"
+                assert len(edits) > 0, "Should have at least one edit"
+
+                for idx, edit in enumerate(edits):
+                    assert isinstance(edit, dict), f"Edit {idx} in {text_doc['uri']} should be a dict, got {type(edit)}"
+
+                    assert "range" in edit, f"Edit {idx} in {text_doc['uri']} missing 'range'"
+                    assert "newText" in edit, f"Edit {idx} in {text_doc['uri']} missing 'newText'"
+
+                    range_obj = edit["range"]
+                    assert "start" in range_obj, f"Edit {idx} range in {text_doc['uri']} missing 'start'"
+                    assert "end" in range_obj, f"Edit {idx} range in {text_doc['uri']} missing 'end'"
+
+                    for pos_name in ["start", "end"]:
+                        pos = range_obj[pos_name]
+                        assert "line" in pos, f"Edit {idx} range {pos_name} in {text_doc['uri']} missing 'line'"
+                        assert "character" in pos, f"Edit {idx} range {pos_name} in {text_doc['uri']} missing 'character'"
+                        assert isinstance(pos["line"], int), f"Line should be int, got {type(pos['line'])}"
+                        assert isinstance(pos["character"], int), f"Character should be int, got {type(pos['character'])}"
+                        assert pos["line"] >= 0, f"Line number should be >= 0, got {pos['line']}"
+                        assert pos["character"] >= 0, f"Character offset should be >= 0, got {pos['character']}"
+
+                    assert isinstance(edit["newText"], str), f"newText should be string, got {type(edit['newText'])}"
+                    assert edit["newText"] == "applicationTitle", f"newText should be 'applicationTitle', got {edit['newText']}"

test/solidlsp/vue/test_vue_symbol_retrieval.py

@@ -0,0 +1,249 @@
+import os
+
+import pytest
+
+from solidlsp import SolidLanguageServer
+from solidlsp.ls_config import Language
+from solidlsp.ls_types import SymbolKind
+
+pytestmark = pytest.mark.vue
+
+
+class TestVueSymbolRetrieval:
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_request_containing_symbol_script_setup_function(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # First, get the document symbols to find the handleDigit function
+        symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
+        handle_digit_symbol = next((s for s in symbols[0] if s.get("name") == "handleDigit"), None)
+
+        if not handle_digit_symbol or "range" not in handle_digit_symbol:
+            pytest.skip("handleDigit symbol not found - test fixture may need updating")
+
+        # Get a position inside the handleDigit function body
+        # We'll use a line a few lines after the function start
+        func_start_line = handle_digit_symbol["range"]["start"]["line"]
+        position_inside_func = func_start_line + 1
+        position_character = 4
+
+        # Request the containing symbol for this position
+        containing_symbol = language_server.request_containing_symbol(
+            file_path, position_inside_func, position_character, include_body=True
+        )
+
+        # Verify we found the correct containing symbol
+        assert containing_symbol is not None, "Should find containing symbol inside handleDigit function"
+        assert containing_symbol["name"] == "handleDigit", f"Expected handleDigit, got {containing_symbol.get('name')}"
+        assert containing_symbol["kind"] in [
+            SymbolKind.Function,
+            SymbolKind.Method,
+            SymbolKind.Variable,
+        ], f"Expected function-like kind, got {containing_symbol.get('kind')}"
+
+        # Verify the body is included if available
+        if "body" in containing_symbol:
+            assert "handleDigit" in containing_symbol["body"], "Function body should contain function name"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_request_containing_symbol_computed_property(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Find the formattedDisplay computed property
+        symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
+        formatted_display_symbol = next((s for s in symbols[0] if s.get("name") == "formattedDisplay"), None)
+
+        if not formatted_display_symbol or "range" not in formatted_display_symbol:
+            pytest.skip("formattedDisplay computed property not found - test fixture may need updating")
+
+        # Get a position inside the computed property body
+        computed_start_line = formatted_display_symbol["range"]["start"]["line"]
+        position_inside_computed = computed_start_line + 1
+        position_character = 4
+
+        # Request the containing symbol for this position
+        containing_symbol = language_server.request_containing_symbol(
+            file_path, position_inside_computed, position_character, include_body=True
+        )
+
+        # Verify we found the correct containing symbol
+        # The language server returns the arrow function inside computed() rather than
+        # the variable name. This is technically correct from LSP's perspective.
+        assert containing_symbol is not None, "Should find containing symbol inside computed property"
+        assert containing_symbol["name"] in [
+            "formattedDisplay",
+            "computed() callback",
+        ], f"Expected formattedDisplay or computed() callback, got {containing_symbol.get('name')}"
+        assert containing_symbol["kind"] in [
+            SymbolKind.Property,
+            SymbolKind.Variable,
+            SymbolKind.Function,
+        ], f"Expected property/variable/function kind for computed, got {containing_symbol.get('kind')}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_request_containing_symbol_no_containing_symbol(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Position in the import statements at the top of the script setup
+        # Line 1-6 contain imports in CalculatorInput.vue
+        import_line = 2
+        import_character = 10
+
+        # Request containing symbol for a position in the imports
+        containing_symbol = language_server.request_containing_symbol(file_path, import_line, import_character)
+
+        # Should return None or empty dictionary for positions without containing symbol
+        assert (
+            containing_symbol is None or containing_symbol == {}
+        ), f"Expected None or empty dict for import position, got {containing_symbol}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_request_referencing_symbols_store_function(self, language_server: SolidLanguageServer) -> None:
+        store_file = os.path.join("src", "stores", "calculator.ts")
+
+        # Find the 'add' action in the calculator store
+        symbols = language_server.request_document_symbols(store_file).get_all_symbols_and_roots()
+        add_symbol = next((s for s in symbols[0] if s.get("name") == "add"), None)
+
+        if not add_symbol or "selectionRange" not in add_symbol:
+            pytest.skip("add action not found in calculator store - test fixture may need updating")
+
+        # Request referencing symbols for the add action (include_self=True to get at least the definition)
+        sel_start = add_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol
+            for ref in language_server.request_referencing_symbols(store_file, sel_start["line"], sel_start["character"], include_self=True)
+        ]
+
+        assert isinstance(ref_symbols, list), f"request_referencing_symbols should return a list, got {type(ref_symbols)}"
+
+        for symbol in ref_symbols:
+            assert "name" in symbol, "Referencing symbol should have a name"
+            assert "kind" in symbol, "Referencing symbol should have a kind"
+
+        vue_refs = [
+            symbol for symbol in ref_symbols if "location" in symbol and "uri" in symbol["location"] and ".vue" in symbol["location"]["uri"]
+        ]
+
+        if len(vue_refs) > 0:
+            calculator_input_refs = [
+                ref
+                for ref in vue_refs
+                if "location" in ref and "uri" in ref["location"] and "CalculatorInput.vue" in ref["location"]["uri"]
+            ]
+            for ref in calculator_input_refs:
+                assert "name" in ref, "Reference should have name"
+                assert "location" in ref, "Reference should have location"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_request_referencing_symbols_composable(self, language_server: SolidLanguageServer) -> None:
+        composable_file = os.path.join("src", "composables", "useFormatter.ts")
+
+        # Find the useFormatter composable function
+        symbols = language_server.request_document_symbols(composable_file).get_all_symbols_and_roots()
+        use_formatter_symbol = next((s for s in symbols[0] if s.get("name") == "useFormatter"), None)
+
+        if not use_formatter_symbol or "selectionRange" not in use_formatter_symbol:
+            pytest.skip("useFormatter composable not found - test fixture may need updating")
+
+        # Request referencing symbols for the composable
+        sel_start = use_formatter_symbol["selectionRange"]["start"]
+        ref_symbols = [
+            ref.symbol for ref in language_server.request_referencing_symbols(composable_file, sel_start["line"], sel_start["character"])
+        ]
+
+        # Verify we found references - useFormatter is imported and used in CalculatorInput.vue
+        assert (
+            len(ref_symbols) >= 1
+        ), f"useFormatter should have at least 1 reference (used in CalculatorInput.vue), found {len(ref_symbols)} references"
+
+        # Check for references in Vue components
+        vue_refs = [
+            symbol for symbol in ref_symbols if "location" in symbol and "uri" in symbol["location"] and ".vue" in symbol["location"]["uri"]
+        ]
+
+        # CalculatorInput.vue imports and uses useFormatter
+        assert len(vue_refs) >= 1, f"Should find at least 1 Vue component reference to useFormatter, found {len(vue_refs)}"
+
+        # Verify we found reference in CalculatorInput.vue specifically
+        has_calculator_input_ref = any(
+            "CalculatorInput.vue" in ref["location"]["uri"] for ref in vue_refs if "location" in ref and "uri" in ref["location"]
+        )
+        assert has_calculator_input_ref, (
+            f"Should find reference to useFormatter in CalculatorInput.vue. "
+            f"Found references in: {[ref['location']['uri'] for ref in vue_refs if 'location' in ref and 'uri' in ref['location']]}"
+        )
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_vue_component_cross_references(self, language_server: SolidLanguageServer) -> None:
+        input_file = os.path.join("src", "components", "CalculatorInput.vue")
+        button_file = os.path.join("src", "components", "CalculatorButton.vue")
+
+        definitions = language_server.request_definition(input_file, 4, 10)
+
+        assert len(definitions) == 1, f"Should find exactly 1 definition for CalculatorButton import, got {len(definitions)}"
+        assert (
+            "CalculatorButton.vue" in definitions[0]["relativePath"]
+        ), f"Definition should point to CalculatorButton.vue, got {definitions[0]['relativePath']}"
+
+        refs = language_server.request_references(input_file, 4, 10)
+
+        assert len(refs) >= 2, (
+            f"Should find at least 2 references to CalculatorButton (import + template usages). "
+            f"In CalculatorInput.vue, CalculatorButton is imported and used ~7 times in template. Found {len(refs)} references"
+        )
+
+        button_symbols = language_server.request_document_symbols(button_file).get_all_symbols_and_roots()
+        symbol_names = [s.get("name") for s in button_symbols[0]]
+
+        assert "Props" in symbol_names, "CalculatorButton.vue should have Props interface"
+        assert "handleClick" in symbol_names, "CalculatorButton.vue should have handleClick function"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_request_defining_symbol_import_resolution(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        # Find the import position for useCalculatorStore
+        # In CalculatorInput.vue (0-indexed lines):
+        # Line 2: import { useCalculatorStore } from '@/stores/calculator'
+        # Line 8: const store = useCalculatorStore()
+        # We'll request definition at the position of "useCalculatorStore" in the usage line
+        defining_symbol = language_server.request_defining_symbol(file_path, 8, 18)
+
+        if defining_symbol is None:
+            # Some language servers may not support go-to-definition at usage sites
+            # Try at line 2 (import statement) instead
+            defining_symbol = language_server.request_defining_symbol(file_path, 2, 18)
+
+        # Verify we found a defining symbol
+        assert defining_symbol is not None, "Should find defining symbol for useCalculatorStore"
+        assert "name" in defining_symbol, "Defining symbol should have a name"
+        assert defining_symbol.get("name") in [
+            "useCalculatorStore",
+            "calculator",
+        ], f"Expected useCalculatorStore or calculator, got {defining_symbol.get('name')}"
+
+        # Verify it points to the store file
+        if "location" in defining_symbol and "uri" in defining_symbol["location"]:
+            assert (
+                "calculator.ts" in defining_symbol["location"]["uri"]
+            ), f"Should point to calculator.ts, got {defining_symbol['location']['uri']}"
+
+    @pytest.mark.parametrize("language_server", [Language.VUE], indirect=True)
+    def test_request_defining_symbol_component_import(self, language_server: SolidLanguageServer) -> None:
+        file_path = os.path.join("src", "components", "CalculatorInput.vue")
+
+        definitions = language_server.request_definition(file_path, 4, 10)
+
+        assert len(definitions) > 0, "Should find definition for CalculatorButton import"
+
+        definition = definitions[0]
+        assert definition["relativePath"] is not None, "Definition should have a relative path"
+        assert (
+            "CalculatorButton.vue" in definition["relativePath"]
+        ), f"Should point to CalculatorButton.vue, got {definition['relativePath']}"
+
+        assert definition["range"]["start"]["line"] == 0, "Definition should point to start of .vue file"
+
+        defining_symbol = language_server.request_defining_symbol(file_path, 4, 10)
+        assert defining_symbol is None or "name" in defining_symbol, "If defining_symbol is found, it should have a name"