golf-mcp 0.2.13__tar.gz → 0.2.15__tar.gz

{golf_mcp-0.2.13/src/golf_mcp.egg-info → golf_mcp-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: golf-mcp
-Version: 0.2.13
+Version: 0.2.15
 Summary: Framework for building MCP servers
 Author-email: Antoni Gmitruk <antoni@golf.dev>
 License-Expression: Apache-2.0

{golf_mcp-0.2.13 → golf_mcp-0.2.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "golf-mcp"
-version = "0.2.13"
+version = "0.2.15"
 description = "Framework for building MCP servers"
 authors = [
     {name = "Antoni Gmitruk", email = "antoni@golf.dev"}
@@ -66,7 +66,7 @@ golf = ["examples/**/*"]
 
 [tool.poetry]
 name = "golf-mcp"
-version = "0.2.13"
+version = "0.2.14"
 description = "Framework for building MCP servers with zero boilerplate"
 authors = ["Antoni Gmitruk <antoni@golf.dev>"]
 license = "Apache-2.0"

golf_mcp-0.2.15/src/golf/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.15"

{golf_mcp-0.2.13 → golf_mcp-0.2.15}/src/golf/core/builder.py

@@ -341,6 +341,13 @@ class CodeGenerator:
         self.manifest = {}
         self.shared_files = {}
         self.import_map = {}
+        self._root_files_cache = None  # Cache for discovered root files
+
+    def _get_cached_root_files(self) -> dict[str, Path]:
+        """Get cached root files, discovering them only once."""
+        if self._root_files_cache is None:
+            self._root_files_cache = discover_root_files(self.project_path)
+        return self._root_files_cache
 
     def generate(self) -> None:
         """Generate the FastMCP application code."""
@@ -386,7 +393,7 @@ class CodeGenerator:
     def _generate_root_file_imports(self) -> list[str]:
         """Generate import statements for automatically discovered root files."""
         root_file_imports = []
-        discovered_files = discover_root_files(self.project_path)
+        discovered_files = self._get_cached_root_files()
 
         if discovered_files:
             root_file_imports.append("# Import root-level Python files")
@@ -399,6 +406,11 @@ class CodeGenerator:
 
         return root_file_imports
 
+    def _get_root_file_modules(self) -> set[str]:
+        """Get set of root file module names for import transformation."""
+        discovered_files = self._get_cached_root_files()
+        return {Path(filename).stem for filename in discovered_files.keys()}
+
     def _create_directory_structure(self) -> None:
         """Create the output directory structure"""
         # Create main directories
@@ -444,12 +456,14 @@ class CodeGenerator:
             target_file = target_dir / shared_file.name
 
             # Use transformer to process the file
+            root_file_modules = self._get_root_file_modules()
             transform_component(
                 component=None,
                 output_file=target_file,
                 project_path=self.project_path,
                 import_map=self.import_map,
                 source_file=shared_file,
+                root_file_modules=root_file_modules,
             )
 
     def _generate_tools(self) -> None:
@@ -474,7 +488,10 @@ class CodeGenerator:
 
             # Create the tool file
             output_file = tool_dir / rel_path.name
-            transform_component(tool, output_file, self.project_path, self.import_map)
+            root_file_modules = self._get_root_file_modules()
+            transform_component(
+                tool, output_file, self.project_path, self.import_map, root_file_modules=root_file_modules
+            )
 
     def _generate_resources(self) -> None:
         """Generate code for all resources."""
@@ -498,7 +515,10 @@ class CodeGenerator:
 
             # Create the resource file
             output_file = resource_dir / rel_path.name
-            transform_component(resource, output_file, self.project_path, self.import_map)
+            root_file_modules = self._get_root_file_modules()
+            transform_component(
+                resource, output_file, self.project_path, self.import_map, root_file_modules=root_file_modules
+            )
 
     def _generate_prompts(self) -> None:
         """Generate code for all prompts."""
@@ -522,7 +542,10 @@ class CodeGenerator:
 
             # Create the prompt file
             output_file = prompt_dir / rel_path.name
-            transform_component(prompt, output_file, self.project_path, self.import_map)
+            root_file_modules = self._get_root_file_modules()
+            transform_component(
+                prompt, output_file, self.project_path, self.import_map, root_file_modules=root_file_modules
+            )
 
     def _get_transport_config(self, transport_type: str) -> dict:
         """Get transport-specific configuration (primarily for endpoint path display).
@@ -1596,8 +1619,8 @@ def build_project(
         shutil.copy2(health_path, output_dir)
         console.print(get_status_text("success", "Health script copied to build directory"))
 
-    # Copy any additional Python files from project root
-    discovered_root_files = discover_root_files(project_path)
+    # Copy any additional Python files from project root (reuse cached discovery from generator)
+    discovered_root_files = generator._get_cached_root_files()
 
     for filename, file_path in discovered_root_files.items():
         dest_path = output_dir / filename
@@ -1720,8 +1743,6 @@ def discover_root_files(project_path: Path) -> dict[str, Path]:
     Returns:
         Dictionary mapping filenames to their full paths
     """
-    import ast
-
     discovered_files = {}
 
     # Files that are handled specially by Golf and should not be auto-copied
@@ -1757,19 +1778,11 @@ def discover_root_files(project_path: Path) -> dict[str, Path]:
             if filename.startswith(".") or filename.startswith("_") or filename.endswith("~"):
                 continue
 
-            # Validate it's a readable Python file
+            # Just verify it's a readable file
             try:
                 with open(file_path, encoding="utf-8") as f:
-                    # Read first 200 chars to validate it's a proper Python file
-                    content = f.read(200)
-
-                # Basic Python syntax validation
-                try:
-                    ast.parse(content + "\n# truncated for validation")
-                except SyntaxError:
-                    # Still include files with syntax errors, but warn
-                    console.print(f"[yellow]Warning: {filename} has syntax issues but will be included[/yellow]")
-
+                    # Just check if file is readable - don't validate syntax
+                    f.read(1)  # Read one character to verify readability
             except (OSError, UnicodeDecodeError) as e:
                 console.print(f"[yellow]Warning: Cannot read {filename}, skipping: {e}[/yellow]")
                 continue

{golf_mcp-0.2.13 → golf_mcp-0.2.15}/src/golf/core/transformer.py

@@ -20,6 +20,7 @@ class ImportTransformer(ast.NodeTransformer):
         target_path: Path,
         import_map: dict[str, str],
         project_root: Path,
+        root_file_modules: set[str] | None = None,
     ) -> None:
         """Initialize the import transformer.
 
@@ -28,14 +29,61 @@ class ImportTransformer(ast.NodeTransformer):
             target_path: Path to the target file
             import_map: Mapping of original module paths to generated paths
             project_root: Root path of the project
+            root_file_modules: Set of root file module names (without .py extension)
         """
         self.original_path = original_path
         self.target_path = target_path
         self.import_map = import_map
         self.project_root = project_root
+        self.root_file_modules = root_file_modules or set()
+
+    def _calculate_import_depth(self) -> int:
+        """Calculate the relative import depth needed to reach build root from component location."""
+        try:
+            # Get component path relative to project root
+            relative_path = self.target_path.relative_to(self.project_root)
+
+            # Count directory levels: components/tools/weather.py = 2 levels, needs level=2
+            # components/tools/api/handler.py = 3 levels, needs level=3
+            # Build root contains the root files, so depth = number of path parts
+            return len(relative_path.parts) - 1  # Subtract 1 for the filename itself
+
+        except ValueError:
+            # Fallback to level=3 if path calculation fails
+            return 3
 
     def visit_Import(self, node: ast.Import) -> Any:
         """Transform import statements."""
+        new_names = []
+
+        for alias in node.names:
+            module_name = alias.name
+
+            if module_name in self.root_file_modules:
+                # Calculate dynamic depth based on component location
+                depth = self._calculate_import_depth()
+
+                # Convert to from-import: import config -> from ...config import config
+                # Or if there's an asname: import config as cfg -> from ...config import config as cfg
+                if alias.asname:
+                    # import config as cfg -> from ...config import config as cfg
+                    import_name = module_name
+                    asname = alias.asname
+                else:
+                    # import config -> from ...config import config
+                    import_name = module_name
+                    asname = None
+
+                # Return a from-import instead of continuing with import
+                return ast.ImportFrom(
+                    module=module_name, names=[ast.alias(name=import_name, asname=asname)], level=depth
+                )
+            else:
+                new_names.append(alias)
+
+        # If no root modules, return original or modified import
+        if new_names != list(node.names):
+            return ast.Import(names=new_names)
         return node
 
     def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:
@@ -43,6 +91,12 @@ class ImportTransformer(ast.NodeTransformer):
         if node.module is None:
             return node
 
+        # Check if this is importing from a root file module
+        if node.level == 0 and node.module in self.root_file_modules:
+            # Calculate dynamic depth instead of using hardcoded level=3
+            depth = self._calculate_import_depth()
+            return ast.ImportFrom(module=node.module, names=node.names, level=depth)
+
         # Handle relative imports
         if node.level > 0:
             # Calculate the source module path
@@ -98,6 +152,7 @@ def transform_component(
     project_path: Path,
     import_map: dict[str, str],
     source_file: Path | None = None,
+    root_file_modules: set[str] | None = None,
 ) -> str:
     """Transform a GolfMCP component into a standalone FastMCP component.
 
@@ -107,6 +162,7 @@ def transform_component(
         project_path: Path to the project root
         import_map: Mapping of original module paths to generated paths
         source_file: Optional path to source file (for shared files)
+        root_file_modules: Set of root file module names (without .py extension)
 
     Returns:
         Generated component code
@@ -126,7 +182,7 @@ def transform_component(
     tree = ast.parse(source_code)
 
     # Transform imports
-    transformer = ImportTransformer(file_path, output_file, import_map, project_path)
+    transformer = ImportTransformer(file_path, output_file, import_map, project_path, root_file_modules)
     tree = transformer.visit(tree)
 
     # Get all imports and docstring
@@ -147,13 +203,10 @@ def transform_component(
         if isinstance(node, ast.Import | ast.ImportFrom):
             imports.append(node)
 
-    # Generate the transformed code
-    transformed_imports = ast.unparse(ast.Module(body=imports, type_ignores=[]))
+    # Build full transformed code - start with docstring first (Python convention)
+    transformed_code = ""
 
-    # Build full transformed code
-    transformed_code = transformed_imports + "\n\n"
-
-    # Add docstring if present, using proper triple quotes for multi-line docstrings
+    # Add docstring first if present, using proper triple quotes for multi-line docstrings
     if docstring:
         # Check if docstring contains newlines
         if "\n" in docstring:
@@ -163,6 +216,11 @@ def transform_component(
             # Use single quotes for single-line docstrings
             transformed_code += f'"{docstring}"\n\n'
 
+    # Add transformed imports after docstring
+    if imports:
+        transformed_imports = ast.unparse(ast.Module(body=imports, type_ignores=[]))
+        transformed_code += transformed_imports + "\n\n"
+
     # Add the rest of the code except imports and the original docstring
     remaining_nodes = []
     for node in tree.body:

{golf_mcp-0.2.13 → golf_mcp-0.2.15/src/golf_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: golf-mcp
-Version: 0.2.13
+Version: 0.2.15
 Summary: Framework for building MCP servers
 Author-email: Antoni Gmitruk <antoni@golf.dev>
 License-Expression: Apache-2.0

golf_mcp-0.2.13/src/golf/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.13"