agentready 2.46.2__tar.gz → 2.47.0__tar.gz

{agentready-2.46.2/src/agentready.egg-info → agentready-2.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentready
-Version: 2.46.2
+Version: 2.47.0
 Summary: Assess and bootstrap git repositories for AI-assisted development with automated remediation
 Author-email: Jeremy Eder <jeder@redhat.com>
 License: MIT

{agentready-2.46.2 → agentready-2.47.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentready"
-version = "2.46.2"
+version = "2.47.0"
 description = "Assess and bootstrap git repositories for AI-assisted development with automated remediation"
 authors = [{name = "Jeremy Eder", email = "jeder@redhat.com"}]
 readme = "README.md"

{agentready-2.46.2 → agentready-2.47.0}/src/agentready/assessors/code_quality.py

@@ -3,6 +3,7 @@
 import ast
 import logging
 import re
+import tomllib
 
 from ..models.attribute import Attribute
 from ..models.finding import Citation, Finding, Remediation
@@ -73,7 +74,13 @@ class TypeAnnotationsAssessor(BaseAssessor):
             )
 
     def _assess_python_types(self, repository: Repository) -> Finding:
-        """Assess Python type annotations using AST parsing."""
+        """Assess Python type annotations using AST parsing.
+
+        Checks both annotation coverage (current state) and strict mode
+        configuration (prevents new violations). Both matter — strict mode
+        stops new untyped code from entering; coverage measures what's already
+        typed.
+        """
         # Use AST parsing to accurately detect type annotations
         try:
             # Security: Use safe_subprocess_run for validation and limits
@@ -130,28 +137,121 @@ class TypeAnnotationsAssessor(BaseAssessor):
             )
 
         coverage_percent = (typed_functions / total_functions) * 100
-        score = self.calculate_proportional_score(
+
+        # Check for strict mode configuration (mypy/pyright)
+        strict_mode = self._check_strict_mode(repository)
+
+        # Score combines coverage (up to 80 pts) + strict mode bonus (up to 20 pts)
+        coverage_score = self.calculate_proportional_score(
             measured_value=coverage_percent,
             threshold=80.0,
             higher_is_better=True,
         )
+        score = min(100.0, coverage_score + (20.0 if strict_mode else 0.0))
 
         status = "pass" if score >= 75 else "fail"
 
+        evidence = [
+            f"Typed functions: {typed_functions}/{total_functions}",
+            f"Coverage: {coverage_percent:.1f}%",
+        ]
+        if strict_mode:
+            evidence.append("Strict mode configured")
+        else:
+            evidence.append("No strict mode configuration found")
+
         return Finding(
             attribute=self.attribute,
             status=status,
             score=score,
             measured_value=f"{coverage_percent:.1f}%",
-            threshold="≥80%",
-            evidence=[
-                f"Typed functions: {typed_functions}/{total_functions}",
-                f"Coverage: {coverage_percent:.1f}%",
-            ],
+            threshold="≥80% coverage + strict mode",
+            evidence=evidence,
             remediation=self._create_remediation() if status == "fail" else None,
             error_message=None,
         )
 
+    @staticmethod
+    def _check_strict_mode(repository: Repository) -> bool:
+        """Check whether the Python type checker is configured in strict mode.
+
+        Looks for mypy/pyright strict mode configuration in pyproject.toml,
+        mypy.ini, setup.cfg, or pyrightconfig.json.
+
+        ADR A.6: Strict mode prevents new violations; coverage measures
+        current state. Both matter.
+        """
+        # Check pyproject.toml for mypy/pyright strict config
+        pyproject_path = repository.path / "pyproject.toml"
+        if pyproject_path.exists():
+            try:
+                with open(pyproject_path, "rb") as f:
+                    data = tomllib.load(f)
+
+                # mypy: [tool.mypy] strict = true
+                tool = data.get("tool", {})
+                mypy_cfg = tool.get("mypy", {})
+                if mypy_cfg.get("strict", False):
+                    return True
+                if "disallow_untyped_defs" in mypy_cfg and mypy_cfg[
+                    "disallow_untyped_defs"
+                ]:
+                    return True
+
+                # pyright: [tool.pyright] strict = true
+                pyright_cfg = tool.get("pyright", {})
+                if pyright_cfg.get("strict", False):
+                    return True
+
+            except (OSError, tomllib.TOMLDecodeError):
+                pass
+
+        # Check mypy.ini
+        mypy_ini_path = repository.path / "mypy.ini"
+        if mypy_ini_path.exists():
+            try:
+                content = mypy_ini_path.read_text(encoding="utf-8")
+                if "[mypy]" in content:
+                    for line in content.splitlines():
+                        stripped = line.strip().lower()
+                        if stripped == "strict = true" or stripped == "strict=true":
+                            return True
+                        if stripped.startswith("disallow_untyped_defs"):
+                            return True
+            except OSError:
+                pass
+
+        # Check setup.cfg
+        setup_cfg_path = repository.path / "setup.cfg"
+        if setup_cfg_path.exists():
+            try:
+                content = setup_cfg_path.read_text(encoding="utf-8")
+                if "[mypy]" in content or "[mypy]" in content.lower():
+                    for line in content.splitlines():
+                        stripped = line.strip().lower()
+                        if "strict = true" in stripped or "strict=true" in stripped:
+                            return True
+                        if stripped.startswith("disallow_untyped_defs"):
+                            return True
+            except OSError:
+                pass
+
+        # Check pyrightconfig.json
+        pyright_path = repository.path / "pyrightconfig.json"
+        if pyright_path.exists():
+            try:
+                import json
+
+                content = json.loads(pyright_path.read_text(encoding="utf-8"))
+                if content.get("typeCheckingMode", "") == "strict":
+                    return True
+                if content.get("strict", False):
+                    return True
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        return False
+
     def _assess_typescript_types(self, repository: Repository) -> Finding:
         """Assess TypeScript type configuration across all tsconfig.json files.
 

{agentready-2.46.2 → agentready-2.47.0}/src/agentready/assessors/structure.py

@@ -126,6 +126,9 @@ class StandardLayoutAssessor(BaseAssessor):
         - Go: cmd/, internal/, pkg/ with go.mod, tests in *_test.go
 
         Fix for #246, #305: Support multiple valid Python layouts
+        ADR A.7: Adds naming consistency check for Python repos — mixed
+        naming conventions (camelCase vs snake_case in same directory) reduce
+        "glob-ability" for agents.
         """
         if self._primary_language(repository, {"Python", "Go"}) == "Go":
             return self._assess_go_layout(repository)
@@ -162,6 +165,16 @@ class StandardLayoutAssessor(BaseAssessor):
             higher_is_better=True,
         )
 
+        # ADR A.7: Naming consistency check for Python repos
+        naming_penalty = 0.0
+        naming_evidence = []
+        if repository.languages.get("Python", 0) > 0:
+            penalty, evidence = self._check_naming_consistency(repository)
+            naming_penalty = penalty
+            naming_evidence = evidence
+
+        score = max(0.0, score - naming_penalty)
+
         status = "pass" if score >= 75 else "fail"
 
         # Build evidence with detailed source directory info
@@ -180,7 +193,7 @@ class StandardLayoutAssessor(BaseAssessor):
             f"Found {found_dirs}/{required_dirs} standard directories",
             source_evidence,
             f"tests/: {'✓' if has_tests else '✗'}",
-        ]
+        ] + naming_evidence
 
         return Finding(
             attribute=self.attribute,
@@ -497,6 +510,93 @@ project/
             ],
         )
 
+    def _check_naming_consistency(self, repository: Repository) -> tuple:
+        """Check for mixed naming conventions in the same directory.
+
+        ADR A.7: Inconsistent naming (camelCase vs snake_case coexisting in
+        the same directory) reduces "glob-ability" for agents. A consistent
+        naming convention makes it easier for agents to use glob patterns like
+        `src/**/*.py` to find all relevant files.
+
+        Returns:
+            (penalty_score, evidence_list)
+            - penalty_score: 0-20, where 20 is maximum penalty for mixed conventions
+            - evidence_list: human-readable evidence strings
+        """
+        # Only check source directories, not test directories
+        # We look at Python files (.py, .pyi) in source locations
+        source_path = repository.path / "src"
+        if not source_path.exists():
+            # Try project-named directory
+            package_name = self._get_package_name_from_pyproject(repository)
+            if package_name:
+                source_path = repository.path / package_name.replace("-", "_")
+            if not source_path.exists():
+                # Fall back to root for small repos
+                source_path = repository.path
+
+        file_stats: dict = {"snake_case": 0, "camelCase": 0, "mixed": set()}
+        total_files = 0
+
+        try:
+            for py_file in source_path.rglob("*.py"):
+                # Skip venv, node_modules, etc.
+                if any(
+                    part in py_file.parts
+                    for part in [".venv", "venv", "node_modules", ".git", ".tox"]
+                ):
+                    continue
+                total_files += 1
+                dirname = py_file.parent.name
+                filename = py_file.name
+
+                # Group files by directory and check naming per directory
+                is_snake = bool(re.fullmatch(r"[a-z][a-z0-9]*(?:_[a-z0-9]+)*\.py(?:i)?$", filename))
+                is_camel = bool(re.fullmatch(r"[a-z][a-zA-Z0-9]*\.py(?:i)?$", filename))
+
+                if is_snake and is_camel:
+                    pass  # lowercase is snake_case
+                elif is_snake:
+                    key = f"{dirname}/"
+                    if key not in file_stats:
+                        file_stats[key] = {"snake_case": 0, "camelCase": 0}
+                    file_stats[key]["snake_case"] += 1
+                elif is_camel:
+                    key = f"{dirname}/"
+                    if key not in file_stats:
+                        file_stats[key] = {"snake_case": 0, "camelCase": 0}
+                    file_stats[key]["camelCase"] += 1
+
+        except OSError:
+            return 0.0, []
+
+        # Check if any directory has mixed naming
+        penalty = 0.0
+        evidence = []
+
+        for dir_key, counts in file_stats.items():
+            snake_count = counts.get("snake_case", 0)
+            camel_count = counts.get("camelCase", 0)
+
+            # Only count directories with at least 2 files (need meaningful sample)
+            if snake_count > 0 and camel_count > 0:
+                total_in_dir = snake_count + camel_count
+                if total_in_dir >= 2:
+                    penalty += 10.0
+                    evidence.append(
+                        f"Mixed naming in {dir_key}: {snake_count} snake_case, {camel_count} camelCase"
+                    )
+
+        # Cap the penalty at 20 points
+        penalty = min(20.0, penalty)
+
+        if penalty > 0:
+            evidence.insert(0, "Inconsistent naming conventions detected")
+        elif total_files > 0:
+            evidence.append("Naming convention consistent")
+
+        return penalty, evidence
+
     def _create_remediation(self, has_source: bool, has_tests: bool) -> Remediation:
         """Create context-aware remediation guidance for standard layout.
 

{agentready-2.46.2 → agentready-2.47.0}/src/agentready/assessors/testing.py

@@ -564,12 +564,17 @@ class TestExecutionAssessor(BaseAssessor):
 
         text_sources = self._read_go_build_files(repository)
 
-        has_test_cmd = bool(re.search(r"(?:\bgo|\$\(GO\))\s+test\b", text_sources))
+        has_test_cmd = bool(
+            re.search(
+                r"(?:\bgo|\$\(GO\))\s+test\b|\bmake\s+test\b|\bginkgo\b",
+                text_sources,
+            )
+        )
         if has_test_cmd:
             score += 20.0
             evidence.append("Go test command found in project files")
         else:
-            evidence.append("No 'go test' command found in Makefile/CI/README")
+            evidence.append("No test command found in Makefile/CI/README/AGENTS.md")
 
         has_coverage = bool(
             re.search(r"(?<!\S)-cover(?:\b|profile\b|mode\b)", text_sources)
@@ -634,6 +639,8 @@ class TestExecutionAssessor(BaseAssessor):
             repository.path / "Makefile",
             repository.path / "Taskfile.yml",
             repository.path / "README.md",
+            repository.path / "AGENTS.md",
+            repository.path / "CLAUDE.md",
         ]
 
         # Include module-local build files (Go monorepos)

{agentready-2.46.2 → agentready-2.47.0/src/agentready.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentready
-Version: 2.46.2
+Version: 2.47.0
 Summary: Assess and bootstrap git repositories for AI-assisted development with automated remediation
 Author-email: Jeremy Eder <jeder@redhat.com>
 License: MIT