golf-mcp 0.1.20__py3-none-any.whl → 0.2.0__py3-none-any.whl

golf/core/builder.py

@@ -9,15 +9,14 @@ from typing import Any
 
 import black
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
 
-from golf.auth import get_auth_config
+from golf.auth import is_auth_configured
 from golf.auth.api_key import get_api_key_config
 from golf.core.builder_auth import generate_auth_code, generate_auth_routes
 from golf.core.builder_telemetry import (
     generate_telemetry_imports,
-    get_otel_dependencies,
 )
+from golf.cli.branding import create_build_header, get_status_text, STATUS_ICONS, GOLF_BLUE
 from golf.core.config import Settings
 from golf.core.parser import (
     ComponentType,
@@ -109,9 +108,7 @@ class ManifestBuilder:
         """Process all resource components and add them to the manifest."""
         for component in self.components[ComponentType.RESOURCE]:
             if not component.uri_template:
-                console.print(
-                    f"[yellow]Warning: Resource {component.name} has no URI template[/yellow]"
-                )
+                console.print(f"[yellow]Warning: Resource {component.name} has no URI template[/yellow]")
                 continue
 
             resource_schema = {
@@ -127,7 +124,8 @@ class ManifestBuilder:
     def _process_prompts(self) -> None:
         """Process all prompt components and add them to the manifest."""
         for component in self.components[ComponentType.PROMPT]:
-            # For prompts, the handler will have to load the module and execute the run function
+            # For prompts, the handler will have to load the module and execute
+            # the run function
             # to get the actual messages, so we just register it by name
             prompt_schema = {
                 "name": component.name,
@@ -188,9 +186,7 @@ def build_manifest(project_path: Path, settings: Settings) -> dict[str, Any]:
     return builder.build()
 
 
-def compute_manifest_diff(
-    old_manifest: dict[str, Any], new_manifest: dict[str, Any]
-) -> dict[str, Any]:
+def compute_manifest_diff(old_manifest: dict[str, Any], new_manifest: dict[str, Any]) -> dict[str, Any]:
     """Compute the difference between two manifests.
 
     Args:
@@ -221,11 +217,7 @@ def compute_manifest_diff(
         if new_tool["name"] in old_tools:
             # Find the corresponding old tool
             old_tool = next(
-                (
-                    t
-                    for t in old_manifest.get("tools", [])
-                    if t["name"] == new_tool["name"]
-                ),
+                (t for t in old_manifest.get("tools", []) if t["name"] == new_tool["name"]),
                 None,
             )
             if old_tool and json.dumps(old_tool) != json.dumps(new_tool):
@@ -242,11 +234,7 @@ def compute_manifest_diff(
         if new_resource["name"] in old_resources:
             # Find the corresponding old resource
             old_resource = next(
-                (
-                    r
-                    for r in old_manifest.get("resources", [])
-                    if r["name"] == new_resource["name"]
-                ),
+                (r for r in old_manifest.get("resources", []) if r["name"] == new_resource["name"]),
                 None,
             )
             if old_resource and json.dumps(old_resource) != json.dumps(new_resource):
@@ -263,11 +251,7 @@ def compute_manifest_diff(
         if new_prompt["name"] in old_prompts:
             # Find the corresponding old prompt
             old_prompt = next(
-                (
-                    p
-                    for p in old_manifest.get("prompts", [])
-                    if p["name"] == new_prompt["name"]
-                ),
+                (p for p in old_manifest.get("prompts", []) if p["name"] == new_prompt["name"]),
                 None,
             )
             if old_prompt and json.dumps(old_prompt) != json.dumps(new_prompt):
@@ -320,7 +304,7 @@ class CodeGenerator:
         self.copy_env = copy_env
         self.components = {}
         self.manifest = {}
-        self.common_files = {}
+        self.shared_files = {}
         self.import_map = {}
 
     def generate(self) -> None:
@@ -330,42 +314,39 @@ class CodeGenerator:
             self.components = parse_project(self.project_path)
             self.manifest = build_manifest(self.project_path, self.settings)
 
-            # Find common.py files and build import map
-            self.common_files = find_common_files(self.project_path, self.components)
-            self.import_map = build_import_map(self.project_path, self.common_files)
+            # Find shared Python files and build import map
+            from golf.core.parser import parse_shared_files
+
+            self.shared_files = parse_shared_files(self.project_path)
+            self.import_map = build_import_map(self.project_path, self.shared_files)
 
         # Create output directory structure
         with console.status("Creating directory structure..."):
             self._create_directory_structure()
 
         # Generate code for all components
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[bold green]Generating {task.description}"),
-            console=console,
-        ) as progress:
-            tasks = [
-                ("tools", self._generate_tools),
-                ("resources", self._generate_resources),
-                ("prompts", self._generate_prompts),
-                ("server entry point", self._generate_server),
-            ]
+        tasks = [
+            ("Generating tools", self._generate_tools),
+            ("Generating resources", self._generate_resources),
+            ("Generating prompts", self._generate_prompts),
+            ("Generating server entry point", self._generate_server),
+        ]
 
-            for description, func in tasks:
-                task = progress.add_task(description, total=1)
-                func()
-                progress.update(task, completed=1)
+        for description, func in tasks:
+            console.print(get_status_text("generating", description))
+            func()
 
         # Get relative path for display
         try:
             output_dir_display = self.output_dir.relative_to(Path.cwd())
-        except ValueError:
+        except (ValueError, FileNotFoundError, OSError):
+            # ValueError: paths don't have a common base
+            # FileNotFoundError/OSError: current directory was deleted
             output_dir_display = self.output_dir
 
         # Show success message with output directory
-        console.print(
-            f"[bold green]✓[/bold green] Build completed successfully in [bold]{output_dir_display}[/bold]"
-        )
+        console.print()
+        console.print(get_status_text("success", f"Build completed successfully in {output_dir_display}"))
 
     def _create_directory_structure(self) -> None:
         """Create the output directory structure"""
@@ -380,19 +361,20 @@ class CodeGenerator:
 
         for directory in dirs:
             directory.mkdir(parents=True, exist_ok=True)
-        # Process common.py files directly in the components directory
-        self._process_common_files()
+        # Process shared files directly in the components directory
+        self._process_shared_files()
 
-    def _process_common_files(self) -> None:
-        """Process and transform common.py files in the components directory structure."""
-        # Reuse the already fetched common_files instead of calling the function again
-        for dir_path_str, common_file in self.common_files.items():
-            # Convert string path to Path object
-            dir_path = Path(dir_path_str)
+    def _process_shared_files(self) -> None:
+        """Process and transform shared Python files in the components directory
+        structure."""
+        # Process all shared files
+        for module_path_str, shared_file in self.shared_files.items():
+            # Convert module path to Path object (e.g., "tools/weather/helpers")
+            module_path = Path(module_path_str)
 
             # Determine the component type
             component_type = None
-            for part in dir_path.parts:
+            for part in module_path.parts:
                 if part in ["tools", "resources", "prompts"]:
                     component_type = part
                     break
@@ -401,16 +383,14 @@ class CodeGenerator:
                 continue
 
             # Calculate target directory in components structure
-            rel_to_component = dir_path.relative_to(component_type)
-            target_dir = (
-                self.output_dir / "components" / component_type / rel_to_component
-            )
+            rel_to_component = module_path.relative_to(component_type)
+            target_dir = self.output_dir / "components" / component_type / rel_to_component.parent
 
             # Create directory if it doesn't exist
             target_dir.mkdir(parents=True, exist_ok=True)
 
-            # Create the common.py file in the target directory
-            target_file = target_dir / "common.py"
+            # Create the shared file in the target directory (preserve original filename)
+            target_file = target_dir / shared_file.name
 
             # Use transformer to process the file
             transform_component(
@@ -418,7 +398,7 @@ class CodeGenerator:
                 output_file=target_file,
                 project_path=self.project_path,
                 import_map=self.import_map,
-                source_file=common_file,
+                source_file=shared_file,
             )
 
     def _generate_tools(self) -> None:
@@ -429,9 +409,7 @@ class CodeGenerator:
             # Get the tool directory structure
             rel_path = Path(tool.file_path).relative_to(self.project_path)
             if not rel_path.is_relative_to(Path(self.settings.tools_dir)):
-                console.print(
-                    f"[yellow]Warning: Tool {tool.name} is not in the tools directory[/yellow]"
-                )
+                console.print(f"[yellow]Warning: Tool {tool.name} is not in the tools directory[/yellow]")
                 continue
 
             try:
@@ -455,9 +433,7 @@ class CodeGenerator:
             # Get the resource directory structure
             rel_path = Path(resource.file_path).relative_to(self.project_path)
             if not rel_path.is_relative_to(Path(self.settings.resources_dir)):
-                console.print(
-                    f"[yellow]Warning: Resource {resource.name} is not in the resources directory[/yellow]"
-                )
+                console.print(f"[yellow]Warning: Resource {resource.name} is not in the resources directory[/yellow]")
                 continue
 
             try:
@@ -471,9 +447,7 @@ class CodeGenerator:
 
             # Create the resource file
             output_file = resource_dir / rel_path.name
-            transform_component(
-                resource, output_file, self.project_path, self.import_map
-            )
+            transform_component(resource, output_file, self.project_path, self.import_map)
 
     def _generate_prompts(self) -> None:
         """Generate code for all prompts."""
@@ -483,9 +457,7 @@ class CodeGenerator:
             # Get the prompt directory structure
             rel_path = Path(prompt.file_path).relative_to(self.project_path)
             if not rel_path.is_relative_to(Path(self.settings.prompts_dir)):
-                console.print(
-                    f"[yellow]Warning: Prompt {prompt.name} is not in the prompts directory[/yellow]"
-                )
+                console.print(f"[yellow]Warning: Prompt {prompt.name} is not in the prompts directory[/yellow]")
                 continue
 
             try:
@@ -520,16 +492,30 @@ class CodeGenerator:
             config["endpoint_path"] = ""  # No HTTP endpoint
         else:
             # Default to streamable-http
-            config["endpoint_path"] = "/mcp"  # Default MCP path for FastMCP
+            config["endpoint_path"] = "/mcp/"  # Default MCP path for FastMCP
 
         return config
 
+    def _is_resource_template(self, component: ParsedComponent) -> bool:
+        """Check if a resource component is a template (has URI parameters).
+
+        Args:
+            component: The parsed component to check
+
+        Returns:
+            True if the resource has URI parameters, False otherwise
+        """
+        return (
+            component.type == ComponentType.RESOURCE
+            and component.parameters is not None
+            and len(component.parameters) > 0
+        )
+
     def _generate_server(self) -> None:
         """Generate the main server entry point."""
         server_file = self.output_dir / "server.py"
 
         # Get auth components
-        provider_config, _ = get_auth_config()
         auth_components = generate_auth_code(
             server_name=self.settings.name,
             host=self.settings.host,
@@ -542,14 +528,20 @@ class CodeGenerator:
         # Create imports section
         imports = [
             "from fastmcp import FastMCP",
+            "from fastmcp.tools import Tool",
+            "from fastmcp.resources import Resource, ResourceTemplate",
+            "from fastmcp.prompts import Prompt",
             "import os",
             "import sys",
             "from dotenv import load_dotenv",
             "import logging",
             "",
             "# Suppress FastMCP INFO logs",
-            "logging.getLogger('fastmcp').setLevel(logging.WARNING)",
-            "logging.getLogger('mcp').setLevel(logging.WARNING)",
+            "logging.getLogger('FastMCP').setLevel(logging.ERROR)",
+            "logging.getLogger('mcp').setLevel(logging.ERROR)",
+            "",
+            "# Golf utilities for MCP features (available for tool functions)",
+            "# from golf.utilities import elicit, sample, get_current_context",
             "",
         ]
 
@@ -615,11 +607,7 @@ class CodeGenerator:
                         rel_to_tools = rel_path.relative_to(self.settings.tools_dir)
                         # Handle nested directories properly
                         if rel_to_tools.parent != Path("."):
-                            parent_path = (
-                                str(rel_to_tools.parent)
-                                .replace("\\", ".")
-                                .replace("/", ".")
-                            )
+                            parent_path = str(rel_to_tools.parent).replace("\\", ".").replace("/", ".")
                             import_path = f"components.tools.{parent_path}"
                         else:
                             import_path = "components.tools"
@@ -627,16 +615,10 @@ class CodeGenerator:
                         import_path = "components.tools"
                 elif component_type == ComponentType.RESOURCE:
                     try:
-                        rel_to_resources = rel_path.relative_to(
-                            self.settings.resources_dir
-                        )
+                        rel_to_resources = rel_path.relative_to(self.settings.resources_dir)
                         # Handle nested directories properly
                         if rel_to_resources.parent != Path("."):
-                            parent_path = (
-                                str(rel_to_resources.parent)
-                                .replace("\\", ".")
-                                .replace("/", ".")
-                            )
+                            parent_path = str(rel_to_resources.parent).replace("\\", ".").replace("/", ".")
                             import_path = f"components.resources.{parent_path}"
                         else:
                             import_path = "components.resources"
@@ -647,11 +629,7 @@ class CodeGenerator:
                         rel_to_prompts = rel_path.relative_to(self.settings.prompts_dir)
                         # Handle nested directories properly
                         if rel_to_prompts.parent != Path("."):
-                            parent_path = (
-                                str(rel_to_prompts.parent)
-                                .replace("\\", ".")
-                                .replace("/", ".")
-                            )
+                            parent_path = str(rel_to_prompts.parent).replace("\\", ".").replace("/", ".")
                             import_path = f"components.prompts.{parent_path}"
                         else:
                             import_path = "components.prompts"
@@ -668,14 +646,10 @@ class CodeGenerator:
                 # Add code to register this component
                 if self.settings.opentelemetry_enabled:
                     # Use telemetry instrumentation
-                    registration = (
-                        f"# Register the {component_type.value} "
-                        f"'{component.name}' with telemetry"
-                    )
+                    registration = f"# Register the {component_type.value} '{component.name}' with telemetry"
                     entry_func = (
                         component.entry_function
-                        if hasattr(component, "entry_function")
-                        and component.entry_function
+                        if hasattr(component, "entry_function") and component.entry_function
                         else "export"
                     )
 
@@ -686,34 +660,42 @@ class CodeGenerator:
 
                     if component_type == ComponentType.TOOL:
                         registration += (
-                            f'\nmcp.add_tool(_wrapped_func, name="{component.name}", '
-                            f'description="{component.docstring or ""}"'
+                            f"\n_tool = Tool.from_function(_wrapped_func, "
+                            f'name="{component.name}", '
+                            f'description="{component.docstring or ""}")'
                         )
                         # Add annotations if present
                         if hasattr(component, "annotations") and component.annotations:
-                            registration += f", annotations={component.annotations}"
-                        registration += ")"
+                            registration += f".with_annotations({component.annotations})"
+                        registration += "\nmcp.add_tool(_tool)"
                     elif component_type == ComponentType.RESOURCE:
-                        registration += (
-                            f"\nmcp.add_resource_fn(_wrapped_func, "
-                            f'uri="{component.uri_template}", name="{component.name}", '
-                            f'description="{component.docstring or ""}")'
-                        )
+                        if self._is_resource_template(component):
+                            registration += (
+                                f"\n_template = ResourceTemplate.from_function(_wrapped_func, "
+                                f'uri_template="{component.uri_template}", name="{component.name}", '
+                                f'description="{component.docstring or ""}")\n'
+                                f"mcp.add_template(_template)"
+                            )
+                        else:
+                            registration += (
+                                f"\n_resource = Resource.from_function(_wrapped_func, "
+                                f'uri="{component.uri_template}", name="{component.name}", '
+                                f'description="{component.docstring or ""}")\n'
+                                f"mcp.add_resource(_resource)"
+                            )
                     else:  # PROMPT
                         registration += (
-                            f'\nmcp.add_prompt(_wrapped_func, name="{component.name}", '
-                            f'description="{component.docstring or ""}")'
+                            f"\n_prompt = Prompt.from_function(_wrapped_func, "
+                            f'name="{component.name}", '
+                            f'description="{component.docstring or ""}")\n'
+                            f"mcp.add_prompt(_prompt)"
                         )
                 elif self.settings.metrics_enabled:
                     # Use metrics instrumentation
-                    registration = (
-                        f"# Register the {component_type.value} "
-                        f"'{component.name}' with metrics"
-                    )
+                    registration = f"# Register the {component_type.value} '{component.name}' with metrics"
                     entry_func = (
                         component.entry_function
-                        if hasattr(component, "entry_function")
-                        and component.entry_function
+                        if hasattr(component, "entry_function") and component.entry_function
                         else "export"
                     )
 
@@ -724,37 +706,49 @@ class CodeGenerator:
 
                     if component_type == ComponentType.TOOL:
                         registration += (
-                            f'\nmcp.add_tool(_wrapped_func, name="{component.name}", '
-                            f'description="{component.docstring or ""}"'
+                            f"\n_tool = Tool.from_function(_wrapped_func, "
+                            f'name="{component.name}", '
+                            f'description="{component.docstring or ""}")'
                         )
                         # Add annotations if present
                         if hasattr(component, "annotations") and component.annotations:
-                            registration += f", annotations={component.annotations}"
-                        registration += ")"
+                            registration += f".with_annotations({component.annotations})"
+                        registration += "\nmcp.add_tool(_tool)"
                     elif component_type == ComponentType.RESOURCE:
-                        registration += (
-                            f"\nmcp.add_resource_fn(_wrapped_func, "
-                            f'uri="{component.uri_template}", name="{component.name}", '
-                            f'description="{component.docstring or ""}")'
-                        )
+                        if self._is_resource_template(component):
+                            registration += (
+                                f"\n_template = ResourceTemplate.from_function(_wrapped_func, "
+                                f'uri_template="{component.uri_template}", name="{component.name}", '
+                                f'description="{component.docstring or ""}")\n'
+                                f"mcp.add_template(_template)"
+                            )
+                        else:
+                            registration += (
+                                f"\n_resource = Resource.from_function(_wrapped_func, "
+                                f'uri="{component.uri_template}", name="{component.name}", '
+                                f'description="{component.docstring or ""}")\n'
+                                f"mcp.add_resource(_resource)"
+                            )
                     else:  # PROMPT
                         registration += (
-                            f'\nmcp.add_prompt(_wrapped_func, name="{component.name}", '
-                            f'description="{component.docstring or ""}")'
+                            f"\n_prompt = Prompt.from_function(_wrapped_func, "
+                            f'name="{component.name}", '
+                            f'description="{component.docstring or ""}")\n'
+                            f"mcp.add_prompt(_prompt)"
                         )
                 else:
                     # Standard registration without telemetry
                     if component_type == ComponentType.TOOL:
                         registration = f"# Register the tool '{component.name}' from {full_module_path}"
 
-                        # Use the entry_function if available, otherwise try the export variable
-                        if (
-                            hasattr(component, "entry_function")
-                            and component.entry_function
-                        ):
-                            registration += f"\nmcp.add_tool({full_module_path}.{component.entry_function}"
+                        # Use the entry_function if available, otherwise try the
+                        # export variable
+                        if hasattr(component, "entry_function") and component.entry_function:
+                            registration += (
+                                f"\n_tool = Tool.from_function({full_module_path}.{component.entry_function}"
+                            )
                         else:
-                            registration += f"\nmcp.add_tool({full_module_path}.export"
+                            registration += f"\n_tool = Tool.from_function({full_module_path}.export"
 
                         # Add the name parameter
                         registration += f', name="{component.name}"'
@@ -765,48 +759,85 @@ class CodeGenerator:
                             escaped_docstring = component.docstring.replace('"', '\\"')
                             registration += f', description="{escaped_docstring}"'
 
+                        registration += ")"
+
                         # Add annotations if present
                         if hasattr(component, "annotations") and component.annotations:
-                            registration += f", annotations={component.annotations}"
+                            registration += f"\n_tool = _tool.with_annotations({component.annotations})"
 
-                        registration += ")"
+                        registration += "\nmcp.add_tool(_tool)"
 
                     elif component_type == ComponentType.RESOURCE:
-                        registration = f"# Register the resource '{component.name}' from {full_module_path}"
-
-                        # Use the entry_function if available, otherwise try the export variable
-                        if (
-                            hasattr(component, "entry_function")
-                            and component.entry_function
-                        ):
-                            registration += f'\nmcp.add_resource_fn({full_module_path}.{component.entry_function}, uri="{component.uri_template}"'
-                        else:
-                            registration += f'\nmcp.add_resource_fn({full_module_path}.export, uri="{component.uri_template}"'
-
-                        # Add the name parameter
-                        registration += f', name="{component.name}"'
-
-                        # Add description from docstring
-                        if component.docstring:
-                            # Escape any quotes in the docstring
-                            escaped_docstring = component.docstring.replace('"', '\\"')
-                            registration += f', description="{escaped_docstring}"'
+                        if self._is_resource_template(component):
+                            registration = (
+                                f"# Register the resource template '{component.name}' from {full_module_path}"
+                            )
 
-                        registration += ")"
+                            # Use the entry_function if available, otherwise try the
+                            # export variable
+                            if hasattr(component, "entry_function") and component.entry_function:
+                                registration += (
+                                    f"\n_template = ResourceTemplate.from_function("
+                                    f"{full_module_path}.{component.entry_function}, "
+                                    f'uri_template="{component.uri_template}"'
+                                )
+                            else:
+                                registration += (
+                                    f"\n_template = ResourceTemplate.from_function("
+                                    f"{full_module_path}.export, "
+                                    f'uri_template="{component.uri_template}"'
+                                )
+
+                            # Add the name parameter
+                            registration += f', name="{component.name}"'
+
+                            # Add description from docstring
+                            if component.docstring:
+                                # Escape any quotes in the docstring
+                                escaped_docstring = component.docstring.replace('"', '\\"')
+                                registration += f', description="{escaped_docstring}"'
+
+                            registration += ")\nmcp.add_template(_template)"
+                        else:
+                            registration = f"# Register the resource '{component.name}' from {full_module_path}"
+
+                            # Use the entry_function if available, otherwise try the
+                            # export variable
+                            if hasattr(component, "entry_function") and component.entry_function:
+                                registration += (
+                                    f"\n_resource = Resource.from_function("
+                                    f"{full_module_path}.{component.entry_function}, "
+                                    f'uri="{component.uri_template}"'
+                                )
+                            else:
+                                registration += (
+                                    f"\n_resource = Resource.from_function("
+                                    f"{full_module_path}.export, "
+                                    f'uri="{component.uri_template}"'
+                                )
+
+                            # Add the name parameter
+                            registration += f', name="{component.name}"'
+
+                            # Add description from docstring
+                            if component.docstring:
+                                # Escape any quotes in the docstring
+                                escaped_docstring = component.docstring.replace('"', '\\"')
+                                registration += f', description="{escaped_docstring}"'
+
+                            registration += ")\nmcp.add_resource(_resource)"
 
                     else:  # PROMPT
                         registration = f"# Register the prompt '{component.name}' from {full_module_path}"
 
-                        # Use the entry_function if available, otherwise try the export variable
-                        if (
-                            hasattr(component, "entry_function")
-                            and component.entry_function
-                        ):
-                            registration += f"\nmcp.add_prompt({full_module_path}.{component.entry_function}"
-                        else:
+                        # Use the entry_function if available, otherwise try the
+                        # export variable
+                        if hasattr(component, "entry_function") and component.entry_function:
                             registration += (
-                                f"\nmcp.add_prompt({full_module_path}.export"
+                                f"\n_prompt = Prompt.from_function({full_module_path}.{component.entry_function}"
                             )
+                        else:
+                            registration += f"\n_prompt = Prompt.from_function({full_module_path}.export"
 
                         # Add the name parameter
                         registration += f', name="{component.name}"'
@@ -817,7 +848,7 @@ class CodeGenerator:
                             escaped_docstring = component.docstring.replace('"', '\\"')
                             registration += f', description="{escaped_docstring}"'
 
-                        registration += ")"
+                        registration += ")\nmcp.add_prompt(_prompt)"
 
                 component_registrations.append(registration)
 
@@ -870,8 +901,9 @@ class CodeGenerator:
             early_telemetry_init.extend(
                 [
                     "# Initialize telemetry early to ensure instrumentation works",
-                    "from golf.telemetry.instrumentation import init_telemetry",
+                    "from golf.telemetry.instrumentation import init_telemetry, set_detailed_tracing",
                     f'init_telemetry("{self.settings.name}")',
+                    f"set_detailed_tracing({self.settings.detailed_tracing})",
                     "",
                 ]
             )
@@ -881,9 +913,7 @@ class CodeGenerator:
         if self.settings.metrics_enabled:
             from golf.core.builder_metrics import generate_metrics_initialization
 
-            early_metrics_init.extend(
-                generate_metrics_initialization(self.settings.name)
-            )
+            early_metrics_init.extend(generate_metrics_initialization(self.settings.name))
 
         # Main entry point with transport-specific app initialization
         main_code = [
@@ -892,22 +922,12 @@ class CodeGenerator:
             "    from rich.panel import Panel",
             "    console = Console()",
             "    # Get configuration from environment variables or use defaults",
-            '    host = os.environ.get("HOST", "127.0.0.1")',
+            '    host = os.environ.get("HOST", "localhost")',
             '    port = int(os.environ.get("PORT", 3000))',
             f'    transport_to_run = "{self.settings.transport}"',
             "",
         ]
 
-        # Add startup message
-        if self.settings.transport != "stdio":
-            main_code.append(
-                f'    console.print(Panel.fit(f"[bold green]{{mcp.name}}[/bold green]\\n[dim]Running on http://{{host}}:{{port}}{endpoint_path} with transport \\"{{transport_to_run}}\\" (environment: {self.build_env})[/dim]", border_style="green"))'
-            )
-        else:
-            main_code.append(
-                f'    console.print(Panel.fit(f"[bold green]{{mcp.name}}[/bold green]\\n[dim]Running with transport \\"{{transport_to_run}}\\" (environment: {self.build_env})[/dim]", border_style="green"))'
-            )
-
         main_code.append("")
 
         # Transport-specific run methods
@@ -918,26 +938,18 @@ class CodeGenerator:
 
             api_key_config = get_api_key_config()
             if auth_components.get("has_auth") and api_key_config:
-                middleware_setup.append(
-                    "    from starlette.middleware import Middleware"
-                )
+                middleware_setup.append("    from starlette.middleware import Middleware")
                 middleware_list.append("Middleware(ApiKeyMiddleware)")
 
             # Add metrics middleware if enabled
             if self.settings.metrics_enabled:
-                middleware_setup.append(
-                    "    from starlette.middleware import Middleware"
-                )
+                middleware_setup.append("    from starlette.middleware import Middleware")
                 middleware_list.append("Middleware(MetricsMiddleware)")
 
             # Add OpenTelemetry middleware if enabled
             if self.settings.opentelemetry_enabled:
-                middleware_setup.append(
-                    "    from opentelemetry.instrumentation.asgi import OpenTelemetryMiddleware"
-                )
-                middleware_setup.append(
-                    "    from starlette.middleware import Middleware"
-                )
+                middleware_setup.append("    from opentelemetry.instrumentation.asgi import OpenTelemetryMiddleware")
+                middleware_setup.append("    from starlette.middleware import Middleware")
                 middleware_list.append("Middleware(OpenTelemetryMiddleware)")
 
             if middleware_setup:
@@ -947,14 +959,18 @@ class CodeGenerator:
                 main_code.extend(
                     [
                         "    # Run SSE server with middleware using FastMCP's run method",
-                        '    mcp.run(transport="sse", host=host, port=port, log_level="info", middleware=middleware)',
+                        f'    mcp.run(transport="sse", host=host, port=port, '
+                        f'path="{endpoint_path}", log_level="info", '
+                        f"middleware=middleware, show_banner=False)",
                     ]
                 )
             else:
                 main_code.extend(
                     [
                         "    # Run SSE server using FastMCP's run method",
-                        '    mcp.run(transport="sse", host=host, port=port, log_level="info")',
+                        f'    mcp.run(transport="sse", host=host, port=port, '
+                        f'path="{endpoint_path}", log_level="info", '
+                        f"show_banner=False)",
                     ]
                 )
 
@@ -965,26 +981,18 @@ class CodeGenerator:
 
             api_key_config = get_api_key_config()
             if auth_components.get("has_auth") and api_key_config:
-                middleware_setup.append(
-                    "    from starlette.middleware import Middleware"
-                )
+                middleware_setup.append("    from starlette.middleware import Middleware")
                 middleware_list.append("Middleware(ApiKeyMiddleware)")
 
             # Add metrics middleware if enabled
             if self.settings.metrics_enabled:
-                middleware_setup.append(
-                    "    from starlette.middleware import Middleware"
-                )
+                middleware_setup.append("    from starlette.middleware import Middleware")
                 middleware_list.append("Middleware(MetricsMiddleware)")
 
             # Add OpenTelemetry middleware if enabled
             if self.settings.opentelemetry_enabled:
-                middleware_setup.append(
-                    "    from opentelemetry.instrumentation.asgi import OpenTelemetryMiddleware"
-                )
-                middleware_setup.append(
-                    "    from starlette.middleware import Middleware"
-                )
+                middleware_setup.append("    from opentelemetry.instrumentation.asgi import OpenTelemetryMiddleware")
+                middleware_setup.append("    from starlette.middleware import Middleware")
                 middleware_list.append("Middleware(OpenTelemetryMiddleware)")
 
             if middleware_setup:
@@ -994,21 +1002,23 @@ class CodeGenerator:
                 main_code.extend(
                     [
                         "    # Run HTTP server with middleware using FastMCP's run method",
-                        '    mcp.run(transport="streamable-http", host=host, port=port, log_level="info", middleware=middleware)',
+                        f'    mcp.run(transport="streamable-http", host=host, '
+                        f'port=port, path="{endpoint_path}", log_level="info", '
+                        f"middleware=middleware, show_banner=False)",
                     ]
                 )
             else:
                 main_code.extend(
                     [
                         "    # Run HTTP server using FastMCP's run method",
-                        '    mcp.run(transport="streamable-http", host=host, port=port, log_level="info")',
+                        f'    mcp.run(transport="streamable-http", host=host, '
+                        f'port=port, path="{endpoint_path}", log_level="info", '
+                        f"show_banner=False)",
                     ]
                 )
         else:
             # For stdio transport, use mcp.run()
-            main_code.extend(
-                ["    # Run with stdio transport", '    mcp.run(transport="stdio")']
-            )
+            main_code.extend(["    # Run with stdio transport", '    mcp.run(transport="stdio", show_banner=False)'])
 
         # Add metrics route if enabled
         metrics_route_code = []
@@ -1022,18 +1032,17 @@ class CodeGenerator:
         if self.settings.health_check_enabled:
             health_check_code = [
                 "# Add health check route",
-                "@mcp.custom_route('"
-                + self.settings.health_check_path
-                + '\', methods=["GET"])',
+                "@mcp.custom_route('" + self.settings.health_check_path + '\', methods=["GET"])',
                 "async def health_check(request: Request) -> PlainTextResponse:",
                 '    """Health check endpoint for Kubernetes and load balancers."""',
-                f'    return PlainTextResponse("{self.settings.health_check_response}")',
+                (f'    return PlainTextResponse("{self.settings.health_check_response}")'),
                 "",
             ]
 
         # Combine all sections
         # Order: imports, env_section, auth_setup, server_code (mcp init),
-        # early_telemetry_init, early_metrics_init, component_registrations, metrics_route_code, health_check_code, main_code (run block)
+        # early_telemetry_init, early_metrics_init, component_registrations,
+        # metrics_route_code, health_check_code, main_code (run block)
         code = "\n".join(
             imports
             + env_section
@@ -1089,66 +1098,81 @@ def build_project(
         if has_api_key and has_server_id:
             console.print("[dim]Loaded Golf credentials for build operations[/dim]")
 
-    # Execute pre_build.py if it exists
-    pre_build_path = project_path / "pre_build.py"
-    if pre_build_path.exists():
+    # Execute auth.py if it exists (for authentication configuration)
+    # Also support legacy pre_build.py for backward compatibility
+    auth_path = project_path / "auth.py"
+    legacy_path = project_path / "pre_build.py"
+
+    config_path = None
+    if auth_path.exists():
+        config_path = auth_path
+    elif legacy_path.exists():
+        config_path = legacy_path
+        console.print("[yellow]Warning: pre_build.py is deprecated. Rename to auth.py[/yellow]")
+
+    if config_path:
+        # Save the current directory and path - handle case where cwd might be invalid
         try:
-            # Save the current directory and path
             original_dir = os.getcwd()
-            original_path = sys.path.copy()
+        except (FileNotFoundError, OSError):
+            # Current directory might have been deleted by previous operations,
+            # use project_path as fallback
+            original_dir = str(project_path)
+            os.chdir(original_dir)
+        original_path = sys.path.copy()
 
+        try:
             # Change to the project directory and add it to Python path
             os.chdir(project_path)
             sys.path.insert(0, str(project_path))
 
-            # Execute the pre_build script
-            with open(pre_build_path) as f:
+            # Execute the auth configuration script
+            with open(config_path) as f:
                 script_content = f.read()
 
             # Print the first few lines for debugging
             "\n".join(script_content.split("\n")[:5]) + "\n..."
 
             # Use exec to run the script as a module
-            code = compile(script_content, str(pre_build_path), "exec")
+            code = compile(script_content, str(config_path), "exec")
             exec(code, {})
 
-            # Check if auth was configured by the script
-            provider, scopes = get_auth_config()
-
-            # Restore original directory and path
-            os.chdir(original_dir)
-            sys.path = original_path
-
         except Exception as e:
-            console.print(f"[red]Error executing pre_build.py: {str(e)}[/red]")
+            console.print(f"[red]Error executing {config_path.name}: {str(e)}[/red]")
             import traceback
 
             console.print(f"[red]{traceback.format_exc()}[/red]")
 
-            # Track detailed error for pre_build.py execution failures
+            # Track detailed error for auth.py execution failures
             try:
                 from golf.core.telemetry import track_detailed_error
 
                 track_detailed_error(
-                    "build_pre_build_failed",
+                    "build_auth_failed",
                     e,
-                    context="Executing pre_build.py configuration script",
-                    operation="pre_build_execution",
+                    context=f"Executing {config_path.name} configuration script",
+                    operation="auth_execution",
                     additional_props={
-                        "file_path": str(pre_build_path.relative_to(project_path)),
+                        "file_path": str(config_path.relative_to(project_path)),
                         "build_env": build_env,
                     },
                 )
             except Exception:
                 # Don't let telemetry errors break the build
                 pass
+        finally:
+            # Always restore original directory and path, even if an exception occurred
+            try:
+                os.chdir(original_dir)
+                sys.path = original_path
+            except Exception:
+                # If we can't restore the directory, at least try to reset the path
+                sys.path = original_path
 
     # Clear the output directory if it exists
     if output_dir.exists():
         shutil.rmtree(output_dir)
-    output_dir.mkdir(
-        parents=True, exist_ok=True
-    )  # Ensure output_dir exists after clearing
+    output_dir.mkdir(parents=True, exist_ok=True)  # Ensure output_dir exists after clearing
 
     # --- BEGIN Enhanced .env handling ---
     env_vars_to_write = {}
@@ -1164,38 +1188,36 @@ def build_project(
                 env_vars_to_write.update(dotenv_values(project_env_file))
             except ImportError:
                 console.print(
-                    "[yellow]Warning: python-dotenv is not installed. Cannot read existing .env file for rich merging. Copying directly.[/yellow]"
+                    "[yellow]Warning: python-dotenv is not installed. "
+                    "Cannot read existing .env file for rich merging. "
+                    "Copying directly.[/yellow]"
                 )
                 try:
                     shutil.copy(project_env_file, env_file_path)
-                    # If direct copy happens, re-read for step 2 & 3 to respect its content
+                    # If direct copy happens, re-read for step 2 & 3 to respect
+                    # its content
                     if env_file_path.exists():
                         from dotenv import dotenv_values
 
-                        env_vars_to_write.update(
-                            dotenv_values(env_file_path)
-                        )  # Read what was copied
+                        env_vars_to_write.update(dotenv_values(env_file_path))  # Read what was copied
                 except Exception as e:
-                    console.print(
-                        f"[yellow]Warning: Could not copy project .env file: {e}[/yellow]"
-                    )
+                    console.print(f"[yellow]Warning: Could not copy project .env file: {e}[/yellow]")
             except Exception as e:
-                console.print(
-                    f"[yellow]Warning: Error reading project .env file content: {e}[/yellow]"
-                )
+                console.print(f"[yellow]Warning: Error reading project .env file content: {e}[/yellow]")
 
-    # 2. Apply Golf's OTel default exporter setting if OTEL_TRACES_EXPORTER is not already set
-    if settings.opentelemetry_enabled and settings.opentelemetry_default_exporter:
-        if "OTEL_TRACES_EXPORTER" not in env_vars_to_write:
-            env_vars_to_write["OTEL_TRACES_EXPORTER"] = (
-                settings.opentelemetry_default_exporter
-            )
+    # 2. Apply Golf's OTel default exporter setting if OTEL_TRACES_EXPORTER
+    # is not already set
+    if (
+        settings.opentelemetry_enabled
+        and settings.opentelemetry_default_exporter
+        and "OTEL_TRACES_EXPORTER" not in env_vars_to_write
+    ):
+        env_vars_to_write["OTEL_TRACES_EXPORTER"] = settings.opentelemetry_default_exporter
 
     # 3. Apply Golf's project name as OTEL_SERVICE_NAME if not already set
     # (Ensures service name defaults to project name if not specified in user's .env)
-    if settings.opentelemetry_enabled and settings.name:
-        if "OTEL_SERVICE_NAME" not in env_vars_to_write:
-            env_vars_to_write["OTEL_SERVICE_NAME"] = settings.name
+    if settings.opentelemetry_enabled and settings.name and "OTEL_SERVICE_NAME" not in env_vars_to_write:
+        env_vars_to_write["OTEL_SERVICE_NAME"] = settings.name
 
     # 4. (Re-)Write the .env file in the output directory if there's anything to write
     if env_vars_to_write:
@@ -1206,73 +1228,51 @@ def build_project(
                     # and handle existing quotes within the value.
                     if isinstance(value, str):
                         # Replace backslashes first, then double quotes
-                        processed_value = value.replace(
-                            "\\", "\\\\"
-                        )  # Escape backslashes
-                        processed_value = processed_value.replace(
-                            '"', '\\"'
-                        )  # Escape double quotes
-                        if (
-                            " " in value
-                            or "#" in value
-                            or "\n" in value
-                            or '"' in value
-                            or "'" in value
-                        ):
+                        processed_value = value.replace("\\", "\\\\")  # Escape backslashes
+                        processed_value = processed_value.replace('"', '\\"')  # Escape double quotes
+                        if " " in value or "#" in value or "\n" in value or '"' in value or "'" in value:
                             f.write(f'{key}="{processed_value}"\n')
                         else:
                             f.write(f"{key}={processed_value}\n")
                     else:  # For non-string values, write directly
                         f.write(f"{key}={value}\n")
         except Exception as e:
-            console.print(
-                f"[yellow]Warning: Could not write .env file to output directory: {e}[/yellow]"
-            )
+            console.print(f"[yellow]Warning: Could not write .env file to output directory: {e}[/yellow]")
     # --- END Enhanced .env handling ---
 
     # Show what we're building, with environment info
-    console.print(
-        f"[bold]Building [green]{settings.name}[/green] ({build_env} environment)[/bold]"
-    )
+    create_build_header(settings.name, build_env, console)
 
     # Generate the code
-    generator = CodeGenerator(
-        project_path, settings, output_dir, build_env=build_env, copy_env=copy_env
-    )
+    generator = CodeGenerator(project_path, settings, output_dir, build_env=build_env, copy_env=copy_env)
     generator.generate()
 
     # Platform registration (only for prod builds)
     if build_env == "prod":
-        console.print(
-            "[dim]Registering with Golf platform and updating resources...[/dim]"
-        )
-        import asyncio
+        console.print()
+        status_msg = f"[{GOLF_BLUE}]{STATUS_ICONS['platform']} Registering with Golf platform and updating resources...[/{GOLF_BLUE}]"
+        with console.status(status_msg):
+            import asyncio
 
-        try:
-            from golf.core.platform import register_project_with_platform
+            try:
+                from golf.core.platform import register_project_with_platform
 
-            success = asyncio.run(
-                register_project_with_platform(
-                    project_path=project_path,
-                    settings=settings,
-                    components=generator.components,
+                success = asyncio.run(
+                    register_project_with_platform(
+                        project_path=project_path,
+                        settings=settings,
+                        components=generator.components,
+                    )
                 )
-            )
 
-            if success:
-                console.print("[green]✓ Platform registration completed[/green]")
-            # If success is False, the platform module already printed appropriate warnings
-        except ImportError:
-            console.print(
-                "[yellow]Warning: Platform registration module not available[/yellow]"
-            )
-        except Exception as e:
-            console.print(
-                f"[yellow]Warning: Platform registration failed: {e}[/yellow]"
-            )
-            console.print(
-                "[yellow]Tip: Ensure GOLF_API_KEY and GOLF_SERVER_ID are available in your .env file[/yellow]"
-            )
+                if success:
+                    console.print(get_status_text("success", "Platform registration completed"))
+                # If success is False, the platform module already printed appropriate warnings
+            except ImportError:
+                console.print(get_status_text("warning", "Platform registration module not available"))
+            except Exception as e:
+                console.print(get_status_text("warning", f"Platform registration failed: {e}"))
+                console.print("[dim]Tip: Ensure GOLF_API_KEY and GOLF_SERVER_ID are available in your .env file[/dim]")
 
     # Create a simple README
     readme_content = f"""# {settings.name}
@@ -1292,50 +1292,6 @@ This is a standalone FastMCP server generated by GolfMCP.
     with open(output_dir / "README.md", "w") as f:
         f.write(readme_content)
 
-    # Copy pyproject.toml with required dependencies
-    base_dependencies = [
-        "fastmcp>=2.0.0,<2.6.0",
-        "uvicorn>=0.20.0",
-        "pydantic>=2.0.0",
-        "python-dotenv>=1.0.0",
-    ]
-
-    # Add OpenTelemetry dependencies if enabled
-    if settings.opentelemetry_enabled:
-        base_dependencies.extend(get_otel_dependencies())
-
-    # Add authentication dependencies if enabled, before generating pyproject_content
-    provider_config, required_scopes = (
-        get_auth_config()
-    )  # Ensure this is called to check for auth
-    if provider_config:
-        base_dependencies.extend(
-            [
-                "pyjwt>=2.0.0",
-                "httpx>=0.20.0",
-            ]
-        )
-
-    # Create the dependencies string
-    dependencies_str = ",\n    ".join([f'"{dep}"' for dep in base_dependencies])
-
-    pyproject_content = f"""[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "generated-fastmcp-app"
-version = "0.1.0"
-description = "Generated FastMCP Application"
-requires-python = ">=3.10"
-dependencies = [
-    {dependencies_str}
-]
-"""
-
-    with open(output_dir / "pyproject.toml", "w") as f:
-        f.write(pyproject_content)
-
     # Always copy the auth module so it's available
     auth_dir = output_dir / "golf" / "auth"
     auth_dir.mkdir(parents=True, exist_ok=True)
@@ -1345,24 +1301,24 @@ dependencies = [
         f.write(
             """\"\"\"Auth module for GolfMCP.\"\"\"
 
-from golf.auth.provider import ProviderConfig
-from golf.auth.oauth import GolfOAuthProvider, create_callback_handler
-from golf.auth.helpers import get_access_token, get_provider_token, extract_token_from_header, get_api_key, set_api_key
+# Legacy ProviderConfig removed in Golf 0.2.x - use modern auth configurations
+# Legacy OAuth imports removed in Golf 0.2.x - use FastMCP 2.11+ auth providers
+from golf.auth.helpers import get_provider_token, extract_token_from_header, get_api_key, set_api_key
 from golf.auth.api_key import configure_api_key, get_api_key_config
+from golf.auth.factory import create_auth_provider
+from golf.auth.providers import RemoteAuthConfig, JWTAuthConfig, StaticTokenConfig, OAuthServerConfig
 """
         )
 
-    # Copy provider, oauth, and helper modules
-    for module in ["provider.py", "oauth.py", "helpers.py", "api_key.py"]:
+    # Copy auth modules required for Golf 0.2.x
+    for module in ["helpers.py", "api_key.py", "factory.py", "providers.py"]:
         src_file = Path(__file__).parent.parent.parent / "golf" / "auth" / module
         dst_file = auth_dir / module
 
         if src_file.exists():
             shutil.copy(src_file, dst_file)
         else:
-            console.print(
-                f"[yellow]Warning: Could not find {src_file} to copy[/yellow]"
-            )
+            console.print(f"[yellow]Warning: Could not find {src_file} to copy[/yellow]")
 
     # Copy telemetry module if OpenTelemetry is enabled
     if settings.opentelemetry_enabled:
@@ -1370,31 +1326,21 @@ from golf.auth.api_key import configure_api_key, get_api_key_config
         telemetry_dir.mkdir(parents=True, exist_ok=True)
 
         # Copy telemetry __init__.py
-        src_init = (
-            Path(__file__).parent.parent.parent / "golf" / "telemetry" / "__init__.py"
-        )
+        src_init = Path(__file__).parent.parent.parent / "golf" / "telemetry" / "__init__.py"
         dst_init = telemetry_dir / "__init__.py"
         if src_init.exists():
             shutil.copy(src_init, dst_init)
 
         # Copy instrumentation module
-        src_instrumentation = (
-            Path(__file__).parent.parent.parent
-            / "golf"
-            / "telemetry"
-            / "instrumentation.py"
-        )
+        src_instrumentation = Path(__file__).parent.parent.parent / "golf" / "telemetry" / "instrumentation.py"
         dst_instrumentation = telemetry_dir / "instrumentation.py"
         if src_instrumentation.exists():
             shutil.copy(src_instrumentation, dst_instrumentation)
         else:
-            console.print(
-                "[yellow]Warning: Could not find telemetry instrumentation module[/yellow]"
-            )
+            console.print("[yellow]Warning: Could not find telemetry instrumentation module[/yellow]")
 
     # Check if auth routes need to be added
-    provider_config, _ = get_auth_config()
-    if provider_config:
+    if is_auth_configured() or get_api_key_config():
         auth_routes_code = generate_auth_routes()
 
         server_file = output_dir / "server.py"
@@ -1407,17 +1353,12 @@ from golf.auth.api_key import configure_api_key, get_api_key_config
             app_pos = server_code_content.find(app_marker)
             if app_pos != -1:
                 modified_code = (
-                    server_code_content[:app_pos]
-                    + auth_routes_code
-                    + "\n\n"
-                    + server_code_content[app_pos:]
+                    server_code_content[:app_pos] + auth_routes_code + "\n\n" + server_code_content[app_pos:]
                 )
 
                 # Format with black before writing
                 try:
-                    final_code_to_write = black.format_str(
-                        modified_code, mode=black.Mode()
-                    )
+                    final_code_to_write = black.format_str(modified_code, mode=black.Mode())
                 except Exception as e:
                     console.print(
                         f"[yellow]Warning: Could not format server.py after auth routes injection: {e}[/yellow]"
@@ -1432,38 +1373,29 @@ from golf.auth.api_key import configure_api_key, get_api_key_config
                 )
 
 
-# Renamed function - was find_shared_modules
-def find_common_files(
-    project_path: Path, components: dict[ComponentType, list[ParsedComponent]]
-) -> dict[str, Path]:
-    """Find all common.py files used by components."""
-    # We'll use the parser's functionality to find common files directly
-    from golf.core.parser import parse_common_files
-
-    common_files = parse_common_files(project_path)
-
-    # Return the found files without debug messages
-    return common_files
+# Legacy function removed - replaced by parse_shared_files in parser module
 
 
-# Updated parameter name from shared_modules to common_files
-def build_import_map(
-    project_path: Path, common_files: dict[str, Path]
-) -> dict[str, str]:
+# Updated to handle any shared file, not just common.py files
+def build_import_map(project_path: Path, shared_files: dict[str, Path]) -> dict[str, str]:
     """Build a mapping of import paths to their new locations in the build output.
 
     This maps from original relative import paths to absolute import paths
     in the components directory structure.
+
+    Args:
+        project_path: Path to the project root
+        shared_files: Dictionary mapping module paths to shared file paths
     """
     import_map = {}
 
-    for dir_path_str, _file_path in common_files.items():
-        # Convert string path to Path object
-        dir_path = Path(dir_path_str)
+    for module_path_str, file_path in shared_files.items():
+        # Convert module path to Path object (e.g., "tools/weather/helpers" -> Path("tools/weather/helpers"))
+        module_path = Path(module_path_str)
 
         # Get the component type (tools, resources, prompts)
         component_type = None
-        for part in dir_path.parts:
+        for part in module_path.parts:
             if part in ["tools", "resources", "prompts"]:
                 component_type = part
                 break
@@ -1473,23 +1405,32 @@ def build_import_map(
 
         # Calculate the relative path within the component type
         try:
-            rel_to_component = dir_path.relative_to(component_type)
+            rel_to_component = module_path.relative_to(component_type)
             # Create the new import path
             if str(rel_to_component) == ".":
-                # This is at the root of the component type
+                # This shouldn't happen for individual files, but handle it
                 new_path = f"components.{component_type}"
             else:
                 # Replace path separators with dots
                 path_parts = str(rel_to_component).replace("\\", "/").split("/")
                 new_path = f"components.{component_type}.{'.'.join(path_parts)}"
 
-            # Map both the directory and the common file
-            orig_module = dir_path_str
-            import_map[orig_module] = new_path
+            # Map the specific shared module
+            # e.g., "tools/weather/helpers" -> "components.tools.weather.helpers"
+            import_map[module_path_str] = new_path
+
+            # Also map the directory path for relative imports
+            # e.g., "tools/weather" -> "components.tools.weather"
+            dir_path_str = str(module_path.parent)
+            if dir_path_str != "." and dir_path_str not in import_map:
+                dir_rel_to_component = module_path.parent.relative_to(component_type)
+                if str(dir_rel_to_component) == ".":
+                    dir_new_path = f"components.{component_type}"
+                else:
+                    dir_path_parts = str(dir_rel_to_component).replace("\\", "/").split("/")
+                    dir_new_path = f"components.{component_type}.{'.'.join(dir_path_parts)}"
+                import_map[dir_path_str] = dir_new_path
 
-            # Also map the specific common module
-            common_module = f"{dir_path_str}/common"
-            import_map[common_module] = f"{new_path}.common"
         except ValueError:
             continue