tapps-agents 3.5.39__py3-none-any.whl → 3.5.40__py3-none-any.whl

tapps_agents/agents/implementer/agent.py

@@ -625,16 +625,16 @@ class ImplementerAgent(BaseAgent, ExpertSupportMixin):
     async def _detect_api_client_pattern(self, specification: str, context: str | None = None) -> bool:
         """
         Detect if specification/context indicates an HTTP/API client implementation.
-        
+
         Checks for common patterns that indicate API client code:
         - Keywords: "API client", "OAuth2", "refresh token", "external API", "HTTP client"
-        - Authentication patterns: "Bearer", "Zoho", "token", "authentication"
+        - Authentication patterns: "Bearer", "token", "authentication"
         - API patterns: "REST API", "API integration", "third-party API"
-        
+
         Args:
             specification: Code specification/description
             context: Optional context code
-            
+
         Returns:
             True if specification appears to be for an API client, False otherwise
         """
@@ -646,13 +646,14 @@ class ImplementerAgent(BaseAgent, ExpertSupportMixin):
         if context:
             text_to_analyze += " " + context.lower()
         
-        # API client keywords
+        # API client keywords (enhanced)
         api_client_keywords = [
             "api client",
             "http client",
             "rest client",
             "oauth2",
             "oauth 2",
+            "oauth",
             "refresh token",
             "access token",
             "external api",
@@ -660,31 +661,52 @@ class ImplementerAgent(BaseAgent, ExpertSupportMixin):
             "api integration",
             "rest api",
             "api wrapper",
+            "graphql client",
+            "graphql api",
+            "websocket client",
+            "mqtt client",
+            "grpc client",
         ]
-        
-        # Authentication keywords
+
+        # Authentication keywords (enhanced with OAuth2 patterns)
         auth_keywords = [
             "bearer",
-            "zoho",
-            "site24x7",
-            "okta",
-            "salesforce",
+            "token",  # General token (covers access, refresh, bearer, etc.)
             "authentication",
             "authorization",
             "api key",
+            "api_key",
+            "apikey",
             "client_id",
             "client_secret",
             "token_url",
             "api_base_url",
+            "jwt",
+            "id_token",
+            "grant_type",
+            "authorization_code",
+            "client_credentials",
+            "credentials",  # General credentials
+            "auth",  # Short form
         ]
-        
-        # Structure keywords
+
+        # Structure keywords (enhanced with framework patterns)
         structure_keywords = [
             "class.*client",
             "get method",
             "post method",
+            "put method",
+            "delete method",
+            "patch method",
             "api endpoint",
+            "endpoint",  # General endpoint
+            "rest endpoint",
             "make request",
+            "http request",
+            "fastapi",
+            "django rest",
+            "api route",
+            "router",  # General router
         ]
         
         # Check for API client keywords

tapps_agents/agents/reviewer/agent.py

@@ -3218,16 +3218,16 @@ class ReviewerAgent(BaseAgent, ExpertSupportMixin):
     async def _detect_api_client_pattern(self, code: str) -> bool:
         """
         Detect if code appears to be an HTTP/API client.
-        
+
         Checks for common patterns that indicate API client code:
         - HTTP client libraries (requests, httpx)
-        - Authentication headers (Authorization, Bearer, Zoho-oauthtoken, X-API-Key)
+        - Authentication headers (Authorization, Bearer, X-API-Key)
         - Token management (refresh_token, access_token, token_url)
         - API client structure (class Client, get/post methods, api_base_url)
-        
+
         Args:
             code: Code content to analyze
-            
+
         Returns:
             True if code appears to be an API client, False otherwise
         """
@@ -3243,18 +3243,20 @@ class ReviewerAgent(BaseAgent, ExpertSupportMixin):
             "requests.put",
             "requests.delete",
             "httpx.client",
-            "httpx.asynccclient",
+            "httpx.asyncclient",
             "httpx.get",
             "httpx.post",
             "urllib.request",
             "urllib3",
+            "aiohttp",
+            "fetch(",  # JavaScript/TypeScript
+            "axios",   # JavaScript/TypeScript
         ]
-        
-        # Authentication indicators
+
+        # Authentication indicators (including OAuth2)
         auth_indicators = [
             "authorization:",
             "bearer",
-            "zoho-oauthtoken",
             "x-api-key",
             "api_key",
             "api-key",
@@ -3263,6 +3265,13 @@ class ReviewerAgent(BaseAgent, ExpertSupportMixin):
             "token_url",
             "client_id",
             "client_secret",
+            "oauth2",
+            "oauth",
+            "grant_type",
+            "authorization_code",
+            "client_credentials",
+            "jwt",
+            "id_token",
         ]
         
         # API client structure indicators
@@ -3270,14 +3279,25 @@ class ReviewerAgent(BaseAgent, ExpertSupportMixin):
             "api_base_url",
             "base_url",
             "api_url",
+            "endpoint",
+            "/api/",
+            "rest",
+            "graphql",
             "class.*client",
+            "class.*api",
             "def get(",
             "def post(",
             "def put(",
             "def delete(",
+            "def patch(",
             "def _headers",
             "def _get_access_token",
             "def _refresh",
+            "@app.get",      # FastAPI
+            "@app.post",     # FastAPI
+            "@router",       # FastAPI router
+            "apiview",       # Django REST
+            "viewset",       # Django REST
         ]
         
         # Check for HTTP client usage
@@ -3289,8 +3309,21 @@ class ReviewerAgent(BaseAgent, ExpertSupportMixin):
         # Check for API client structure
         has_structure = any(indicator in code_lower for indicator in structure_indicators)
         
-        # Code is likely an API client if it has HTTP client usage AND (auth OR structure)
-        return has_http_client and (has_auth or has_structure)
+        # Server-side REST framework indicators (FastAPI, Django REST, etc.)
+        server_api_indicators = [
+            "@app.get",
+            "@app.post",
+            "@router",
+            "apiview",
+            "viewset",
+        ]
+        has_server_api = any(indicator in code_lower for indicator in server_api_indicators)
+
+        # Code is likely an API client/server if:
+        # 1. Has HTTP client usage AND (auth OR structure), OR
+        # 2. Has auth AND structure (e.g., OAuth2 client without explicit http calls yet), OR
+        # 3. Has server-side REST framework patterns (FastAPI, Django REST)
+        return (has_http_client and (has_auth or has_structure)) or (has_auth and has_structure) or has_server_api
 
     def _score_yaml_file(self, file_path: Path, code: str) -> dict[str, Any]:
         """

tapps_agents/agents/reviewer/scoring.py

@@ -964,9 +964,7 @@ class CodeScorer(BaseScorer):
 
         Phase 6.2: Modern Quality Analysis - mypy Integration
         Phase 5 (P1): Fixed to actually run mypy and return real scores (not static 5.0).
-
-        Returns:
-            Type checking score (0-10), where 10 = no issues, 0 = many issues
+        ENH-002-S2: Prefer ScopedMypyExecutor (--follow-imports=skip, <10s) with fallback to full mypy.
         """
         if not self.has_mypy:
             logger.debug("mypy not available - returning neutral score")
@@ -976,10 +974,25 @@ class CodeScorer(BaseScorer):
         if file_path.suffix != ".py":
             return 10.0  # Perfect score for non-Python files (can't type check)
 
+        # ENH-002-S2: Try scoped mypy first (faster)
+        try:
+            from .tools.scoped_mypy import ScopedMypyExecutor
+            executor = ScopedMypyExecutor()
+            result = executor.run_scoped_sync(file_path, timeout=10)
+            if result.files_checked == 1 or result.issues:
+                error_count = len(result.issues)
+                if error_count == 0:
+                    return 10.0
+                score = 10.0 - (error_count * 0.5)
+                logger.debug(
+                    "mypy (scoped) found %s errors for %s, score: %s/10",
+                    error_count, file_path, score,
+                )
+                return max(0.0, min(10.0, score))
+        except Exception as e:
+            logger.debug("scoped mypy not used, falling back to full mypy: %s", e)
+
         try:
-            # Phase 5 fix: Actually run mypy and parse errors
-            # Run mypy with show-error-codes for better error parsing
-            # Optimization (ENH-002): Scoped to single file with --no-incremental for 6x speedup
             result = subprocess.run(  # nosec B603
                 [
                     sys.executable,
@@ -988,63 +1001,44 @@ class CodeScorer(BaseScorer):
                     "--show-error-codes",
                     "--no-error-summary",
                     "--no-color-output",
-                    "--no-incremental",  # Skip cache for single-file check (faster)
+                    "--no-incremental",
                     str(file_path),
                 ],
                 capture_output=True,
                 text=True,
                 encoding="utf-8",
                 errors="replace",
-                timeout=30,  # 30 second timeout (optimized from 60s for single file)
+                timeout=30,
                 cwd=file_path.parent if file_path.parent.exists() else None,
             )
-
-            # Phase 5 fix: Parse mypy output correctly
             if result.returncode == 0:
-                # No type errors found - return perfect score
-                logger.debug(f"mypy found no errors for {file_path}")
+                logger.debug("mypy found no errors for %s", file_path)
                 return 10.0
-
-            # mypy returns non-zero exit code when errors found
-            # mypy outputs errors to stdout (not stderr)
             output = result.stdout.strip()
             if not output:
-                # No output but non-zero return code - assume success
-                logger.debug(f"mypy returned non-zero but no output for {file_path}")
+                logger.debug("mypy returned non-zero but no output for %s", file_path)
                 return 10.0
-
-            # Parse mypy error output
-            # Format: filename:line: error: message [error-code]
-            # Or: filename:line:column: error: message [error-code]
             error_lines = [
                 line
                 for line in output.split("\n")
                 if "error:" in line.lower() and file_path.name in line
             ]
             error_count = len(error_lines)
-
             if error_count == 0:
-                # No errors found despite non-zero return code (e.g., config issues)
-                logger.debug(f"mypy returned non-zero but no parseable errors for {file_path}")
+                logger.debug("mypy returned non-zero but no parseable errors for %s", file_path)
                 return 10.0
-
-            # Phase 5 fix: Calculate score based on actual error count
-            # Formula: 10 - (errors * 0.5), but cap at 0.0
             score = 10.0 - (error_count * 0.5)
-            logger.debug(f"mypy found {error_count} errors for {file_path}, score: {score:.1f}/10")
+            logger.debug("mypy found %s errors for %s, score: %s/10", error_count, file_path, score)
             return max(0.0, min(10.0, score))
-
         except subprocess.TimeoutExpired:
-            logger.warning(f"mypy timed out for {file_path}")
-            return 5.0  # Neutral on timeout
+            logger.warning("mypy timed out for %s", file_path)
+            return 5.0
         except FileNotFoundError:
-            # mypy not found in PATH
-            logger.debug(f"mypy not found in PATH for {file_path}")
-            self.has_mypy = False  # Update availability flag
+            logger.debug("mypy not found in PATH for %s", file_path)
+            self.has_mypy = False
             return 5.0
         except Exception as e:
-            # Any other error
-            logger.warning(f"mypy failed for {file_path}: {e}", exc_info=True)
+            logger.warning("mypy failed for %s: %s", file_path, e, exc_info=True)
             return 5.0
 
     def get_mypy_errors(self, file_path: Path) -> list[dict[str, Any]]:
@@ -1052,15 +1046,30 @@ class CodeScorer(BaseScorer):
         Get detailed mypy type checking errors for a file.
 
         Phase 6.2: Modern Quality Analysis - mypy Integration
-
-        Returns:
-            List of error dictionaries with line, message, error_code, etc.
+        ENH-002-S2: Prefer ScopedMypyExecutor with fallback to full mypy.
         """
         if not self.has_mypy or file_path.suffix != ".py":
             return []
 
         try:
-            # Optimization (ENH-002): Scoped to single file with --no-incremental for 6x speedup
+            from .tools.scoped_mypy import ScopedMypyExecutor
+            executor = ScopedMypyExecutor()
+            result = executor.run_scoped_sync(file_path, timeout=10)
+            if result.files_checked == 1 or result.issues:
+                return [
+                    {
+                        "filename": str(i.file_path),
+                        "line": i.line,
+                        "message": i.message,
+                        "error_code": i.error_code,
+                        "severity": i.severity,
+                    }
+                    for i in result.issues
+                ]
+        except Exception:
+            pass
+
+        try:
             result = subprocess.run(  # nosec B603
                 [
                     sys.executable,
@@ -1068,32 +1077,22 @@ class CodeScorer(BaseScorer):
                     "mypy",
                     "--show-error-codes",
                     "--no-error-summary",
-                    "--no-incremental",  # Skip cache for single-file check (faster)
+                    "--no-incremental",
                     str(file_path),
                 ],
                 capture_output=True,
                 text=True,
                 encoding="utf-8",
                 errors="replace",
-                timeout=30,  # Optimized from 60s for single file
+                timeout=30,
                 cwd=file_path.parent if file_path.parent.exists() else None,
             )
-
-            if result.returncode == 0:
-                # No errors
-                return []
-
-            if not result.stdout.strip():
+            if result.returncode == 0 or not result.stdout.strip():
                 return []
-
-            # Parse mypy error output
-            # Format: filename:line: error: message [error-code]
             errors = []
             for line in result.stdout.strip().split("\n"):
                 if "error:" not in line.lower():
                     continue
-
-                # Parse line: "file.py:12: error: Missing return type [func-returns]"
                 parts = line.split(":", 3)
                 if len(parts) >= 4:
                     filename = parts[0]
@@ -1101,10 +1100,7 @@ class CodeScorer(BaseScorer):
                         line_num = int(parts[1])
                     except ValueError:
                         continue
-
                     error_msg = parts[3].strip()
-
-                    # Extract error code (if present)
                     error_code = None
                     if "[" in error_msg and "]" in error_msg:
                         start = error_msg.rfind("[")
@@ -1112,19 +1108,14 @@ class CodeScorer(BaseScorer):
                         if start < end:
                             error_code = error_msg[start + 1 : end]
                             error_msg = error_msg[:start].strip()
-
-                    errors.append(
-                        {
-                            "filename": filename,
-                            "line": line_num,
-                            "message": error_msg,
-                            "error_code": error_code,
-                            "severity": "error",
-                        }
-                    )
-
+                    errors.append({
+                        "filename": filename,
+                        "line": line_num,
+                        "message": error_msg,
+                        "error_code": error_code,
+                        "severity": "error",
+                    })
             return errors
-
         except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
             return []
 

tapps_agents/agents/reviewer/tools/__init__.py

@@ -8,9 +8,33 @@ from .parallel_executor import (
     ToolResult,
     ToolStatus,
 )
+from .ruff_grouping import (
+    GroupedRuffIssues,
+    RuffGroupingConfig,
+    RuffGroupingParser,
+    RuffIssue,
+    RuffParsingError,
+)
+from .scoped_mypy import (
+    MypyIssue,
+    MypyResult,
+    MypyTimeoutError,
+    ScopedMypyConfig,
+    ScopedMypyExecutor,
+)
 
 __all__ = [
+    "GroupedRuffIssues",
+    "MypyIssue",
+    "MypyResult",
+    "MypyTimeoutError",
     "ParallelToolExecutor",
+    "RuffGroupingConfig",
+    "RuffGroupingParser",
+    "RuffIssue",
+    "RuffParsingError",
+    "ScopedMypyConfig",
+    "ScopedMypyExecutor",
     "ToolExecutionConfig",
     "ToolResult",
     "ToolStatus",