code-discovery 0.2.0__tar.gz → 0.2.2__tar.gz

{code_discovery-0.2.0 → code_discovery-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-discovery
-Version: 0.2.0
+Version: 0.2.2
 Summary: Automatic API discovery system for multiple frameworks and VCS platforms
 Home-page: https://github.com/yourusername/codediscovery
 Author: Code Discovery Team

{code_discovery-0.2.0 → code_discovery-0.2.2}/setup.py

@@ -22,7 +22,7 @@ dev_requirements = [
 
 setup(
     name="code-discovery",
-    version="0.2.0",
+    version="0.2.2",
     author="Code Discovery Team",
     author_email="team@codediscovery.dev",
     description="Automatic API discovery system for multiple frameworks and VCS platforms",

{code_discovery-0.2.0 → code_discovery-0.2.2}/src/code_discovery.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-discovery
-Version: 0.2.0
+Version: 0.2.2
 Summary: Automatic API discovery system for multiple frameworks and VCS platforms
 Home-page: https://github.com/yourusername/codediscovery
 Author: Code Discovery Team

{code_discovery-0.2.0 → code_discovery-0.2.2}/src/generators/openapi_generator.py

@@ -151,6 +151,8 @@ class OpenAPIGenerator:
     def _generate_paths(self, endpoints: List[APIEndpoint]) -> Dict[str, Any]:
         """Generate the paths section."""
         paths = {}
+        seen_operations = {}  # Track (path, method) combinations
+        duplicate_warnings = []
 
         for endpoint in endpoints:
             path = endpoint.path
@@ -159,8 +161,37 @@ class OpenAPIGenerator:
 
             # Add operation for this HTTP method
             method_lower = endpoint.method.value.lower()
+            operation_key = (path, method_lower)
+            
+            # Check for duplicates
+            if operation_key in seen_operations:
+                duplicate_warnings.append(
+                    f"{endpoint.method.value} {path} (duplicate #{seen_operations[operation_key]['count'] + 1})"
+                )
+                # Make operationId unique by appending a counter
+                if endpoint.operation_id:
+                    endpoint.operation_id = f"{endpoint.operation_id}_{seen_operations[operation_key]['count']}"
+                else:
+                    endpoint.operation_id = f"{method_lower}_{seen_operations[operation_key]['count']}"
+                seen_operations[operation_key]['count'] += 1
+            else:
+                seen_operations[operation_key] = {'count': 1}
+            
             paths[path][method_lower] = self._generate_operation(endpoint)
 
+        # Warn about duplicates
+        if duplicate_warnings:
+            print(f"\n⚠️  Warning: Found {len(duplicate_warnings)} duplicate path+method combinations.")
+            print("   These endpoints have been made unique by modifying their operationId.")
+            print("   Consider adding unique paths or tags to differentiate them.")
+            if len(duplicate_warnings) <= 10:
+                for warning in duplicate_warnings:
+                    print(f"   - {warning}")
+            else:
+                for warning in duplicate_warnings[:10]:
+                    print(f"   - {warning}")
+                print(f"   ... and {len(duplicate_warnings) - 10} more")
+
         return paths
 
     def _generate_operation(self, endpoint: APIEndpoint) -> Dict[str, Any]:

{code_discovery-0.2.0 → code_discovery-0.2.2}/src/main.py

@@ -73,7 +73,7 @@ Examples:
         version = importlib.metadata.version("code-discovery")
     except Exception:
         # Fallback if package not installed or metadata not available
-        version = "0.2.0"
+        version = "0.2.2"
     
     parser.add_argument(
         "--version",

{code_discovery-0.2.0 → code_discovery-0.2.2}/src/parsers/java_spring_parser.py

@@ -59,24 +59,28 @@ class SpringBootParser(BaseParser):
         endpoints = []
         
         # Extract class-level @RequestMapping
-        class_path = self._extract_class_request_mapping(content)
+        class_path = self._extract_class_request_mapping(content, file_path)
+        
+        # Extract controller class name for tags and unique operationIds
+        controller_name = self._extract_controller_name(content, file_path)
         
         # Find all method annotations
-        methods = self._extract_methods(content)
+        methods = self._extract_methods(content, file_path)
         
         for method_info in methods:
             endpoint = self._create_endpoint(
                 method_info,
                 class_path,
                 file_path,
+                controller_name,
             )
             if endpoint:
                 endpoints.append(endpoint)
 
         return endpoints
 
-    def _extract_class_request_mapping(self, content: str) -> str:
-        """Extract class-level @RequestMapping path."""
+    def _extract_class_request_mapping(self, content: str, file_path: Path) -> str:
+        """Extract class-level @RequestMapping path, resolving constants if needed."""
         # Match @RequestMapping("/path") or @RequestMapping(value = "/path")
         patterns = [
             r'@RequestMapping\s*\(\s*"([^"]+)"\s*\)',
@@ -89,9 +93,31 @@ class SpringBootParser(BaseParser):
             if match:
                 return match.group(1)
         
+        # Check for constant references: @RequestMapping(ClassName.CONSTANT_NAME)
+        constant_patterns = [
+            r'@RequestMapping\s*\(\s*(\w+)\.(\w+)\s*\)',
+            r'@RequestMapping\s*\(\s*value\s*=\s*(\w+)\.(\w+)\s*\)',
+            r'@RequestMapping\s*\(\s*path\s*=\s*(\w+)\.(\w+)\s*\)',
+        ]
+        
+        for pattern in constant_patterns:
+            match = re.search(pattern, content)
+            if match:
+                class_name = match.group(1)
+                constant_name = match.group(2)
+                # Resolve the constant value
+                constant_value = self._resolve_constant(class_name, constant_name, file_path)
+                if constant_value:
+                    return constant_value
+        
+        # Check for inheritance - if controller extends a base class with @RequestMapping
+        base_class_path = self._extract_inherited_request_mapping(content, file_path)
+        if base_class_path:
+            return base_class_path
+        
         return ""
 
-    def _extract_methods(self, content: str) -> List[Dict[str, Any]]:
+    def _extract_methods(self, content: str, file_path: Path) -> List[Dict[str, Any]]:
         """Extract method information from controller (Spring Boot 2.7.5 through 3.5.x)."""
         methods = []
         
@@ -129,22 +155,27 @@ class SpringBootParser(BaseParser):
         # Patterns: @RequestMapping(value = "/path", method = RequestMethod.GET)
         #           @RequestMapping(path = "/path", method = RequestMethod.POST)
         #           @RequestMapping("/path", method = RequestMethod.PUT)
+        #           @RequestMapping(value = ClassName.CONSTANT, method = RequestMethod.GET)
         request_mapping_patterns = [
             # @RequestMapping(value = "/path", method = RequestMethod.GET)
-            (r'@RequestMapping\s*\(\s*value\s*=\s*"([^"]+)"\s*,\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', 1, 2),
+            (r'@RequestMapping\s*\(\s*value\s*=\s*"([^"]+)"\s*,\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', 1, 2, True),
             # @RequestMapping(path = "/path", method = RequestMethod.GET)
-            (r'@RequestMapping\s*\(\s*path\s*=\s*"([^"]+)"\s*,\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', 1, 2),
+            (r'@RequestMapping\s*\(\s*path\s*=\s*"([^"]+)"\s*,\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', 1, 2, True),
             # @RequestMapping("/path", method = RequestMethod.GET)
-            (r'@RequestMapping\s*\(\s*"([^"]+)"\s*,\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', 1, 2),
+            (r'@RequestMapping\s*\(\s*"([^"]+)"\s*,\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', 1, 2, True),
             # @RequestMapping(method = RequestMethod.GET, value = "/path")
-            (r'@RequestMapping\s*\(\s*method\s*=\s*RequestMethod\.(\w+)\s*,\s*value\s*=\s*"([^"]+)"\s*\)', 2, 1),
+            (r'@RequestMapping\s*\(\s*method\s*=\s*RequestMethod\.(\w+)\s*,\s*value\s*=\s*"([^"]+)"\s*\)', 2, 1, True),
             # @RequestMapping(method = RequestMethod.GET, path = "/path")
-            (r'@RequestMapping\s*\(\s*method\s*=\s*RequestMethod\.(\w+)\s*,\s*path\s*=\s*"([^"]+)"\s*\)', 2, 1),
+            (r'@RequestMapping\s*\(\s*method\s*=\s*RequestMethod\.(\w+)\s*,\s*path\s*=\s*"([^"]+)"\s*\)', 2, 1, True),
+            # @RequestMapping(value = ClassName.CONSTANT, method = RequestMethod.GET)
+            (r'@RequestMapping\s*\(\s*value\s*=\s*(\w+)\.(\w+)\s*,\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', None, 3, False),
+            # @RequestMapping(path = ClassName.CONSTANT, method = RequestMethod.GET)
+            (r'@RequestMapping\s*\(\s*path\s*=\s*(\w+)\.(\w+)\s*,\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', None, 3, False),
             # @RequestMapping(method = RequestMethod.GET) - no path
-            (r'@RequestMapping\s*\(\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', None, 1),
+            (r'@RequestMapping\s*\(\s*method\s*=\s*RequestMethod\.(\w+)\s*\)', None, 1, True),
         ]
         
-        for pattern, path_group, method_group in request_mapping_patterns:
+        for pattern, path_group, method_group, is_string_literal in request_mapping_patterns:
             for match in re.finditer(pattern, content):
                 http_method_name = match.group(method_group).upper()
                 try:
@@ -154,7 +185,13 @@ class SpringBootParser(BaseParser):
                 
                 # Extract path if specified
                 if path_group:
-                    path = match.group(path_group) if match.lastindex and path_group <= match.lastindex else ""
+                    if is_string_literal:
+                        path = match.group(path_group) if match.lastindex and path_group <= match.lastindex else ""
+                    else:
+                        # Constant reference: extract class and constant name
+                        const_class = match.group(1)
+                        const_name = match.group(2)
+                        path = self._resolve_constant(const_class, const_name, file_path) or ""
                 else:
                     path = ""
                 
@@ -249,6 +286,7 @@ class SpringBootParser(BaseParser):
         method_info: Dict[str, Any],
         class_path: str,
         file_path: Path,
+        controller_name: str,
     ) -> Optional[APIEndpoint]:
         """Create an APIEndpoint from method information."""
         # Combine class path and method path
@@ -264,11 +302,23 @@ class SpringBootParser(BaseParser):
         # Extract response schema from return type
         response_schema = self._extract_response_schema(method_info["signature"], file_path)
         
-        # Create endpoint
+        # Extract method name for unique operationId
+        method_name = self._extract_method_name(method_info["signature"])
+        
+        # Generate unique operationId using controller + method name
+        operation_id = self._generate_operation_id(
+            full_path, 
+            method_info["method"], 
+            controller_name=controller_name,
+            method_name=method_name,
+        )
+        
+        # Create endpoint with controller name as tag
         endpoint = APIEndpoint(
             path=full_path,
             method=method_info["method"],
-            operation_id=self._generate_operation_id(full_path, method_info["method"]),
+            operation_id=operation_id,
+            tags=[controller_name] if controller_name else [],
             parameters=parameters,
             request_body=request_body,
             responses=[
@@ -578,10 +628,218 @@ class SpringBootParser(BaseParser):
         
         return None
 
-    def _generate_operation_id(self, path: str, method: HTTPMethod) -> str:
-        """Generate operation ID from path and method."""
-        # Remove leading slash and convert to camelCase
-        path_parts = [p for p in path.split('/') if p and not p.startswith('{')]
-        operation_id = method.value.lower() + ''.join(p.capitalize() for p in path_parts)
+    def _resolve_constant(self, class_name: str, constant_name: str, current_file: Path) -> Optional[str]:
+        """
+        Resolve a constant value from a class.
+        
+        Args:
+            class_name: Name of the class containing the constant (e.g., "BaseController")
+            constant_name: Name of the constant (e.g., "PROJECTS_BASE")
+            current_file: Path to the current file (for relative imports)
+            
+        Returns:
+            Resolved constant value or None if not found
+        """
+        # Try to find the class file
+        class_file = self._find_class_file(class_name, current_file)
+        if not class_file:
+            return None
+        
+        # Read the class file
+        class_content = self.read_file(class_file)
+        if not class_content:
+            return None
+        
+        # Extract constant value
+        # Pattern: public static final String CONSTANT_NAME = "value";
+        # Or: public static final String CONSTANT_NAME = OTHER_CONSTANT + "/path";
+        constant_pattern = rf'public\s+static\s+final\s+String\s+{constant_name}\s*=\s*([^;]+);'
+        match = re.search(constant_pattern, class_content)
+        if not match:
+            return None
+        
+        constant_value_expr = match.group(1).strip()
+        
+        # Handle string literals: "value"
+        if constant_value_expr.startswith('"') and constant_value_expr.endswith('"'):
+            return constant_value_expr.strip('"')
+        
+        # Handle string concatenation: CONSTANT1 + "/path" or "path" + CONSTANT2
+        parts = []
+        # Split by + and process each part
+        concat_parts = re.split(r'\s*\+\s*', constant_value_expr)
+        for part in concat_parts:
+            part = part.strip()
+            # String literal
+            if part.startswith('"') and part.endswith('"'):
+                parts.append(part.strip('"'))
+            # Another constant reference
+            elif '.' in part:
+                # Format: ClassName.CONSTANT_NAME
+                const_match = re.match(r'(\w+)\.(\w+)', part)
+                if const_match:
+                    const_class = const_match.group(1)
+                    const_name = const_match.group(2)
+                    # Recursively resolve
+                    resolved = self._resolve_constant(const_class, const_name, class_file)
+                    if resolved:
+                        parts.append(resolved)
+                    else:
+                        return None  # Can't resolve dependency
+                else:
+                    return None  # Invalid format
+            else:
+                # Might be a simple constant name in the same class
+                same_class_match = re.search(
+                    rf'public\s+static\s+final\s+String\s+{part}\s*=\s*"([^"]+)"',
+                    class_content
+                )
+                if same_class_match:
+                    parts.append(same_class_match.group(1))
+                else:
+                    return None  # Can't resolve
+        
+        return ''.join(parts)
+    
+    def _find_class_file(self, class_name: str, reference_file: Path) -> Optional[Path]:
+        """
+        Find the file containing a class definition.
+        
+        Args:
+            class_name: Name of the class to find
+            reference_file: File that references this class (for package resolution)
+            
+        Returns:
+            Path to the class file or None if not found
+        """
+        # Try to find in cached files first
+        for file_path, content in self._file_content_cache.items():
+            # Check if file contains the class definition
+            class_pattern = rf'(?:public\s+)?(?:abstract\s+)?(?:class|interface|enum)\s+{class_name}\b'
+            if re.search(class_pattern, content):
+                return file_path
+        
+        # Try to find by filename (common convention: ClassName.java)
+        for file_path in self.source_paths:
+            if file_path.name == f"{class_name}.java":
+                return file_path
+        
+        # Try to find in same package (extract package from reference file)
+        try:
+            ref_content = self.read_file(reference_file)
+            if ref_content:
+                package_match = re.search(r'package\s+([\w.]+);', ref_content)
+                if package_match:
+                    package = package_match.group(1)
+                    # Search for class in same package directory
+                    ref_dir = reference_file.parent
+                    candidate = ref_dir / f"{class_name}.java"
+                    if candidate.exists():
+                        return candidate
+        except:
+            pass
+        
+        # Search all Java files
+        for file_path in self.find_files("*.java"):
+            try:
+                content = self.read_file(file_path)
+                if content:
+                    class_pattern = rf'(?:public\s+)?(?:abstract\s+)?(?:class|interface|enum)\s+{class_name}\b'
+                    if re.search(class_pattern, content):
+                        return file_path
+            except:
+                continue
+        
+        return None
+    
+    def _extract_inherited_request_mapping(self, content: str, file_path: Path) -> Optional[str]:
+        """
+        Extract @RequestMapping from a base class if the controller extends it.
+        
+        Args:
+            content: Controller file content
+            file_path: Path to controller file
+            
+        Returns:
+            Base class @RequestMapping path or None
+        """
+        # Check if class extends another class
+        extends_match = re.search(r'class\s+\w+\s+extends\s+(\w+)', content)
+        if not extends_match:
+            return None
+        
+        base_class_name = extends_match.group(1)
+        base_class_file = self._find_class_file(base_class_name, file_path)
+        
+        if base_class_file:
+            base_content = self.read_file(base_class_file)
+            if base_content:
+                # Extract @RequestMapping from base class
+                base_path = self._extract_class_request_mapping(base_content, base_class_file)
+                if base_path:
+                    return base_path
+        
+        return None
+
+    def _extract_controller_name(self, content: str, file_path: Path) -> str:
+        """Extract controller class name from file content or file path."""
+        # Try to extract from class declaration first
+        class_match = re.search(r'public\s+class\s+(\w+)', content)
+        if class_match:
+            class_name = class_match.group(1)
+            # Remove common suffixes for cleaner tag names
+            for suffix in ['Controller', 'Resource', 'Endpoint', 'Api']:
+                if class_name.endswith(suffix):
+                    return class_name[:-len(suffix)]
+            return class_name
+        
+        # Fallback to file name
+        file_name = file_path.stem  # Gets filename without extension
+        # Remove common suffixes
+        for suffix in ['Controller', 'Resource', 'Endpoint', 'Api']:
+            if file_name.endswith(suffix):
+                return file_name[:-len(suffix)]
+        return file_name
+    
+    def _generate_operation_id(
+        self, 
+        path: str, 
+        method: HTTPMethod, 
+        controller_name: Optional[str] = None,
+        method_name: Optional[str] = None,
+    ) -> str:
+        """Generate unique operation ID from path, method, controller, and method name."""
+        # Build operation ID components
+        parts = []
+        
+        # Start with HTTP method
+        parts.append(method.value.lower())
+        
+        # Add controller name if available (makes it unique)
+        if controller_name:
+            # Convert to camelCase: "PrimaryTransaction" -> "primaryTransaction"
+            controller_camel = controller_name[0].lower() + controller_name[1:] if controller_name else ""
+            parts.append(controller_camel)
+        
+        # Add method name if available (further uniqueness)
+        if method_name:
+            parts.append(method_name)
+        
+        # Add path parts as fallback if no method name
+        if not method_name:
+            path_parts = [p for p in path.split('/') if p and not p.startswith('{')]
+            parts.extend(p.capitalize() for p in path_parts)
+        
+        # Join parts: e.g., "getPrimaryTransactionGetById"
+        operation_id = ''.join(parts)
+        
+        # If still empty or too generic, use path-based fallback
+        if not operation_id or operation_id == method.value.lower():
+            path_parts = [p for p in path.split('/') if p and not p.startswith('{')]
+            if path_parts:
+                operation_id = method.value.lower() + ''.join(p.capitalize() for p in path_parts)
+            else:
+                operation_id = method.value.lower() + "Endpoint"
+        
         return operation_id
 

{code_discovery-0.2.0 → code_discovery-0.2.2}/src/utils/config.py

@@ -16,7 +16,7 @@ class Config:
             "frameworks": [],  # Empty means auto-detect all
             "openapi": {
                 "version": "3.0.0",
-                "output_path": "openapi-spec.yaml",
+                "output_path": "apisec-bolt-code-discovery/openapi_spec.yaml",
                 "output_format": "yaml",  # yaml or json
                 "include_examples": True,
             },

{code_discovery-0.2.0 → code_discovery-0.2.2}/src/utils/state_manager.py

@@ -32,7 +32,7 @@ class DiscoveryStateManager:
             repo_path: Path to the repository root.
         """
         self.repo_path = Path(repo_path)
-        self.state_file = self.repo_path / ".code-discovery" / "state.yaml"
+        self.state_file = self.repo_path / "apisec-bolt-code-discovery" / "state.yaml"
         self.state_dir = self.state_file.parent
 
     def load_state(self) -> Optional[Dict[str, Any]]: