From 20d0e870988ac83d72429ba483c61b00eab71e2a Mon Sep 17 00:00:00 2001 From: TensorTemplar Date: Sun, 8 Feb 2026 09:43:47 +0200 Subject: [PATCH 1/5] Refactor guard logic to not fail on gitignored subdirs --- .coverage | Bin 53248 -> 53248 bytes coverage.xml | 1951 +++++++++-------- src/slopometry/core/code_analyzer.py | 2 - src/slopometry/core/code_quality_cache.py | 56 +- src/slopometry/core/complexity_analyzer.py | 10 +- src/slopometry/core/coverage_analyzer.py | 6 +- src/slopometry/core/hook_handler.py | 8 +- src/slopometry/core/models.py | 51 +- src/slopometry/core/plan_analyzer.py | 6 +- src/slopometry/core/project_guard.py | 61 +- src/slopometry/core/tokenizer.py | 8 +- .../services/current_impact_service.py | 75 +- tests/test_code_analyzer.py | 3 +- tests/test_code_quality_cache.py | 12 +- tests/test_coverage_analyzer.py | 2 +- tests/test_current_impact_service.py | 117 +- tests/test_feedback_cache.py | 63 + tests/test_hook_handler.py | 141 ++ tests/test_models.py | 65 +- tests/test_project_guard.py | 107 + tests/test_tokenizer.py | 17 +- 21 files changed, 1709 insertions(+), 1052 deletions(-) diff --git a/.coverage b/.coverage index 7488cb5bf78cd238d113d92f7f30f444545a0120..86ecbb803fabccb53af612d5ffbf223226681eae 100644 GIT binary patch delta 1264 zcmX|>4^R|U9LL}8?cVO*-rgQ`%KhOG0{`Hokco&6?vWT+{y~ZW8IzGoZ4{0%6BB_u z|6wYEz9};rPm8oMjXxVmhk8deIa_;x*=-aole2F7wUo`~LR(es6!D z_uH9gJF2i9RkWp9SRH+lw$eP+MOBCv%b*f=<~&E331Elz!kGtiX)+eYQSh%NFF{ML z7Bj(RxkaQAd0EJt4%=Rih9kKq(tw<_XU>v^I((rX*5;(ch6M~;X02HL&YJ0!?=Omh zsX2?pRSUb7uTWO{5?Mg9R0?0kr)j*zcgjDx37Rjt4TOOyW5%iHDx29yhwOw(ZI@5l@jEgn-4gzsUlW_uJ$NmGSNOKN>z|koXIFH4` zyrLq~w30yJ_WUdaZ6uAw1cDB~Az;h^YYJzFc~#GN^)RJyvAC+ZWzrjZz~AC~`A_-R zdA%m6QE}gL8JvM*)RKBc-Ok=-zh{rJO{`AkQ~j=TsZOdIR67|rv!2OfQs@upB038- zxsPh4TByC$S}L1*fzpdn+Ve^(I+?(jNhUa>egk6oqJB1Jgv0gOGg1?fziQkT>TJh- zFycHpH1Exlkh~FWY?h+WXX;Ote{E#;V0tQL;#IbIy+yfnW5p4GK15R(vvN@Y*n5^679`He(I z*FuX>=fk>#+!Rl9`|lrx07-4$1PEd^aU^!U#Ed>>+zq>>Icjl8MWb!k)vE z7_(giAMKq|mv-Ol2$jzZK4^U}D38kR;%`Snr#oi_>(=-@k|@iK=e$e(9Y0RLeke02 z%0KLGt2o`McJ*wU_3&I^xEf8HCD&*q7_M%d8WjBApKAT0Q0-4&-#XOcK{0x)UQzxS zlf0gh3+|q-!!?R0t##K=mlW*8Otod6Hnk-5Rdn^dTaxa#iiZAm<(}V#~d{;&T5;y#+ZS&_8RQJe(l>@R4;GjhTfMqhUC3X>& z_3i}V{^(YsO^XAN>}a8~gMJj8n{tDYqISqHy+qD@zhP=F2|nMy9TTGZ;iiJkC~L{*Ui>B zuS=`rr*zN7Mx;9ePy6-iSQzp^eAI^JCs zxDxn!ZXnzp>%gW!`2={laiWljqfh5XIg2l2K8y0#8*B)3bFu;V#c$t*+QqwrgB-2L zP|^(A`Qc&Z=nkh8x}ZG;uDN6;&vvkBrj}pMpVi2`PV)!f$DiPLh}lgo8g$RxJz^Sf ym>5RK;*%nhoEQ-!G&&YwF|gE;jK#q{j_1v0F0zoMjz}UK5xpuRvEoHXdg{OMz3gEC delta 1168 zcmYk5drVVT9LMju+-Gmw%Nt5*0TB_2!(`x#kQRj%HeNCpz$L(BjwPGG%!ZDKw+tf- z69G@uFr6ivnNGyW?ux8D+PFU)Fa(#tWaZ()W-=7%BqCwn-W}>(_Dk;het*B;d305M-Xf#eyuql;=T)KkP5m=oL{+0DI%uElU(nC=igwlAZ zGx-87++s3-5LjU{0S(N_N`cQz{va6oq!oc6_(58}xIevzdWB)A-^n*fj{cE9%qOTH z5;y5uRhas+>JXt}OXxUdB6W^iBEKZcxJ&A6E{C-;-*}Z!CYHtTkV|;2vd(LO$?0m< z;bLvBh4`0^CH0vEVynxIgRX3HjgQp5N+7%!l~9Bj3ghw&2(&!Ugg~*jKiyQXFV*DTc0N=*v@B!)-HLL1T?NDh{tkSJ~r0n7zaD!YYcb*GZJX0(v zh85k4HbpD@6MKZsWD}Xw%-c*RvyPsiZ_+pD3v@M|M;qu^(Z~A^Mf=7OfZd>hVGW1S zKRMN~9UVK|kP;gcf$Dn$s=Qu$ldi}s7%vO!=yVG^F9S~%CPn*O)eC28kw>3U zVv%ksU8O>$fts<7Jk&Y_X}E0q$|j{tTOD-#fJ@d?iql^>ZC%2-5l7*B9pl%x>0sB1 z-RO3ooY(~PFuY0gZY_(L>#9OlldvN!wid+DV+D@k9`6~RTVph4j_f8X8XOV-YfX)1 z81eRx7B>Sdr#A{~5irL!cZc)ff^cK8e3XAN)4{hU`w?b0pA5fm(khIoPB;vP*Q{`+ zX*2ykO|oqLKInUL2LP?f{-I}`LkG7;n?0-57P>pm|KPSH zqi}Xl*E(r - + @@ -16,7 +16,7 @@ - + @@ -51,27 +51,27 @@ - - + + + - - - + + + - - - + + + - - + + - - + - + @@ -87,71 +87,67 @@ - - + + + + + + + + - - - - - - - - - - - - - + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - - - - - - + + - + - - - - @@ -285,7 +281,7 @@ - + @@ -340,172 +336,174 @@ - + - + - + - - - + + + - + - + - + - + - + - - - - - + + + + + - + - + - - - + + + - - + + - + - - - - - - + + + + + + - + - - - + + + - + - - + + - - + + - - + + - + - + - - - - - + + + + + - - + + - - + + - + - + - - - - + + + + - + - + - + - + + - - + + - + - + - + - + - - - + + + + @@ -744,86 +742,86 @@ - - - - - - - + + + + + + - - + + - + - - - + + + - + - - - - + + + + - - - - - - - + + + + + + + - - - - - + + + + + - + - + - - - + + - - - - - + + + + + - - + + + + - + @@ -940,67 +938,67 @@ - - - - + + + + - - - - + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + - - + + - + @@ -1013,7 +1011,7 @@ - + @@ -1034,11 +1032,11 @@ - - - - - + + + + + @@ -1052,13 +1050,13 @@ - + - + - - - + + + @@ -1066,14 +1064,14 @@ - - - - - - - - + + + + + + + + @@ -1106,9 +1104,9 @@ - - - + + + @@ -1372,22 +1370,22 @@ - - + + - - - - - + + + + + - - + + - + @@ -1457,9 +1455,9 @@ - + - + @@ -1487,7 +1485,7 @@ - + @@ -1650,7 +1648,7 @@ - + @@ -1669,18 +1667,18 @@ - - + + - + - + - + @@ -1689,54 +1687,54 @@ - - - + + + - + - - - + + + - - - - - - - - - - + + + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + @@ -1744,12 +1742,12 @@ - + - - - - + + + + @@ -1790,277 +1788,277 @@ - - - - - + + + + + - - - - - - - + + + + + + + + + - + + - - - + - + - - - - - - - + + + + + + + + - - - - - + + + + - - - - - + + + + + - + - - + - - - - - - + + + + + + + + - - + - + - - - - + + + + + - - + - - - - - - - + + + + + + + - + + - - + + - - + - + - + + - - + - - + + - + + - - + + - - - + - + + - + + - - - - + + + + + - - - + - + - + - + + - - + - + - + - - - - - + + + + + + + - - - + - + - + - + + - - + - - - - - - - - - + + + + + + + + + + - - + - + + - - @@ -2070,21 +2068,21 @@ + - + - - - + + + - @@ -2092,11 +2090,15 @@ - - - - - + + + + + + + + + @@ -2444,7 +2446,7 @@ - + @@ -2555,78 +2557,76 @@ - - - - - + + + - - - - + + + + - + + - - + + - - + + - - - - + + - - - + + - + - - - - + + + + + + + + + + + + + + + - - - - - - - - - - - + + @@ -2636,61 +2636,57 @@ - - - - + + + - - + + - + + + - - - - + - - - + + + + + + + - - - - - - - - - + + + + + - - + + - - @@ -2700,196 +2696,198 @@ - - - - + + + + + + + + + + + - - - - + + - - + + + - - + + + - - - - + + + - - - + + + + - - - - - + + + - - - + + + - - - - + + + - - - - + - - + + - + - + + + - + + + - + + - - + - + - - + - - - + + + + + + - - - - - - - + + + - + + + + + + - - - + + + + + + - - - - - - - - - - - + + + + + + + + + + - - - - - - - - - - + - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - + + - - + + + + - - + + - - - + + + - - - - + + - - - + + + @@ -2902,37 +2900,37 @@ - - + + - + - + + - + - - - + - - + + + + - - - + + + + - - @@ -2940,8 +2938,8 @@ - - + + @@ -2960,311 +2958,327 @@ - - - + + + + + - + - - + + + + - - - - - - + + - + + + + + + + + - - - - - - + + + + - - - + + + + + + - - - - - - - - + + - + + + + - - - - + + + - - - - - - - - - - + + + + + + + + - - + - + - - + + - - + + + + + + + + - - - - - - - - - + + + - + + + + + - - - + + + + - - - - - - - - + + + + + - + - + + - - + + + - - - + + - - - + + - - - - + - - - - - - + + + - - - + + + + + + - - - + + + + - + - - - - - + + + + - - + - - - + + - + - - + + + + - + + - - + + + + + + + + + + + + + + + + + - + - + + - - - - + + + - + - - - + + + - - + - - - - - + + + + + + - + - - - + + + - - - + + + - + - + - - - + + + + - - - + + - - - - - - - + + + + + + + - + - + + - - + - - - - - + + + + + - - - + + + - + - + @@ -3272,10 +3286,13 @@ - + + + + - + @@ -3313,57 +3330,85 @@ - + + + + + + - - - - - - - + + - - - - - + + - + + + + + - - - - - - - - - - + + + - - - + + + + + - - - + + + + + + + + + + + - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -3391,11 +3436,11 @@ - + - + @@ -4008,7 +4053,7 @@ - + @@ -4016,26 +4061,27 @@ - - - + + + - - - + + - - - - - - - + + + + + + + + + @@ -4206,7 +4252,7 @@ - + @@ -4257,17 +4303,17 @@ - - - + + + - - - + + + @@ -6439,7 +6485,7 @@ - + @@ -6638,7 +6684,7 @@ - + @@ -6647,123 +6693,146 @@ - + + - - + + - - - - - + + + + - + + - - + + - - - - - + + + + + - + - + - + - + - + - - - + + + - + - - - - - - + + + + + + - + - + - - - + + + - - + + - - + + - + - + - + - - - + + + - + - + - - + + - + - + - + - - - - - + + + + + - + - + - + - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/slopometry/core/code_analyzer.py b/src/slopometry/core/code_analyzer.py index 3c89bd3..0e0cd78 100644 --- a/src/slopometry/core/code_analyzer.py +++ b/src/slopometry/core/code_analyzer.py @@ -71,7 +71,6 @@ def _analyze_single_file(file_path: Path) -> FileAnalysisResult: difficulty=0.0, effort=0.0, mi=0.0, - tokens=0, error=str(e), ) @@ -126,7 +125,6 @@ def analyze_file(self, file_path: Path) -> FileAnalysisResult: difficulty=0.0, effort=0.0, mi=0.0, - tokens=0, error=str(e), ) diff --git a/src/slopometry/core/code_quality_cache.py b/src/slopometry/core/code_quality_cache.py index 6d2b02d..178abf6 100644 --- a/src/slopometry/core/code_quality_cache.py +++ b/src/slopometry/core/code_quality_cache.py @@ -5,7 +5,7 @@ from datetime import datetime, timedelta from slopometry.core.complexity_analyzer import CALCULATOR_VERSION -from slopometry.core.models import ComplexityDelta, ExtendedComplexityMetrics +from slopometry.core.models import CacheUpdateError, ComplexityDelta, ExtendedComplexityMetrics class CodeQualityCacheManager: @@ -37,33 +37,9 @@ def get_cached_metrics( if working_tree_hash is None: cursor = self.db_connection.execute( """ - SELECT complexity_metrics_json, complexity_delta_json - FROM code_quality_cache - WHERE session_id = ? AND repository_path = ? AND commit_sha = ? - AND working_tree_hash IS NULL - AND (calculator_version = ? OR calculator_version IS NULL) - """, - (session_id, repository_path, commit_sha, CALCULATOR_VERSION), - ) - else: - cursor = self.db_connection.execute( - """ - SELECT complexity_metrics_json, complexity_delta_json - FROM code_quality_cache - WHERE session_id = ? AND repository_path = ? AND commit_sha = ? - AND working_tree_hash = ? - AND (calculator_version = ? OR calculator_version IS NULL) - """, - (session_id, repository_path, commit_sha, working_tree_hash, CALCULATOR_VERSION), - ) - row = cursor.fetchone() - - if working_tree_hash is None: - cursor = self.db_connection.execute( - """ - SELECT complexity_metrics_json, complexity_delta_json - FROM code_quality_cache - WHERE session_id = ? AND repository_path = ? AND commit_sha = ? + SELECT complexity_metrics_json, complexity_delta_json + FROM code_quality_cache + WHERE session_id = ? AND repository_path = ? AND commit_sha = ? AND working_tree_hash IS NULL AND calculator_version = ? """, @@ -72,9 +48,9 @@ def get_cached_metrics( else: cursor = self.db_connection.execute( """ - SELECT complexity_metrics_json, complexity_delta_json - FROM code_quality_cache - WHERE session_id = ? AND repository_path = ? AND commit_sha = ? + SELECT complexity_metrics_json, complexity_delta_json + FROM code_quality_cache + WHERE session_id = ? AND repository_path = ? AND commit_sha = ? AND working_tree_hash = ? AND calculator_version = ? """, @@ -214,9 +190,9 @@ def cleanup_old_cache_entries(self, days_old: int = 30) -> int: def update_cached_coverage( self, session_id: str, - test_coverage_percent: float, + test_coverage_percent: float | None, test_coverage_source: str, - ) -> bool: + ) -> bool | CacheUpdateError: """Update test coverage fields in cached metrics for a session. Args: @@ -225,7 +201,7 @@ def update_cached_coverage( test_coverage_source: Source file path (e.g., coverage.xml) Returns: - True if successfully updated, False otherwise + True if successfully updated, CacheUpdateError otherwise """ try: cursor = self.db_connection.execute( @@ -234,7 +210,10 @@ def update_cached_coverage( ) row = cursor.fetchone() if not row: - return False + return CacheUpdateError( + message="No cached metrics found for session", + session_id=session_id, + ) metrics_data = json.loads(row[0]) metrics_data["test_coverage_percent"] = test_coverage_percent @@ -247,8 +226,11 @@ def update_cached_coverage( self.db_connection.commit() return True - except (sqlite3.Error, json.JSONDecodeError, Exception): - return False + except (sqlite3.Error, json.JSONDecodeError) as e: + return CacheUpdateError( + message=str(e), + session_id=session_id, + ) def get_cache_statistics(self) -> dict[str, int]: """Get statistics about the cache. diff --git a/src/slopometry/core/complexity_analyzer.py b/src/slopometry/core/complexity_analyzer.py index c5762b0..bd96f59 100644 --- a/src/slopometry/core/complexity_analyzer.py +++ b/src/slopometry/core/complexity_analyzer.py @@ -104,8 +104,9 @@ def _analyze_directory(self, directory: Path) -> ComplexityMetrics: relative_path = self._get_relative_path(result.path, directory) files_by_complexity[relative_path] = result.complexity all_complexities.append(result.complexity) - files_by_token_count[relative_path] = result.tokens - all_token_counts.append(result.tokens) + if isinstance(result.tokens, int): + files_by_token_count[relative_path] = result.tokens + all_token_counts.append(result.tokens) total_files = len(all_complexities) total_complexity = sum(all_complexities) @@ -388,8 +389,9 @@ def analyze_extended_complexity(self, directory: Path | None = None) -> Extended files_by_mi[relative_path] = result.mi mi_file_count += 1 - files_by_token_count[relative_path] = result.tokens - all_token_counts.append(result.tokens) + if isinstance(result.tokens, int): + files_by_token_count[relative_path] = result.tokens + all_token_counts.append(result.tokens) elapsed_total = time.perf_counter() - start_total mode = "parallel" if len(all_files) >= settings.parallel_file_threshold else "sequential" diff --git a/src/slopometry/core/coverage_analyzer.py b/src/slopometry/core/coverage_analyzer.py index d9fff2c..edc7636 100644 --- a/src/slopometry/core/coverage_analyzer.py +++ b/src/slopometry/core/coverage_analyzer.py @@ -11,7 +11,9 @@ class CoverageResult(BaseModel): """Result of coverage analysis from existing files.""" - total_coverage_percent: float = Field(default=0.0, description="Total test coverage percentage (0-100)") + total_coverage_percent: float | None = Field( + default=None, description="Total test coverage percentage (0-100), None if unavailable" + ) num_statements: int = Field(default=0, description="Total number of statements") covered_statements: int = Field(default=0, description="Number of covered statements") missing_statements: int = Field(default=0, description="Number of missing statements") @@ -128,7 +130,7 @@ def _parse_coverage_db(self, db_path: Path) -> CoverageResult: try: total_percent = cov.report(file=output, show_missing=False) except Exception: - total_percent = 0.0 + total_percent = None # N/A - report failed but file parsing may still work data = cov.get_data() measured_files = data.measured_files() diff --git a/src/slopometry/core/hook_handler.py b/src/slopometry/core/hook_handler.py index 2f5f12a..a38ec75 100644 --- a/src/slopometry/core/hook_handler.py +++ b/src/slopometry/core/hook_handler.py @@ -378,7 +378,11 @@ def handle_stop_event(session_id: str, parsed_input: "StopInput | SubagentStopIn cache_stable_parts: list[str] = [] # Only code-based feedback (stable between tool calls) # Get edited files from git (more reliable than transcript-based context coverage) - edited_files = get_modified_python_files(stats.working_directory) + try: + edited_files = get_modified_python_files(stats.working_directory) + except (ValueError, RuntimeError) as e: + logger.debug(f"Failed to get modified Python files: {e}") + edited_files = set() # Code smells - ALWAYS check (independent of enable_complexity_feedback) # This is stable (based on code state, not session activity) @@ -392,7 +396,7 @@ def handle_stop_event(session_id: str, parsed_input: "StopInput | SubagentStopIn # Context coverage - informational but NOT stable (changes with every Read/Glob/Grep) # Excluded from cache hash to avoid invalidation on tool calls - if settings.enable_complexity_feedback and stats.context_coverage and stats.context_coverage.files_edited: + if settings.enable_complexity_feedback and stats.context_coverage and stats.context_coverage.has_gaps: context_feedback = format_context_coverage_feedback(stats.context_coverage) if context_feedback: feedback_parts.append(context_feedback) diff --git a/src/slopometry/core/models.py b/src/slopometry/core/models.py index 8c0e757..a135803 100644 --- a/src/slopometry/core/models.py +++ b/src/slopometry/core/models.py @@ -308,6 +308,25 @@ class HookEvent(BaseModel): transcript_path: str | None = None +class TokenCountError(BaseModel): + """Error that occurred during token counting.""" + + model_config = ConfigDict(frozen=True) + + message: str + path: str + + +class CacheUpdateError(BaseModel): + """Error that occurred during cache update operation.""" + + model_config = ConfigDict(frozen=True) + + message: str + session_id: str + operation: str = "update_coverage" + + class FileAnalysisResult(BaseModel): """Result from analyzing a single Python file for complexity metrics.""" @@ -317,7 +336,7 @@ class FileAnalysisResult(BaseModel): difficulty: float effort: float mi: float - tokens: int + tokens: int | TokenCountError | None = None error: str | None = None @@ -919,14 +938,16 @@ class ExperimentRun(BaseModel): id: str = Field(default_factory=lambda: str(uuid4())) repository_path: Path - start_commit: str # SHA of starting commit (e.g., HEAD~1) - target_commit: str # SHA of target commit (e.g., HEAD) + start_commit: str = Field(description="SHA of starting commit (e.g., HEAD~1)") + target_commit: str = Field(description="SHA of target commit (e.g., HEAD)") process_id: int worktree_path: Path | None = None start_time: datetime = Field(default_factory=datetime.now) end_time: datetime | None = None status: ExperimentStatus = ExperimentStatus.PENDING - nfp_objective: NextFeaturePrediction | None = None # Feature objectives for this experiment + nfp_objective: NextFeaturePrediction | None = Field( + default=None, description="Feature objectives for this experiment" + ) class ExperimentProgress(BaseModel): @@ -935,7 +956,7 @@ class ExperimentProgress(BaseModel): experiment_id: str timestamp: datetime = Field(default_factory=datetime.now) current_metrics: ExtendedComplexityMetrics - target_metrics: ExtendedComplexityMetrics # From HEAD commit + target_metrics: ExtendedComplexityMetrics = Field(description="Metrics from HEAD commit") # Legacy CLI metrics (deprecated - use qpe_score instead) cli_score: float = Field( @@ -958,15 +979,15 @@ class CommitComplexitySnapshot(BaseModel): timestamp: datetime complexity_metrics: ExtendedComplexityMetrics parent_commit_sha: str | None = None - complexity_delta: ComplexityDelta | None = None # Delta from parent + complexity_delta: ComplexityDelta | None = Field(default=None, description="Delta from parent commit") class CommitChain(BaseModel): """Represents a chain of commits with complexity evolution.""" repository_path: Path - base_commit: str # Starting point (e.g., HEAD~10) - head_commit: str # End point (e.g., HEAD) + base_commit: str = Field(description="Starting point (e.g., HEAD~10)") + head_commit: str = Field(description="End point (e.g., HEAD)") commits: list[CommitComplexitySnapshot] = Field(default_factory=list) total_complexity_growth: int = 0 average_complexity_per_commit: float = 0.0 @@ -976,8 +997,8 @@ class ComplexityEvolution(BaseModel): """Tracks how complexity evolves across commits.""" commit_sha: str - cumulative_complexity: int # Total complexity up to this commit - incremental_complexity: int # Complexity added in this commit + cumulative_complexity: int = Field(description="Total complexity up to this commit") + incremental_complexity: int = Field(description="Complexity added in this commit") files_modified: int functions_added: int functions_removed: int @@ -1488,6 +1509,16 @@ def total_blind_spots(self) -> int: """Total number of related files that were never read.""" return len(self.blind_spots) + @property + def has_gaps(self) -> bool: + """Whether there are any coverage gaps requiring attention.""" + return ( + self.files_read_before_edit_ratio < 1.0 + or self.overall_imports_coverage < 100 + or self.overall_dependents_coverage < 100 + or bool(self.blind_spots) + ) + class LanguageGuardResult(BaseModel): """Result of language guard check for complexity analysis features.""" diff --git a/src/slopometry/core/plan_analyzer.py b/src/slopometry/core/plan_analyzer.py index ae72ce1..f17a3db 100644 --- a/src/slopometry/core/plan_analyzer.py +++ b/src/slopometry/core/plan_analyzer.py @@ -1,11 +1,14 @@ """Plan evolution analysis for TodoWrite events.""" +import logging import re from datetime import datetime from typing import Any from slopometry.core.models import PlanEvolution, PlanStep, TodoItem, ToolType +logger = logging.getLogger(__name__) + class PlanAnalyzer: """Analyzes TodoWrite events to track plan evolution.""" @@ -79,7 +82,8 @@ def analyze_todo_write_event(self, tool_input: dict[str, Any], timestamp: dateti try: todo = TodoItem(**todo_data) current_todos[todo.content] = todo - except Exception: + except Exception as e: + logger.debug(f"Skipping malformed todo item: {e}") continue plan_step = self._calculate_plan_step(current_todos, timestamp) diff --git a/src/slopometry/core/project_guard.py b/src/slopometry/core/project_guard.py index 2ac8fc1..559778a 100644 --- a/src/slopometry/core/project_guard.py +++ b/src/slopometry/core/project_guard.py @@ -65,6 +65,54 @@ def _is_git_submodule(path: Path, root: Path) -> bool: return False +def _get_git_root(path: Path) -> Path | None: + """Find the enclosing git repo root for a path. + + Returns None if the path is not inside a git repository. + """ + try: + result = subprocess.run( + ["git", "-C", str(path), "rev-parse", "--show-toplevel"], + capture_output=True, + text=True, + timeout=5, + ) + if result.returncode == 0: + return Path(result.stdout.strip()) + except Exception as e: + logger.debug(f"Failed to find git root for {path}: {e}") + return None + + +def _is_gitignored_batch(paths: list[Path], git_root: Path) -> set[Path]: + """Batch-check which paths are gitignored. + + Uses `git check-ignore` to determine which of the given paths are + covered by gitignore rules. Returns the set of ignored paths. + Fails open: if the command fails, returns an empty set. + """ + if not paths: + return set() + try: + result = subprocess.run( + ["git", "-C", str(git_root), "check-ignore", *[str(p) for p in paths]], + capture_output=True, + text=True, + timeout=10, + ) + # git check-ignore exits 0 if any path is ignored, 1 if none are ignored + if result.returncode in (0, 1): + ignored = set() + for line in result.stdout.strip().split("\n"): + line = line.strip() + if line: + ignored.add(Path(line).resolve()) + return ignored + except Exception as e: + logger.debug(f"Failed to check gitignore for paths: {e}") + return set() + + def detect_multi_project_directory( root: Path, max_depth: int = 2, @@ -82,6 +130,7 @@ def detect_multi_project_directory( """ root = root.resolve() projects: list[str] = [] + git_root = _get_git_root(root) def scan_dir(path: Path, depth: int) -> None: if depth > max_depth: @@ -95,11 +144,17 @@ def scan_dir(path: Path, depth: int) -> None: return try: - for child in path.iterdir(): - if child.is_dir() and not child.name.startswith("."): - scan_dir(child, depth + 1) + children = [child for child in path.iterdir() if child.is_dir() and not child.name.startswith(".")] except PermissionError as e: logger.debug(f"Permission denied scanning directory {path}: {e}") + return + + if git_root and children: + ignored = _is_gitignored_batch(children, git_root) + children = [c for c in children if c.resolve() not in ignored] + + for child in children: + scan_dir(child, depth + 1) scan_dir(root, 0) return projects diff --git a/src/slopometry/core/tokenizer.py b/src/slopometry/core/tokenizer.py index f30a711..1e8328e 100644 --- a/src/slopometry/core/tokenizer.py +++ b/src/slopometry/core/tokenizer.py @@ -4,6 +4,8 @@ from pathlib import Path from typing import Any +from slopometry.core.models import TokenCountError + logger = logging.getLogger(__name__) _encoder: Any = None @@ -43,18 +45,18 @@ def count_tokens(content: str) -> int: return len(encoder.encode(content, disallowed_special=())) -def count_file_tokens(file_path: Path) -> int: +def count_file_tokens(file_path: Path) -> int | TokenCountError: """Count tokens in a file. Args: file_path: Path to the file to tokenize. Returns: - Number of tokens, or 0 if file cannot be read. + Number of tokens, or TokenCountError if file cannot be read. """ try: content = file_path.read_text(encoding="utf-8") return count_tokens(content) except Exception as e: logger.warning("Failed to read file for token counting %s: %s", file_path, e) - return 0 + return TokenCountError(message=str(e), path=str(file_path)) diff --git a/src/slopometry/summoner/services/current_impact_service.py b/src/slopometry/summoner/services/current_impact_service.py index 5708ed3..b99e981 100644 --- a/src/slopometry/summoner/services/current_impact_service.py +++ b/src/slopometry/summoner/services/current_impact_service.py @@ -6,6 +6,7 @@ from pathlib import Path from slopometry.core.complexity_analyzer import ComplexityAnalyzer +from slopometry.core.database import EventDatabase from slopometry.core.models import ( AnalysisSource, ComplexityDelta, @@ -15,17 +16,21 @@ RepoBaseline, ) from slopometry.core.working_tree_extractor import WorkingTreeExtractor +from slopometry.core.working_tree_state import WorkingTreeStateCalculator from slopometry.summoner.services.impact_calculator import ImpactCalculator from slopometry.summoner.services.qpe_calculator import QPECalculator logger = logging.getLogger(__name__) +CURRENT_IMPACT_SESSION_ID = "current-impact" + class CurrentImpactService: """Service for analyzing impact of uncommitted changes.""" - def __init__(self): + def __init__(self, db: EventDatabase | None = None): self.impact_calculator = ImpactCalculator() + self.db = db or EventDatabase() def analyze_uncommitted_changes( self, @@ -51,15 +56,11 @@ def analyze_uncommitted_changes( baseline_metrics = baseline.current_metrics - temp_dir = extractor.extract_working_state() + wt_calculator = WorkingTreeStateCalculator(repo_path) + commit_sha = wt_calculator.get_current_commit_sha() + working_tree_hash = wt_calculator.calculate_working_tree_hash(commit_sha) if commit_sha else None - if not temp_dir: - current_metrics = analyzer.analyze_extended_complexity() - else: - try: - current_metrics = analyzer.analyze_extended_complexity(temp_dir) - finally: - shutil.rmtree(temp_dir, ignore_errors=True) + current_metrics = self._get_or_compute_metrics(repo_path, commit_sha, working_tree_hash, extractor, analyzer) current_delta = self._compute_delta(baseline_metrics, current_metrics) @@ -258,6 +259,62 @@ def _calculate_galen_metrics( return GalenMetrics.calculate(tokens_changed=tokens_changed, period_days=period_days) + def _get_or_compute_metrics( + self, + repo_path: Path, + commit_sha: str | None, + working_tree_hash: str | None, + extractor: WorkingTreeExtractor, + analyzer: ComplexityAnalyzer, + ) -> ExtendedComplexityMetrics: + """Get metrics from cache or compute fresh. + + Args: + repo_path: Path to the repository + commit_sha: Current commit SHA + working_tree_hash: Hash of uncommitted changes + extractor: Working tree extractor for temp dir creation + analyzer: Complexity analyzer + + Returns: + ExtendedComplexityMetrics for current state + """ + from slopometry.core.code_quality_cache import CodeQualityCacheManager + + if commit_sha: + with self.db._get_db_connection() as conn: + cache_manager = CodeQualityCacheManager(conn) + cached_metrics, _ = cache_manager.get_cached_metrics( + CURRENT_IMPACT_SESSION_ID, str(repo_path), commit_sha, working_tree_hash + ) + if cached_metrics: + logger.debug("Using cached metrics for current-impact") + return cached_metrics + + temp_dir = extractor.extract_working_state() + + if not temp_dir: + current_metrics = analyzer.analyze_extended_complexity() + else: + try: + current_metrics = analyzer.analyze_extended_complexity(temp_dir) + finally: + shutil.rmtree(temp_dir, ignore_errors=True) + + if commit_sha: + with self.db._get_db_connection() as conn: + cache_manager = CodeQualityCacheManager(conn) + cache_manager.save_metrics_to_cache( + CURRENT_IMPACT_SESSION_ID, + str(repo_path), + commit_sha, + current_metrics, + working_tree_hash=working_tree_hash, + ) + logger.debug("Cached metrics for current-impact") + + return current_metrics + def _compute_delta( self, baseline_metrics: ExtendedComplexityMetrics, diff --git a/tests/test_code_analyzer.py b/tests/test_code_analyzer.py index a7241e9..c8e8e9c 100644 --- a/tests/test_code_analyzer.py +++ b/tests/test_code_analyzer.py @@ -98,7 +98,7 @@ def test_analyze_file__returns_result_for_valid_python(self, tmp_path: Path) -> assert result.path == str(test_file) assert result.error is None assert isinstance(result.complexity, int) - assert isinstance(result.tokens, int) + assert result.tokens is not None and isinstance(result.tokens, int) def test_analyze_file__returns_error_for_missing_file(self, tmp_path: Path) -> None: """Should return result with error for missing file.""" @@ -109,6 +109,7 @@ def test_analyze_file__returns_error_for_missing_file(self, tmp_path: Path) -> N assert result.path == str(missing_file) assert result.error is not None + assert result.tokens is None def test_analyze_files__returns_results_for_multiple_files(self, tmp_path: Path) -> None: """Should return list of results for multiple files.""" diff --git a/tests/test_code_quality_cache.py b/tests/test_code_quality_cache.py index 3d33ece..691a11e 100644 --- a/tests/test_code_quality_cache.py +++ b/tests/test_code_quality_cache.py @@ -5,7 +5,7 @@ from conftest import make_test_metrics from slopometry.core.code_quality_cache import CodeQualityCacheManager -from slopometry.core.models import ExtendedComplexityMetrics +from slopometry.core.models import CacheUpdateError, ExtendedComplexityMetrics class TestCodeQualityCacheManager: @@ -136,8 +136,10 @@ def test_update_cached_coverage__updates_existing_entry(self, db_connection): assert metrics.test_coverage_percent == 85.5 assert metrics.test_coverage_source == "coverage.xml" - def test_update_cached_coverage__returns_false_for_missing_session(self, db_connection): - """Test that update_cached_coverage returns False if session doesn't exist.""" + def test_update_cached_coverage__returns_error_for_missing_session(self, db_connection): + """Test that update_cached_coverage returns CacheUpdateError if session doesn't exist.""" manager = CodeQualityCacheManager(db_connection) - success = manager.update_cached_coverage("nonexistent", 75.0, "coverage.xml") - assert success is False + result = manager.update_cached_coverage("nonexistent", 75.0, "coverage.xml") + assert isinstance(result, CacheUpdateError) + assert result.session_id == "nonexistent" + assert "No cached metrics found" in result.message diff --git a/tests/test_coverage_analyzer.py b/tests/test_coverage_analyzer.py index 7af7c97..d41ed91 100644 --- a/tests/test_coverage_analyzer.py +++ b/tests/test_coverage_analyzer.py @@ -15,7 +15,7 @@ def test_coverage_result__default_values(self) -> None: """Test CoverageResult has sensible defaults.""" result = CoverageResult() - assert result.total_coverage_percent == 0.0 + assert result.total_coverage_percent is None, "Should be N/A until calculated" assert result.coverage_available is True assert result.error_message is None assert result.source_file is None diff --git a/tests/test_current_impact_service.py b/tests/test_current_impact_service.py index 73087fc..41a961e 100644 --- a/tests/test_current_impact_service.py +++ b/tests/test_current_impact_service.py @@ -6,6 +6,7 @@ import pytest from slopometry.core.complexity_analyzer import ComplexityAnalyzer +from slopometry.core.database import EventDatabase from slopometry.core.models import AnalysisSource, HistoricalMetricStats, RepoBaseline from slopometry.summoner.services.current_impact_service import CurrentImpactService @@ -13,6 +14,11 @@ class TestCurrentImpactService: """Integration tests for CurrentImpactService.""" + @pytest.fixture + def test_db(self, tmp_path): + """Isolated database scoped to each test to prevent cache leaks.""" + return EventDatabase(db_path=tmp_path / "test.db") + @pytest.fixture(scope="module") def real_baseline(self): """Compute baseline once for the current source repo.""" @@ -59,31 +65,22 @@ def test_repo_path(self, tmp_path): return dest_repo_path - def test_analyze_uncommitted_changes__no_changes_returns_none(self, test_repo_path, real_baseline): + def test_analyze_uncommitted_changes__no_changes_returns_none(self, test_repo_path, real_baseline, test_db): """Test that analyzing a clean repo returns None.""" assert real_baseline is not None, "Baseline computation failed - fixture returned None" - # Setup - service = CurrentImpactService() - - # Use valid baseline from source repo (path differs but complexity is same) - # We need to patch the baseline repository_path to match test_repo_path - # or mock the baseline checking if it validates path. - # But analyze_uncommitted_changes only uses baseline.current_metrics. + service = CurrentImpactService(db=test_db) - # Mock baseline service to return our pre-computed baseline - - # Analyze result = service.analyze_uncommitted_changes(test_repo_path, real_baseline) # Should be None as there are no changes assert result is None - def test_analyze_uncommitted_changes__detects_changes(self, test_repo_path, real_baseline): + def test_analyze_uncommitted_changes__detects_changes(self, test_repo_path, real_baseline, test_db): """Test analyzing a repo with uncommitted changes.""" assert real_baseline is not None, "Baseline computation failed - fixture returned None" - service = CurrentImpactService() + service = CurrentImpactService(db=test_db) # Modify a python file target_file = test_repo_path / "src" / "slopometry" / "core" / "models.py" @@ -110,11 +107,11 @@ def test_analyze_uncommitted_changes__detects_changes(self, test_repo_path, real assert result.current_metrics.total_files_analyzed > 0 assert result.current_metrics.total_complexity > 0 - def test_analyze_previous_commit__returns_analysis_with_correct_source(self, test_repo_path, real_baseline): + def test_analyze_previous_commit__returns_analysis_with_correct_source(self, test_repo_path, real_baseline, test_db): """Test that analyzing previous commit sets the correct source.""" assert real_baseline is not None, "Baseline computation failed" - service = CurrentImpactService() + service = CurrentImpactService(db=test_db) # The test_repo_path is a clone with commits, so previous commit should exist result = service.analyze_previous_commit(test_repo_path, real_baseline) @@ -127,11 +124,10 @@ def test_analyze_previous_commit__returns_analysis_with_correct_source(self, tes assert len(result.analyzed_commit_sha) == 8 # Short SHA assert len(result.base_commit_sha) == 8 # Short SHA - def test_analyze_previous_commit__returns_none_when_no_previous_commit(self, tmp_path, real_baseline): + def test_analyze_previous_commit__returns_none_when_no_previous_commit(self, tmp_path, real_baseline, test_db): """Test that analyze_previous_commit returns None for repos with only one commit.""" assert real_baseline is not None, "Baseline computation failed" - # Create a repo with only one commit repo_path = tmp_path / "single_commit_repo" repo_path.mkdir() @@ -165,16 +161,15 @@ def test_analyze_previous_commit__returns_none_when_no_previous_commit(self, tmp capture_output=True, ) - service = CurrentImpactService() + service = CurrentImpactService(db=test_db) result = service.analyze_previous_commit(repo_path, real_baseline) assert result is None - def test_analyze_previous_commit__returns_none_when_no_python_changes(self, tmp_path, real_baseline): + def test_analyze_previous_commit__returns_none_when_no_python_changes(self, tmp_path, real_baseline, test_db): """Test that analyze_previous_commit returns None when last commit has no Python changes.""" assert real_baseline is not None, "Baseline computation failed" - # Create a repo with two commits, but the last one has no Python changes repo_path = tmp_path / "no_python_changes_repo" repo_path.mkdir() @@ -220,14 +215,14 @@ def test_analyze_previous_commit__returns_none_when_no_python_changes(self, tmp_ capture_output=True, ) - service = CurrentImpactService() + service = CurrentImpactService(db=test_db) result = service.analyze_previous_commit(repo_path, real_baseline) # Should return None because no Python files were changed assert result is None def test_analyze_previous_commit__logs_debug_on_git_operation_error( - self, test_repo_path, real_baseline, caplog, monkeypatch + self, test_repo_path, real_baseline, test_db, caplog, monkeypatch ): """Test that analyze_previous_commit logs debug messages on GitOperationError.""" assert real_baseline is not None, "Baseline computation failed" @@ -239,10 +234,86 @@ def mock_get_changed_python_files(self, parent_sha, child_sha): monkeypatch.setattr(GitTracker, "get_changed_python_files", mock_get_changed_python_files) - service = CurrentImpactService() + service = CurrentImpactService(db=test_db) with caplog.at_level(logging.DEBUG, logger="slopometry.summoner.services.current_impact_service"): result = service.analyze_previous_commit(test_repo_path, real_baseline) assert result is None assert any("Failed to get changed files" in record.message for record in caplog.records) + + def test_analyze_uncommitted_changes__uses_cache_on_second_call(self, test_repo_path, real_baseline, test_db, caplog): + """Test that second call with same state uses cached metrics.""" + assert real_baseline is not None, "Baseline computation failed" + + service = CurrentImpactService(db=test_db) + + # Modify a python file to have uncommitted changes + target_file = test_repo_path / "src" / "slopometry" / "core" / "models.py" + if not target_file.exists(): + target_file = test_repo_path / "test_file.py" + target_file.write_text("def foo():\n pass\n") + else: + with open(target_file, "a") as f: + f.write("\n\ndef cached_test_func(x):\n return x * 2\n") + + # First call - should compute and cache + with caplog.at_level(logging.DEBUG, logger="slopometry.summoner.services.current_impact_service"): + result1 = service.analyze_uncommitted_changes(test_repo_path, real_baseline) + + assert result1 is not None + cached_logged = any("Cached metrics for current-impact" in record.message for record in caplog.records) + assert cached_logged, "First call should cache metrics" + + caplog.clear() + + # Second call - should use cache + with caplog.at_level(logging.DEBUG, logger="slopometry.summoner.services.current_impact_service"): + result2 = service.analyze_uncommitted_changes(test_repo_path, real_baseline) + + assert result2 is not None + using_cache_logged = any( + "Using cached metrics for current-impact" in record.message for record in caplog.records + ) + assert using_cache_logged, "Second call should use cached metrics" + + def test_analyze_uncommitted_changes__cache_invalidated_on_file_change( + self, test_repo_path, real_baseline, test_db, caplog + ): + """Test that cache is invalidated when working tree changes.""" + assert real_baseline is not None, "Baseline computation failed" + + service = CurrentImpactService(db=test_db) + + # Modify an existing tracked Python file + target_file = test_repo_path / "src" / "slopometry" / "core" / "models.py" + if not target_file.exists(): + pytest.skip("models.py not found in test repo") + + original_content = target_file.read_text() + + # First modification + target_file.write_text(original_content + "\n\ndef cache_invalidation_test_v1():\n return 1\n") + + # First call - compute and cache + with caplog.at_level(logging.DEBUG, logger="slopometry.summoner.services.current_impact_service"): + result1 = service.analyze_uncommitted_changes(test_repo_path, real_baseline) + + assert result1 is not None + caplog.clear() + + # Second modification - should invalidate cache due to different content hash + target_file.write_text(original_content + "\n\ndef cache_invalidation_test_v2():\n return 2\n") + + # Second call - should recompute (different working tree hash) + with caplog.at_level(logging.DEBUG, logger="slopometry.summoner.services.current_impact_service"): + result2 = service.analyze_uncommitted_changes(test_repo_path, real_baseline) + + assert result2 is not None + # Should NOT see "Using cached metrics" since file changed + using_cache_logged = any( + "Using cached metrics for current-impact" in record.message for record in caplog.records + ) + cached_logged = any("Cached metrics for current-impact" in record.message for record in caplog.records) + assert not using_cache_logged, "Changed file should invalidate cache" + assert cached_logged, "Should cache new metrics after recomputation" diff --git a/tests/test_feedback_cache.py b/tests/test_feedback_cache.py index c63a9f5..4a6caa0 100644 --- a/tests/test_feedback_cache.py +++ b/tests/test_feedback_cache.py @@ -471,3 +471,66 @@ def test_feedback_cache__egg_info_directory_ignored(self): key_after = _compute_feedback_cache_key(str(tmppath), set(), feedback_hash) assert key_before == key_after, "*.egg-info directory should be ignored" + + +def test_feedback_cache__slopometry_dir_visibility_does_not_affect_key(): + """Verify cache key is stable whether .slopometry/ is in gitignore or not. + + This is the critical test: the cache key should remain stable when: + 1. .slopometry/ is NOT in gitignore (shows as untracked) + 2. .slopometry/ IS in gitignore (hidden from git) + 3. .gitignore is modified but not committed + + The key only depends on: commit SHA, Python file content, edited files, and feedback hash. + """ + with tempfile.TemporaryDirectory() as tmpdir: + tmppath = Path(tmpdir) + _init_git_repo(tmppath) + + # Create Python file and gitignore WITHOUT .slopometry entry + (tmppath / "test.py").write_text("def foo(): pass") + (tmppath / ".gitignore").write_text("__pycache__/\n") + _commit_all(tmppath) + + # Modify Python file (uncommitted) + (tmppath / "test.py").write_text("def foo(): return 1") + + feedback_hash = "test_feedback_hash" + + # Scenario 1: .slopometry NOT in gitignore + key1 = _compute_feedback_cache_key(str(tmppath), {"test.py"}, feedback_hash) + + # Save cache (creates .slopometry/ directory) + _save_feedback_cache(str(tmppath), key1) + + # Scenario 2: Add .slopometry to gitignore (uncommitted) + (tmppath / ".gitignore").write_text("__pycache__/\n.slopometry/\n") + key2 = _compute_feedback_cache_key(str(tmppath), {"test.py"}, feedback_hash) + + # Scenario 3: Remove .slopometry from gitignore + (tmppath / ".gitignore").write_text("__pycache__/\n") + key3 = _compute_feedback_cache_key(str(tmppath), {"test.py"}, feedback_hash) + + assert key1 == key2, "Adding .slopometry to gitignore should not change cache key" + assert key2 == key3, "Removing .slopometry from gitignore should not change cache key" + assert key1 == key3, "Cache key should be identical across all scenarios" + + +def test_feedback_cache__gitignore_modification_does_not_invalidate(): + """Verify that modifying .gitignore (non-Python file) doesn't invalidate cache.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmppath = Path(tmpdir) + _init_git_repo(tmppath) + (tmppath / "test.py").write_text("def foo(): pass") + (tmppath / ".gitignore").write_text("*.pyc\n") + _commit_all(tmppath) + + feedback_hash = "feedbackhash1234" + key_before = _compute_feedback_cache_key(str(tmppath), set(), feedback_hash) + + # Modify .gitignore (uncommitted) + (tmppath / ".gitignore").write_text("*.pyc\n.slopometry/\n__pycache__/\n") + + key_after = _compute_feedback_cache_key(str(tmppath), set(), feedback_hash) + + assert key_before == key_after, ".gitignore modifications should not invalidate cache" diff --git a/tests/test_hook_handler.py b/tests/test_hook_handler.py index a7fc66a..2235b4f 100644 --- a/tests/test_hook_handler.py +++ b/tests/test_hook_handler.py @@ -811,3 +811,144 @@ def test_interpret_z_score__negative_is_worse(self): assert _interpret_z_score(-2.0) == "much worse than avg" assert _interpret_z_score(-0.8) == "worse than avg" assert _interpret_z_score(0.0) == "about avg" + + +class TestHookHandlerSmokeTests: + """Smoke tests to ensure hook handlers don't crash with valid input.""" + + def _init_git_repo(self, path: Path) -> None: + """Initialize a git repo for testing.""" + subprocess.run(["git", "init"], cwd=path, capture_output=True, check=True) + subprocess.run( + ["git", "config", "--local", "user.email", "test@example.com"], + cwd=path, + capture_output=True, + check=True, + ) + subprocess.run( + ["git", "config", "--local", "user.name", "Test"], + cwd=path, + capture_output=True, + check=True, + ) + subprocess.run( + ["git", "config", "--local", "commit.gpgsign", "false"], + cwd=path, + capture_output=True, + check=True, + ) + + def test_handle_hook__pre_tool_use_does_not_crash(self): + """Smoke test: PreToolUse hook should not crash.""" + import json + from io import StringIO + from unittest.mock import patch + + from slopometry.core.hook_handler import handle_hook + from slopometry.core.models import HookEventType + + input_data = { + "session_id": "smoke-test-session", + "transcript_path": "/tmp/test.jsonl", + "tool_name": "Bash", + "tool_input": {"command": "ls"}, + } + + with patch("sys.stdin", StringIO(json.dumps(input_data))): + result = handle_hook(event_type_override=HookEventType.PRE_TOOL_USE) + + assert result == 0 + + def test_handle_hook__post_tool_use_does_not_crash(self): + """Smoke test: PostToolUse hook should not crash.""" + import json + from io import StringIO + from unittest.mock import patch + + from slopometry.core.hook_handler import handle_hook + from slopometry.core.models import HookEventType + + input_data = { + "session_id": "smoke-test-session", + "transcript_path": "/tmp/test.jsonl", + "tool_name": "Bash", + "tool_input": {"command": "ls"}, + "tool_response": "file1.txt\nfile2.txt", + } + + with patch("sys.stdin", StringIO(json.dumps(input_data))): + result = handle_hook(event_type_override=HookEventType.POST_TOOL_USE) + + assert result == 0 + + def test_handle_hook__notification_does_not_crash(self): + """Smoke test: Notification hook should not crash.""" + import json + from io import StringIO + from unittest.mock import patch + + from slopometry.core.hook_handler import handle_hook + from slopometry.core.models import HookEventType + + input_data = { + "session_id": "smoke-test-session", + "transcript_path": "/tmp/test.jsonl", + "message": "Test notification", + } + + with patch("sys.stdin", StringIO(json.dumps(input_data))): + result = handle_hook(event_type_override=HookEventType.NOTIFICATION) + + assert result == 0 + + def test_handle_hook__stop_does_not_crash(self): + """Smoke test: Stop hook should not crash.""" + import json + from io import StringIO + from unittest.mock import patch + + from slopometry.core.hook_handler import handle_hook + from slopometry.core.models import HookEventType + + with tempfile.TemporaryDirectory() as tmpdir: + tmppath = Path(tmpdir) + self._init_git_repo(tmppath) + (tmppath / "test.py").write_text("x = 1") + subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) + subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) + + input_data = { + "session_id": "smoke-test-stop", + "transcript_path": "/tmp/test.jsonl", + "stop_hook_active": False, + } + + with ( + patch("sys.stdin", StringIO(json.dumps(input_data))), + patch("os.getcwd", return_value=str(tmppath)), + ): + result = handle_hook(event_type_override=HookEventType.STOP) + + # Stop hook returns 0 (no feedback) or 2 (with feedback) - both are valid + assert result in (0, 2) + + def test_handle_hook__subagent_stop_does_not_crash(self): + """Smoke test: SubagentStop hook should not crash and return 0.""" + import json + from io import StringIO + from unittest.mock import patch + + from slopometry.core.hook_handler import handle_hook + from slopometry.core.models import HookEventType + + input_data = { + "session_id": "smoke-test-subagent", + "transcript_path": "/tmp/test.jsonl", + "stop_hook_active": True, + } + + with patch("sys.stdin", StringIO(json.dumps(input_data))): + result = handle_hook(event_type_override=HookEventType.STOP) + + # Subagent stops should return 0 (no feedback for subagents) + assert result == 0 diff --git a/tests/test_models.py b/tests/test_models.py index 2960bcd..ec3ce46 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -3,7 +3,13 @@ import pytest from pydantic import ValidationError -from slopometry.core.models import ExtendedComplexityMetrics, UserStoryDisplayData, UserStoryStatistics +from slopometry.core.models import ( + ContextCoverage, + ExtendedComplexityMetrics, + FileCoverageStatus, + UserStoryDisplayData, + UserStoryStatistics, +) class TestExtendedComplexityMetrics: @@ -95,3 +101,60 @@ def test_model_creation__creates_display_data_when_values_provided(self) -> None assert display_data.rating == "3/5" assert display_data.model == "gemini-2.5-pro" assert display_data.repository == "slopometry" + + +def test_context_coverage_has_gaps__returns_false_when_perfect(): + """Test that has_gaps returns False when all coverage metrics are perfect.""" + coverage = ContextCoverage( + files_edited=["src/foo.py"], + files_read=["src/foo.py"], + file_coverage=[ + FileCoverageStatus( + file_path="src/foo.py", + was_read_before_edit=True, + imports_coverage=100.0, + dependents_coverage=100.0, + ) + ], + blind_spots=[], + ) + + assert coverage.has_gaps is False + + +def test_context_coverage_has_gaps__returns_true_when_read_ratio_low(): + """Test that has_gaps returns True when files weren't read before edit.""" + coverage = ContextCoverage( + files_edited=["src/foo.py"], + files_read=[], + file_coverage=[ + FileCoverageStatus( + file_path="src/foo.py", + was_read_before_edit=False, + imports_coverage=100.0, + dependents_coverage=100.0, + ) + ], + blind_spots=[], + ) + + assert coverage.has_gaps is True + + +def test_context_coverage_has_gaps__returns_true_when_blind_spots(): + """Test that has_gaps returns True when there are blind spots.""" + coverage = ContextCoverage( + files_edited=["src/foo.py"], + files_read=["src/foo.py"], + file_coverage=[ + FileCoverageStatus( + file_path="src/foo.py", + was_read_before_edit=True, + imports_coverage=100.0, + dependents_coverage=100.0, + ) + ], + blind_spots=["src/bar.py"], + ) + + assert coverage.has_gaps is True diff --git a/tests/test_project_guard.py b/tests/test_project_guard.py index ef42d34..66d6731 100644 --- a/tests/test_project_guard.py +++ b/tests/test_project_guard.py @@ -1,5 +1,6 @@ """Tests for project_guard.py.""" +import subprocess from pathlib import Path import pytest @@ -11,6 +12,38 @@ ) +def _init_git_repo(path: Path) -> None: + """Initialize a real git repo with an initial commit.""" + subprocess.run(["git", "init", str(path)], capture_output=True, check=True) + subprocess.run( + ["git", "-C", str(path), "config", "user.email", "test@test.com"], + capture_output=True, + check=True, + ) + subprocess.run( + ["git", "-C", str(path), "config", "user.name", "Test"], + capture_output=True, + check=True, + ) + subprocess.run( + ["git", "-C", str(path), "config", "commit.gpgsign", "false"], + capture_output=True, + check=True, + ) + # Need at least one commit for gitignore to work + (path / ".gitkeep").write_text("") + subprocess.run( + ["git", "-C", str(path), "add", ".gitkeep"], + capture_output=True, + check=True, + ) + subprocess.run( + ["git", "-C", str(path), "commit", "-m", "init"], + capture_output=True, + check=True, + ) + + class TestDetectMultiProjectDirectory: """Tests for detect_multi_project_directory.""" @@ -78,6 +111,80 @@ def test_detect_multi_project_directory__no_git_repos(self, tmp_path: Path) -> N projects = detect_multi_project_directory(tmp_path) assert projects == [] + def test_detect_multi_project_directory__skips_gitignored_subdirs(self, tmp_path: Path) -> None: + """Gitignored subdirectories with .git are excluded from detection.""" + # Create a git repo at tmp_path with gitignore rules + _init_git_repo(tmp_path) + (tmp_path / ".gitignore").write_text("playground/\nreferences/\n") + subprocess.run( + ["git", "-C", str(tmp_path), "add", ".gitignore"], + capture_output=True, + check=True, + ) + subprocess.run( + ["git", "-C", str(tmp_path), "commit", "-m", "add gitignore"], + capture_output=True, + check=True, + ) + + # Create a workspace subdir (no .git) — this is the scan root + workspace = tmp_path / "workspace" + workspace.mkdir() + + # Gitignored subdirs with their own .git repos + for name in ["playground/sam3", "references/ag-ui", "references/pydantic-ai"]: + subdir = workspace / name + subdir.mkdir(parents=True) + (subdir / ".git").mkdir() + + # All subdirs are gitignored, so nothing should be detected + projects = detect_multi_project_directory(workspace) + assert projects == [] + + def test_detect_multi_project_directory__counts_non_ignored_subdirs(self, tmp_path: Path) -> None: + """Non-ignored subdirs with .git are counted even when ignored ones exist.""" + _init_git_repo(tmp_path) + (tmp_path / ".gitignore").write_text("vendor/\n") + subprocess.run( + ["git", "-C", str(tmp_path), "add", ".gitignore"], + capture_output=True, + check=True, + ) + subprocess.run( + ["git", "-C", str(tmp_path), "commit", "-m", "add gitignore"], + capture_output=True, + check=True, + ) + + workspace = tmp_path / "workspace" + workspace.mkdir() + + # Ignored subdir with .git + vendor = workspace / "vendor" / "lib" + vendor.mkdir(parents=True) + (vendor / ".git").mkdir() + + # Non-ignored subdir with .git — should be detected + real_project = workspace / "services" / "api" + real_project.mkdir(parents=True) + (real_project / ".git").mkdir() + + projects = detect_multi_project_directory(workspace) + assert projects == ["services/api"] + + def test_detect_multi_project_directory__no_git_root_scans_all(self, tmp_path: Path) -> None: + """When not inside a git repo, all subdirs are scanned (no filtering).""" + # No git init on tmp_path — not a git repo + proj1 = tmp_path / "proj1" + proj2 = tmp_path / "proj2" + proj1.mkdir() + proj2.mkdir() + (proj1 / ".git").mkdir() + (proj2 / ".git").mkdir() + + projects = detect_multi_project_directory(tmp_path) + assert sorted(projects) == ["proj1", "proj2"] + class TestGuardSingleProject: """Tests for guard_single_project.""" diff --git a/tests/test_tokenizer.py b/tests/test_tokenizer.py index 7f3facd..644567c 100644 --- a/tests/test_tokenizer.py +++ b/tests/test_tokenizer.py @@ -3,6 +3,7 @@ from pathlib import Path from unittest.mock import patch +from slopometry.core.models import TokenCountError from slopometry.core.tokenizer import count_file_tokens, count_tokens, get_encoder @@ -56,20 +57,22 @@ def test_count_file_tokens__reads_and_counts(self, tmp_path: Path) -> None: test_file.write_text("def foo(): pass") result = count_file_tokens(test_file) - assert result > 0 + assert isinstance(result, int) and result > 0 - def test_count_file_tokens__missing_file_returns_zero(self, tmp_path: Path) -> None: - """Should return 0 for missing file.""" + def test_count_file_tokens__missing_file_returns_error(self, tmp_path: Path) -> None: + """Should return TokenCountError for missing file.""" missing_file = tmp_path / "missing.py" result = count_file_tokens(missing_file) - assert result == 0 + assert isinstance(result, TokenCountError) + assert str(missing_file) in result.path - def test_count_file_tokens__unreadable_file_returns_zero(self, tmp_path: Path) -> None: - """Should return 0 when file cannot be read.""" + def test_count_file_tokens__unreadable_file_returns_error(self, tmp_path: Path) -> None: + """Should return TokenCountError when file cannot be read.""" test_file = tmp_path / "test.py" test_file.write_text("content") with patch.object(Path, "read_text", side_effect=PermissionError("denied")): result = count_file_tokens(test_file) - assert result == 0 + assert isinstance(result, TokenCountError) + assert "denied" in result.message From f9eeca43cabde218365c2f10f2eb4ff6f5efb1ce Mon Sep 17 00:00:00 2001 From: TensorTemplar Date: Sun, 8 Feb 2026 10:41:07 +0200 Subject: [PATCH 2/5] tighten swallowed exception logic around inert statements in general --- .coverage | Bin 53248 -> 53248 bytes coverage.xml | 6365 +++++++++-------- src/slopometry/core/hook_handler.py | 14 +- src/slopometry/core/models.py | 26 +- .../core/python_feature_analyzer.py | 48 +- .../core/transcript_token_analyzer.py | 70 +- src/slopometry/solo/cli/commands.py | 24 + tests/test_current_impact_service.py | 11 +- tests/test_hook_handler.py | 18 +- tests/test_python_feature_analyzer.py | 54 +- tests/test_save_transcript.py | 164 +- 11 files changed, 3566 insertions(+), 3228 deletions(-) diff --git a/.coverage b/.coverage index 86ecbb803fabccb53af612d5ffbf223226681eae..d08257265c828f953558639e229bbdbdb2c91967 100644 GIT binary patch delta 2194 zcmZ8gZBSI#89w*poV|DN*DmZrkVQ5KXn_EgRLQ6T1H0?8EXpDUtb&9<>O?-o#w40{ zcVqjbO*BJJ{gGyhOn$VElTjnlI3`A_6WeJ`wl=AP>4@!*I+LuDCQ~+D+`WD8=I0P;U9V<&b4HnIbQda(n~-1Q+su=7)F}_dD)ME{pw;eevxP7t8v}=-sB( z^kc7+Y%b+dbOrraQ#t*sCyz9gK$>Hwr=Ad$KXdvh9U*&!%>^ zZ3W%ZR8Q~wGTGJw+8k)5UwORr6mRB;|snDtgG{ApTrPvlmj4N`8@SSq4y%2?hNMJ?585V-7%h3y_lp9$MmPY;aJA z|1mlf#Iz=0Bb&0I%tE<0z*FaYnfFTvG7$P18NHmkg z7F0={45?(M$AbzZ0oPj4X=kjIX$q2h5z2}|MF$!)Sg!y_uBOF}4$@+Q%Dmv_dKcSF zs5{uqK7r{6o7axtZd%2(OYh4!#iy;)$_h~zmuVN|CaF}Yu>3Gz8$6k?=TsFChC%GPekEM!K;3CUm{u-Z04sw@p`0bHAmfyrj zGifwbVb~3qZQ;Rf(NHD5?s4JL01sV?hN>O^XS9+|9()!JZJhU5%XWG#P30XzMw)$|qfFd*M&+_0jZ$)_K*cnm`^ z%YmT<=QZ+RBSYqwo3UXf>}ufQyMBw9Zo;|EJeX+_T`&}07UaQC-=a>O^8lY|tBxgG z;cPz-u3B7w$Rkp47L!H0w{6AF2hMeYryR7Rtp;Z3sYY{mfl(GB(_e{{nNUwD^VXKD+ zqZtdqXp9Ilstlho0?4nXU@^u*^LK^_7{&CyCO1s%=E>uo=(jrVi0ZoBzM1id@4S!hjqPc&0JiM{p#7-SbELT z)a;G(sW5{krv_u`>)YN)#nRI`_s8|PuJ=^T(F@`D>A-AnEFHi2-GaArd*sVACw~3W zqUurozL!;?D~ujz}_a0pd?d7{5>+Sst~i!6J0 zWO}ly?4TYy^~T+Mf4hDtl`E6kWe>?$&}?xvhRY7K$*IRO!)r3p?qY-{`k*5S?W|(p zXM}k~zRDYL1V16Ww4)?rc%E-_gv!B#EEqY9me2i`x5>6*$nitQaXR+b@I8vF=2ZP-Kasr7AqvG zHiopj+O(EEsa?}9Yk$D%gbN&3RA3+WURn|DJQta_>3+yTn{4 zGuO!)Tw~KSSb=S3x3d1KE|pm|Px-U*BW0!%Q#2`z3RmWH<~c?u|EIi6&e6?uDIG~& zr{1Fy$)Cw1WDcny+KCdvQ+7`FoGb+I#9ugh&=<$Er}NQ?@tV^0g$B!-Vk_2v6h z)9^Gcgo)v6Q{1Rr4H!mE`uZhm@l=ktrq1NE;u*I!#haqml$Dggp|``46V+fWUM7;i zldhxUSrA!CY*;MkkEbiBT-6idzJhQGNx*`l7niMGD^*Yr36rq^J}Pex@X`hI z=WACQNWUZkI{7HP<~P*zgFXWP^Z;nqN^-ovDauV3<+EwL3<+ZN3NZF zpIgRxs_kk8`vp6f^s=|nqnVgVTzeWOqBc& z@;vz>ctg+A_4HBtReB>GPfw>k8?~BN%H$G3U`&`#Wi#q5(u}w7HQ3wsxlaLIJfr5>-U&aE%z$QNM zMAJUW%EqG|Dzt4bQbKaMU8Jo288jfgPQGrK=fp z35I1@L~k(`J45s$5R#_`kr-2>^S0gZsHQus?>CLLO||xV^oU_MBeSLB6MNs-=)pz) zrmu(Z{_?^?9FGo!D9^c7(qEpsgN9m;U0b-kz#;5FI}STtS{HbJR`RJJ?69C%1G={= zU&yTxI5$0bOxNHWsXR0XS^5^-xrI7s%Ax{5ZKP~td8I?laLM2~Zg;b+yy`e=SuTU@ zaDtl{(!i=yxL1ozOA7FsV1GF6-bBvk&X|!LVd8GXxDsY0vZ+#t$wQ z6xLg;MOsbJ?dt(pgfD1vf-2vzI=M=>2KXT6W`xjZ+z;T zIq=`sM{G!lx<$bt6lX3%s2Z~(WZ?bx&o^N;i@jm{MIxY*jAf7ta^h$%97arT4G?E> zXdYGu`U^c?D5)M#=1H>&9WF8f#Y&{V?T+pL^2XiYohz%?id%Zh3(BEp|LEfhILD*q;A|sie(x`&67_X-yoOJC zVBg!uxq86n6!*%WyHHvi7uk{e&&KC^XAX=!)AvvpI? zp-NY=<~tPp#r-~9YuAC7Nc0u{`IWPHUR4%Zq*d%(6~MVbG`)YzMfdL8 zWo=8xJOZ_#h!3rFoHQ1F?j&8R`B;N#1UqAAPc!qb-gpBYT@a`dO^C{M4nY_fZbd~0 z43Srl3@fiRp6|Qu5Qt8vtR{&Q+p3n?PBl934S(Ne5}XeE*l;c2ky|HC^n>&38+$eg zf>UTK9_(}s}_XQLn-I5&_vdg@=1J#R0t zHwyoFrJ?kAldA3Pu4jhNjrCW-wAZSGG^m`0^QFyaw->~WmNj~HZz*Z=ws#*^ z&sW2BcjLC6xvsmqTnA1dP5aQ#4KlObSm9-?_`+(eSXKVjkOEm$S7&2DwZo3u1v#;w z9_(FFQbDR&aQ64JO{;Qv4+z^-j0$9(DP*&MH?3BRd%-Q+#=G&}LPx&80_26Bc%It2 zMf_y-BicE*m0%h^KzA795LV5IU46mVwgBzECBWc`-ciNgxOur%XN9ZfeS!{{dla64 z*l=VHZYIiKwge)}TR#SyHSoTMSlCNM2wFMT?}GeMQvr^Cq0zwYww7yGoE3KG=(t33 zaT-6kNN2h!XoyU?n9yHoTS1+=AD(M?uwj*R?nuYf_S%|kup=x6!;*8jr5-)Fu@1{J zW}$|T`-!;}a^{!igrf2MP-MIio>{BG%!`G#EeIKR?Xe$eZb9f3 zITj0L!(-t~B@l)%V|RDo(*AVR0H;Rp%(Du$;zImvxq^1e=+%9s-TSi|wz%T7U^rZ6 zVdLKJ>n(XE++4@HBePmhTal$?;#KR4Lhd)Opay3WKlQ*YmL3)UD)YYQYW$O6Sk7-g z5MrW{Rai#bge78z_6=PxV?GqLVUDh)$GKiV<;;9+$a&Mi$wywd4_a@`olC;z4%e3a zkxFdyn4PFAIC86~?yXbbO*0Q)xb{Q9?fMFPOT^LPK+E+px4I7dVSM23ng7t1W=B#I zAy!jO+o);EW+l8SL|s>vsm(4MH~5Lk9}P2d>MS$hOGReLX)l7L_t93t7pHnqoKpN3l9A)7@W!xU_qWUNJnUTOnb3xo)Zh-6Ox;P(hHMf%cQY~;g^>yw%_c8Yp zm&Q@*2i!ugi95l)%EfRS)wenJ(M2U_^waE7^L4eP$tOarJ2qvC1gdZe0>dQm3Y9<~ zB0)s31l~asxCKg}(Mv!DNWl3^5auUAkgo)4sk2ysw_g$;QY(tc(6XI3UR! diff --git a/coverage.xml b/coverage.xml index a398fb9..33a5fc6 100644 --- a/coverage.xml +++ b/coverage.xml @@ -1,5 +1,5 @@ - + @@ -16,9 +16,9 @@ - + - + @@ -37,20 +37,20 @@ - + - - - - - - - - - + + + + + + + + + @@ -62,63 +62,63 @@ - - - + + + - + - + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - + + + + + + + - - - - - - - + + + + + + + - + @@ -127,21 +127,21 @@ - - - - - - - - - - - - + + + + + + + + + + + + - + @@ -150,82 +150,82 @@ - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - - + + @@ -241,7 +241,7 @@ - + @@ -255,33 +255,33 @@ - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - - - - + + + + + + - + @@ -317,43 +317,43 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -419,20 +419,20 @@ - - - - - - - - - + + + + + + + + + - + @@ -442,7 +442,7 @@ - + @@ -506,322 +506,322 @@ - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + - - - - - + + + + + - - + + - - - + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + + + - - - - - - - - - - + + + + + + + + + + - - - - - + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - + + + + + + + + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + - - - - - - - - + + + + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - - - + + + + + + - + @@ -838,78 +838,78 @@ - - - - - - - - + + + + + + + + - - - - - - + + + + + + - + - - - - - + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + + + @@ -931,99 +931,99 @@ - - - - - - + + + + + + - - - - + + + + - - - - + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + - - + + - + - + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + @@ -1032,11 +1032,11 @@ - - - - - + + + + + @@ -1050,13 +1050,13 @@ - + - + - - - + + + @@ -1064,14 +1064,14 @@ - - - - - - - - + + + + + + + + @@ -1104,36 +1104,36 @@ - - - + + + - - - - - - + + + + + + - - - - - - - - - + + + + + + + + + - - - - - - - - - + + + + + + + + + @@ -1266,28 +1266,28 @@ - - - + + + - - - - + + + + - - + + - - + + - - - - - - + + + + + + @@ -1351,41 +1351,41 @@ - - - + + + - - - + + + - - - - - + + + + + - - + + - - - - - + + + + + - - + + - + @@ -1404,60 +1404,60 @@ - - - + + + - - - - - + + + + + - - - - - - - - + + + + + + + + - + - - - - - + + + + + - - - - - - - - + + + + + + + + - + - - - - + + + + - + - + @@ -1478,25 +1478,25 @@ - - - - - + + + + + - - - - + + + + - - - - - - - - + + + + + + + + @@ -1507,9 +1507,9 @@ - - - + + + @@ -1518,102 +1518,102 @@ - - - + + + - + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - + + + - + - + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - + + + - + - + - - - - - - + + + + + + - + - - - - - - - - - - - + + + + + + + + + + + - - - - - - + + + + + + - + - + - + @@ -1623,131 +1623,131 @@ - - - - - + + + + + - - - - - - - - + + + + + + + + - - - + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + - - - - - + + + + + - - - - - - - - - - + + + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - + + - - - - + + + + @@ -1758,206 +1758,209 @@ - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + - - - - + + + + - - - - - - + + + + + + - - - - - - - - - + + + + + + + + + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - + + + + + + - - - - + + + + + @@ -1969,41 +1972,41 @@ - + + - - - + + + - - - - - - + + + + - - - - + + + + + @@ -2015,50 +2018,51 @@ - + - + - + - + + - - - - - - - - - - - + + + + + + + + + + + - - - + - + + + @@ -2066,124 +2070,118 @@ - + - - - - + - - - - - - - - - - - - + + + + + + + + + + + + - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -2192,71 +2190,71 @@ - + - - - - - - - + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - + @@ -2278,175 +2276,175 @@ - + - + - - - - + + + + - + - + - + - - - + + + - + - + - - - - + + + + - - - - - - - + + + + + + + - + - + - - + + - + - + - - - - - - - + + + + + + + - + - + - - - - - - - + + + + + + + - + - + - + - - - + + + - + - + - - + + - - - - - - + + + + + + - - + + - - - - + + + + - + - + - - + + - - + + - - - - - - - - - + + + + + + + + + - - - - - - - - - - - - + + + + + + + + + + + + - + @@ -2458,27 +2456,27 @@ - - + + - - + - - - + + - - - - - - - - - - + + + + + + + + + + + + @@ -2488,17 +2486,13 @@ - - + + - - - - @@ -2508,13 +2502,13 @@ + - @@ -2529,24 +2523,24 @@ + + + - + + - - + + - - - - @@ -2555,129 +2549,135 @@ + + + + - - - + + + - - + + - - - - + + + + - - - + + + + - - - + + - - + - - - + + + - - + - - + + - - - - - + + + + + + + - - + + - - - + + + - - - - + + + - + - + - + - + + - - - - + + - + + + + + @@ -2687,24 +2687,18 @@ - - + + - - - - - - + + + + - - - - @@ -2714,182 +2708,186 @@ - - + + + + + + + + + - - + + - + + - - - + + + + - - - - - + + + - - + + + - - - + + - - - - + + - - - + + - - - - + + + - - - + + + - + + + + + - - - + + + - - - - + + + - - + - - + + + + + - - - + - - - + + + - - - - + + + + + - - + + + + + + + + - - - - - - - - - + + + + + + + + + + - - - - - - + - - - - - - - + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - - + - + + + + + - - - + - - + + - - @@ -2899,54 +2897,54 @@ - - + + - - + + - - - + + + - - - - + + + + + - - - - + + + + - + + - - - - + + @@ -2958,234 +2956,248 @@ - - + + - - + + - - + + + + - - + + - - + + + + - - - - - + + + + + + + + - + - - - + - - - - - - - - - - - + + + + + + + + + + - - + + + - - - - - - + + + + + - - - + + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + - - + + + - - - + + + + + + - - + + - - - - - + + + + + - - - + + + + + - - - - - - - - - + + + + - - - - + + + + + + + + - - - - + + - - + - - - + + + - - - - - + + - - - - + - - + - - - + + + + + - - - + + + + + - - - - + + + + - - - - - - + + + + - - + - - + + + + + + + + - - - - + + + + + + + - - - + + + + + + + + + + - + @@ -3199,82 +3211,82 @@ - - - - - - - + + + + + + + - - + + - - - - - + + + + + - - - - - - - + + + + + + + - - - + + + - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - + + + + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - - - + + + + + @@ -3292,166 +3304,166 @@ - + - - - - - - - - + + + + + + + + - - - - - - - - + + + + + + + + - + - - - - - + + + + + - - - - - - + + + + + + - - - + + + - - - - - - - - - + + + + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - - - + + + - - - - - - - + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + - + @@ -3542,19 +3554,19 @@ - - - - - - + + + + + + - - - - - - + + + + + + @@ -3581,7 +3593,7 @@ - + @@ -3592,20 +3604,20 @@ - - - - - - - - - + + + + + + + + + - + @@ -3887,50 +3899,35 @@ - - - + + + - - - - + - + - + + - + + - + - - - - - - - - - - - - - - - + @@ -3941,28 +3938,28 @@ - - - - + + + + - - - - - - + + + + + + - + - + - + @@ -4024,7 +4021,7 @@ - + @@ -4036,24 +4033,24 @@ - - + + - + - - + + - + - + - + @@ -4079,12 +4076,12 @@ - - - + + + - + @@ -4098,227 +4095,265 @@ - - - - - - + + + + + - + + + + + - + - + + + + + + + - - - - - + + - - + + + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + - + + + + + + + - - + - - - - + - - + + + + - - + + - - - + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - - - + + + + + - - - - - - - - - - - - + + + + + + + + + + + + - - - - - + + + + + - - + + - - - - + + + + - + - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + - + @@ -4327,20 +4362,20 @@ - + - - - - - - - - - - - + + + + + + + + + + + @@ -4360,9 +4395,9 @@ - - - + + + @@ -4375,7 +4410,7 @@ - + @@ -4397,7 +4432,7 @@ - + @@ -4435,21 +4470,21 @@ - + - + - + @@ -4463,7 +4498,7 @@ - + @@ -4479,7 +4514,7 @@ - + @@ -4488,7 +4523,7 @@ - + @@ -4577,7 +4612,7 @@ - + @@ -4655,13 +4690,13 @@ - + - + @@ -4679,7 +4714,7 @@ - + @@ -4700,13 +4735,13 @@ - + - + @@ -4716,7 +4751,7 @@ - + @@ -4724,7 +4759,7 @@ - + @@ -4754,13 +4789,13 @@ - + - + @@ -4771,7 +4806,7 @@ - + @@ -4783,7 +4818,7 @@ - + @@ -4794,7 +4829,7 @@ - + @@ -4805,7 +4840,7 @@ - + @@ -4815,7 +4850,7 @@ - + @@ -4825,7 +4860,7 @@ - + @@ -4863,7 +4898,7 @@ - + @@ -4873,9 +4908,9 @@ - - - + + + @@ -4892,7 +4927,7 @@ - + @@ -4906,7 +4941,7 @@ - + @@ -4965,7 +5000,7 @@ - + @@ -4997,7 +5032,7 @@ - + @@ -5021,7 +5056,7 @@ - + @@ -5030,38 +5065,38 @@ - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - + + + + + + + @@ -5078,7 +5113,7 @@ - + @@ -5109,9 +5144,9 @@ - + - + @@ -5507,185 +5542,193 @@ + + + + + + + + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + - - - - + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - + - - - - + + + + - - - - - - - - - - - - + + + + + + + + + + + + - - + + - - - - + + + + - - - + + + - + - + - + @@ -5694,7 +5737,7 @@ - + @@ -5711,35 +5754,35 @@ - - - - - - + + + + + + - - + + - + - + - - - - - - - - - - + + + + + + + + + + @@ -5747,7 +5790,7 @@ - + @@ -5755,7 +5798,7 @@ - + @@ -5764,7 +5807,7 @@ - + @@ -5772,7 +5815,7 @@ - + @@ -5789,14 +5832,14 @@ - - - - - - - - + + + + + + + + @@ -5820,37 +5863,37 @@ - - - - - - - - - + + + + + + + + + - - + + - - - - - - - - - - - - + + + + + + + + + + + + - - - - + + + + @@ -5887,13 +5930,13 @@ - - - - - - - + + + + + + + @@ -5966,8 +6009,8 @@ - - + + @@ -5977,9 +6020,9 @@ - - - + + + @@ -6000,12 +6043,12 @@ - - - - - - + + + + + + @@ -6067,11 +6110,11 @@ - - - - - + + + + + @@ -6123,10 +6166,10 @@ - - - - + + + + @@ -6148,8 +6191,8 @@ - - + + @@ -6167,9 +6210,9 @@ - - - + + + @@ -6183,11 +6226,11 @@ - - - - - + + + + + @@ -6216,9 +6259,9 @@ - - - + + + @@ -6259,9 +6302,9 @@ - - - + + + @@ -6276,9 +6319,9 @@ - - - + + + @@ -6316,10 +6359,10 @@ - - - - + + + + @@ -6338,10 +6381,10 @@ - - - - + + + + @@ -6383,10 +6426,10 @@ - - - - + + + + @@ -6430,10 +6473,10 @@ - - - - + + + + @@ -6468,7 +6511,7 @@ - + @@ -6485,97 +6528,97 @@ - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -6586,7 +6629,7 @@ - + @@ -6601,7 +6644,7 @@ - + @@ -6613,7 +6656,7 @@ - + @@ -6630,175 +6673,175 @@ - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - + - + - - - - - - - + + + + + + + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - + + + + - + - - - - - - - - - - - + + + + + + + + + + + - - + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + @@ -6807,101 +6850,101 @@ - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -6909,10 +6952,10 @@ - - - - + + + + @@ -6925,37 +6968,37 @@ - - - - + + + + - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + @@ -7065,41 +7108,41 @@ - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + - + - + - - - - - - - - + + + + + + + + @@ -7108,11 +7151,11 @@ - - - - - + + + + + @@ -7128,7 +7171,7 @@ - + @@ -7138,7 +7181,7 @@ - + @@ -7147,17 +7190,17 @@ - + - - - - - - - - + + + + + + + + @@ -7179,45 +7222,45 @@ - + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + @@ -7289,67 +7332,67 @@ - + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - + - - + + - + - + - - - - + + + + - - - - + + + + - - - - + + + + - + @@ -7367,7 +7410,7 @@ - + @@ -7388,12 +7431,111 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + @@ -7401,215 +7543,116 @@ - - - - - + + + - - - + + + + + + + + + + + + + - + - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - - - - - - + + + + + + + + - + - - - - - - - - - - - - + + + + + + + + + + + + - - - + + + - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + - + diff --git a/src/slopometry/core/hook_handler.py b/src/slopometry/core/hook_handler.py index a38ec75..4b0ae52 100644 --- a/src/slopometry/core/hook_handler.py +++ b/src/slopometry/core/hook_handler.py @@ -514,14 +514,11 @@ def extract_dev_guidelines_from_claude_md(working_directory: str) -> str: def _get_related_files_via_imports(edited_files: set[str], working_directory: str) -> set[str]: - """Build set of files related to edited files via import graph. + """Build set of files related to edited files for blocking smell scoping. - Uses the ContextCoverageAnalyzer to find: - - Files that import the edited files (dependents) - these could break from our changes - - Test files for edited files - - Note: We intentionally do NOT include files that edited files import, because - changes to the edited file don't affect its dependencies. + Only includes edited files and their test files. Does NOT include reverse + import graph dependents — those files weren't edited, so their pre-existing + smells are not actionable in the stop hook. Args: edited_files: Set of files edited in this session @@ -541,9 +538,6 @@ def _get_related_files_via_imports(edited_files: set[str], working_directory: st analyzer._build_import_graph() for edited_file in edited_files: - dependents = analyzer._reverse_import_graph.get(edited_file, set()) - related.update(dependents) - test_files = analyzer._find_test_files(edited_file) related.update(test_files) diff --git a/src/slopometry/core/models.py b/src/slopometry/core/models.py index a135803..1e0e269 100644 --- a/src/slopometry/core/models.py +++ b/src/slopometry/core/models.py @@ -9,6 +9,13 @@ from pydantic import BaseModel, ConfigDict, Field +class AgentTool(str, Enum): + """Agent tool that produced the session.""" + + CLAUDE_CODE = "claude_code" + OPENCODE = "opencode" + + class SmellCategory(str, Enum): """Category of code smell for organization and filtering.""" @@ -56,7 +63,7 @@ class SmellDefinition(BaseModel): label="Swallowed Exceptions", category=SmellCategory.GENERAL, weight=0.15, - guidance="BLOCKING: You MUST present a table with columns [Location | Purpose] for each and ask user to confirm silent failure is acceptable", + guidance="BLOCKING: You MUST present a table with columns [Location | Purpose | Justification ] for each and ask user to confirm silent failure is acceptable", count_field="swallowed_exception_count", files_field="swallowed_exception_files", ), @@ -493,6 +500,21 @@ def exploration_token_percentage(self) -> float: return (self.exploration_tokens / total * 100) if total > 0 else 0.0 +class SessionMetadata(BaseModel): + """Structured metadata for a saved session, agent-tool-agnostic.""" + + session_id: str + agent_tool: AgentTool + agent_version: str | None = None + model: str | None = None + start_time: datetime + end_time: datetime | None = None + total_events: int = 0 + working_directory: str + git_branch: str | None = None + token_usage: TokenUsage | None = None + + class PlanEvolution(BaseModel): """Tracks how the plan evolves through TodoWrite events.""" @@ -803,7 +825,7 @@ class ExtendedComplexityMetrics(ComplexityMetrics): swallowed_exception_count: int = SmellField( label="Swallowed Exceptions", files_field="swallowed_exception_files", - guidance="BLOCKING: You MUST present a table with columns [Location | Purpose] for each and ask user to confirm silent failure is acceptable", + guidance="BLOCKING: You MUST present a table with columns [Location | Purpose | Justification ] for each and ask user to confirm silent failure is acceptable", ) type_ignore_count: int = SmellField( label="Type Ignores", diff --git a/src/slopometry/core/python_feature_analyzer.py b/src/slopometry/core/python_feature_analyzer.py index 97a1bed..8fb67ef 100644 --- a/src/slopometry/core/python_feature_analyzer.py +++ b/src/slopometry/core/python_feature_analyzer.py @@ -856,51 +856,31 @@ def visit_Try(self, node: ast.Try) -> None: self.generic_visit(node) def _is_swallowed_exception(self, handler: ast.ExceptHandler) -> bool: - """Check if exception handler just swallows (pass/continue/empty body). + """Check if exception handler swallows without observable side effects. - Not considered swallowed if the handler logs the exception. + A handler is swallowed if ALL statements are inert (pass, continue, + break, assignments) and NONE are observable (logging, print, raise, + return, function calls, yield). """ if not handler.body: return True - # Check if any statement in the handler is a logging call for stmt in handler.body: - if self._is_logging_call(stmt): + if not self._is_inert_statement(stmt): return False - # Single statement that's pass/continue is swallowed - if len(handler.body) == 1: - stmt = handler.body[0] - if isinstance(stmt, ast.Pass | ast.Continue): - return True - - return False - - def _is_logging_call(self, stmt: ast.stmt) -> bool: - """Check if a statement is a logging/print call.""" - if not isinstance(stmt, ast.Expr): - return False - if not isinstance(stmt.value, ast.Call): - return False + return True - call = stmt.value - func = call.func + def _is_inert_statement(self, stmt: ast.stmt) -> bool: + """Check if a statement has no observable side effects. - # Check for print() call - if isinstance(func, ast.Name) and func.id == "print": + Inert statements: pass, continue, break, simple assignments, + augmented assignments (+=, etc.), and type annotations. + """ + if isinstance(stmt, ast.Pass | ast.Continue | ast.Break): + return True + if isinstance(stmt, ast.Assign | ast.AugAssign | ast.AnnAssign): return True - - # Check for attribute calls like logger.warning, logging.info, console.print - if isinstance(func, ast.Attribute): - # logger.*, logging.* - if isinstance(func.value, ast.Name): - if func.value.id in ("logger", "logging", "log", "console"): - return True - # self.logger.* - if isinstance(func.value, ast.Attribute): - if func.value.attr in ("logger", "log"): - return True - return False def visit_Import(self, node: ast.Import) -> None: diff --git a/src/slopometry/core/transcript_token_analyzer.py b/src/slopometry/core/transcript_token_analyzer.py index 4bf61b9..f875794 100644 --- a/src/slopometry/core/transcript_token_analyzer.py +++ b/src/slopometry/core/transcript_token_analyzer.py @@ -13,6 +13,66 @@ logger = logging.getLogger(__name__) +class TranscriptMetadata(BaseModel): + """Lightweight metadata extracted from the first few lines of a transcript.""" + + agent_version: str | None = None + model: str | None = None + git_branch: str | None = None + + +def extract_transcript_metadata(transcript_path: Path) -> TranscriptMetadata: + """Extract version, model, and git branch from a transcript file. + + Makes a single pass through the transcript, stopping early once all + fields are found. Extracts: + - version from first event that has it (Claude Code version) + - message.model from first assistant event (LLM model) + - gitBranch from first event that has it + + Args: + transcript_path: Path to the JSONL transcript file + + Returns: + TranscriptMetadata with extracted values (None for missing fields) + """ + agent_version: str | None = None + model: str | None = None + git_branch: str | None = None + skipped_lines = 0 + + try: + with open(transcript_path, encoding="utf-8") as f: + for line in f: + try: + event = json.loads(line) + except json.JSONDecodeError: + logger.debug("Skipping unparseable line in metadata extraction") + skipped_lines += 1 + continue + + if agent_version is None and isinstance(event.get("version"), str): + agent_version = event["version"] + + if git_branch is None and isinstance(event.get("gitBranch"), str): + git_branch = event["gitBranch"] + + if model is None and event.get("type") == "assistant": + msg = event.get("message") + if isinstance(msg, dict) and isinstance(msg.get("model"), str): + model = msg["model"] + + if agent_version is not None and model is not None and git_branch is not None: + break + except OSError as e: + logger.warning(f"Failed to read transcript for metadata: {e}") + + if skipped_lines: + logger.warning(f"Skipped {skipped_lines} unparseable line(s) in metadata extraction from {transcript_path}") + + return TranscriptMetadata(agent_version=agent_version, model=model, git_branch=git_branch) + + class MessageUsage(BaseModel): """Token usage from an assistant message.""" @@ -62,6 +122,7 @@ def analyze_transcript(self, transcript_path: Path) -> TokenUsage: TokenUsage with tokens categorized by exploration vs implementation """ usage = TokenUsage() + skipped_lines = 0 try: with open(transcript_path, encoding="utf-8") as f: @@ -69,7 +130,9 @@ def analyze_transcript(self, transcript_path: Path) -> TokenUsage: try: raw_event = json.loads(line) event = TranscriptEvent.model_validate(raw_event) - except (json.JSONDecodeError, Exception): + except Exception: + logger.debug("Skipping unparseable transcript event") + skipped_lines += 1 continue self._process_event(event, usage) @@ -77,6 +140,9 @@ def analyze_transcript(self, transcript_path: Path) -> TokenUsage: except OSError as e: logger.warning(f"Failed to read transcript file {transcript_path}: {e}") + if skipped_lines: + logger.warning(f"Skipped {skipped_lines} unparseable line(s) in {transcript_path}") + return usage def _process_event(self, event: TranscriptEvent, usage: TokenUsage) -> None: @@ -179,7 +245,7 @@ def _classify_tool(self, tool_name: str, tool_input: dict) -> str: if tool_type in self.implementation_tools: return "implementation" except ValueError: - pass + logger.debug(f"Unknown tool type '{tool_name}', defaulting to implementation") return "implementation" diff --git a/src/slopometry/solo/cli/commands.py b/src/slopometry/solo/cli/commands.py index 09fb0c5..1b83dd3 100644 --- a/src/slopometry/solo/cli/commands.py +++ b/src/slopometry/solo/cli/commands.py @@ -598,3 +598,27 @@ def save_transcript(session_id: str | None, output_dir: str, yes: bool) -> None: ] todos_file.write_text(json.dumps(todos_data, indent=2)) console.print(f"[green]✓[/green] Saved {len(todos_data)} todos to: final_todos.json") + + # Save structured session metadata + from slopometry.core.models import AgentTool, SessionMetadata + from slopometry.core.transcript_token_analyzer import extract_transcript_metadata + + transcript_meta = extract_transcript_metadata(transcript_path) + token_usage = stats.plan_evolution.token_usage if stats.plan_evolution else None + + metadata = SessionMetadata( + session_id=stats.session_id, + agent_tool=AgentTool.CLAUDE_CODE, + agent_version=transcript_meta.agent_version, + model=transcript_meta.model, + start_time=stats.start_time, + end_time=stats.end_time, + total_events=stats.total_events, + working_directory=stats.working_directory, + git_branch=transcript_meta.git_branch, + token_usage=token_usage, + ) + + metadata_file = session_dir / "session_metadata.json" + metadata_file.write_text(metadata.model_dump_json(indent=2)) + console.print("[green]✓[/green] Saved session metadata to: session_metadata.json") diff --git a/tests/test_current_impact_service.py b/tests/test_current_impact_service.py index 41a961e..04722ae 100644 --- a/tests/test_current_impact_service.py +++ b/tests/test_current_impact_service.py @@ -107,7 +107,9 @@ def test_analyze_uncommitted_changes__detects_changes(self, test_repo_path, real assert result.current_metrics.total_files_analyzed > 0 assert result.current_metrics.total_complexity > 0 - def test_analyze_previous_commit__returns_analysis_with_correct_source(self, test_repo_path, real_baseline, test_db): + def test_analyze_previous_commit__returns_analysis_with_correct_source( + self, test_repo_path, real_baseline, test_db + ): """Test that analyzing previous commit sets the correct source.""" assert real_baseline is not None, "Baseline computation failed" @@ -242,7 +244,9 @@ def mock_get_changed_python_files(self, parent_sha, child_sha): assert result is None assert any("Failed to get changed files" in record.message for record in caplog.records) - def test_analyze_uncommitted_changes__uses_cache_on_second_call(self, test_repo_path, real_baseline, test_db, caplog): + def test_analyze_uncommitted_changes__uses_cache_on_second_call( + self, test_repo_path, real_baseline, test_db, caplog + ): """Test that second call with same state uses cached metrics.""" assert real_baseline is not None, "Baseline computation failed" @@ -287,8 +291,7 @@ def test_analyze_uncommitted_changes__cache_invalidated_on_file_change( # Modify an existing tracked Python file target_file = test_repo_path / "src" / "slopometry" / "core" / "models.py" - if not target_file.exists(): - pytest.skip("models.py not found in test repo") + assert target_file.exists(), f"models.py not found in cloned test repo at {target_file}" original_content = target_file.read_text() diff --git a/tests/test_hook_handler.py b/tests/test_hook_handler.py index 2235b4f..1213754 100644 --- a/tests/test_hook_handler.py +++ b/tests/test_hook_handler.py @@ -584,45 +584,41 @@ def test_format_code_smell_feedback__read_tests_not_blocking(self): class TestGetRelatedFilesViaImports: """Tests for import graph-based file relationship detection.""" - def test_get_related_files_via_imports__finds_dependents_not_imports(self): - """Test that files importing edited files are found, but not files that edited files import.""" + def test_get_related_files_via_imports__only_includes_edited_and_test_files(self): + """Test that only edited files and their test files are related, not import dependents.""" with tempfile.TemporaryDirectory() as tmpdir: tmppath = Path(tmpdir) - # Initialize git repo (required for git_tracker) subprocess.run(["git", "init"], cwd=tmppath, capture_output=True) subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=tmppath, capture_output=True) subprocess.run(["git", "config", "user.name", "Test"], cwd=tmppath, capture_output=True) - # Create src directory with modules src_dir = tmppath / "src" src_dir.mkdir() - # core.py - a dependency + # core.py - a dependency of service.py (src_dir / "core.py").write_text("def core_func(): pass") # service.py - the file we'll edit (imports core.py) (src_dir / "service.py").write_text("from src.core import core_func\ndef service_func(): pass") - # handler.py - imports service.py (is a dependent) + # handler.py - imports service.py (is a dependent, but NOT edited) (src_dir / "handler.py").write_text("from src.service import service_func") # unrelated.py - doesn't import service.py (src_dir / "unrelated.py").write_text("def other(): pass") - # Track files in git subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) - # Get related files for editing service.py edited = {"src/service.py"} related = _get_related_files_via_imports(edited, str(tmppath)) # Should include the edited file assert "src/service.py" in related - # Should include handler.py (imports service.py - is a dependent) - assert "src/handler.py" in related - # Should NOT include core.py (service.py imports it, but changes don't flow upstream) + # Should NOT include handler.py (imports service.py but wasn't edited) + assert "src/handler.py" not in related + # Should NOT include core.py (service.py imports it) assert "src/core.py" not in related # Should NOT include unrelated.py assert "src/unrelated.py" not in related diff --git a/tests/test_python_feature_analyzer.py b/tests/test_python_feature_analyzer.py index 27cb200..0529dd3 100644 --- a/tests/test_python_feature_analyzer.py +++ b/tests/test_python_feature_analyzer.py @@ -255,6 +255,7 @@ def test_analyze_directory__frozen_commit_has_type_references(self, extracted_co any_count += visitor.any_type_refs str_count += visitor.str_type_refs except (SyntaxError, UnicodeDecodeError): + print(f"Skipping unparseable file: {py_file}") continue # Baseline sanity checks - slopometry codebase should have: @@ -281,6 +282,7 @@ def test_any_percentage__below_threshold(self, extracted_commit: Path) -> None: total_refs += visitor.total_type_refs any_count += visitor.any_type_refs except (SyntaxError, UnicodeDecodeError): + print(f"Skipping unparseable file: {py_file}") continue if total_refs > 0: @@ -741,13 +743,13 @@ def test_visit_try__ignores_proper_exception_handling(self) -> None: assert visitor.swallowed_exceptions == 0 - def test_visit_try__ignores_except_with_multiple_statements(self) -> None: - """Test that except block with multiple statements is not flagged.""" + def test_visit_try__ignores_except_with_function_call(self) -> None: + """Test that except block with a function call is not flagged.""" code = """ try: risky() except Exception: - log_error() + handle_error() pass """ tree = ast.parse(code) @@ -756,6 +758,52 @@ def test_visit_try__ignores_except_with_multiple_statements(self) -> None: assert visitor.swallowed_exceptions == 0 + def test_visit_try__detects_multi_statement_inert_handler(self) -> None: + """Test that except block with only assignments and pass/continue is flagged.""" + code = """ +for item in items: + try: + process(item) + except Exception: + skip_count += 1 + continue +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.swallowed_exceptions == 1 + + def test_visit_try__ignores_handler_with_raise(self) -> None: + """Test that except block that re-raises is not flagged.""" + code = """ +try: + risky() +except ValueError: + error_count += 1 + raise +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.swallowed_exceptions == 0 + + def test_visit_try__ignores_handler_with_return(self) -> None: + """Test that except block with return is not flagged.""" + code = """ +def func(): + try: + risky() + except Exception: + return None +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.swallowed_exceptions == 0 + def test_visit_try__ignores_except_with_logger_call(self) -> None: """Test that except block with logger.warning() is not flagged.""" code = """ diff --git a/tests/test_save_transcript.py b/tests/test_save_transcript.py index 187caf8..c68d873 100644 --- a/tests/test_save_transcript.py +++ b/tests/test_save_transcript.py @@ -1,12 +1,14 @@ """Tests for the save-transcript command.""" +import json from datetime import datetime from pathlib import Path from unittest.mock import Mock, patch from click.testing import CliRunner -from slopometry.core.models import PlanEvolution, SessionStatistics, TodoItem +from slopometry.core.models import AgentTool, PlanEvolution, SessionMetadata, SessionStatistics, TodoItem, TokenUsage +from slopometry.core.transcript_token_analyzer import TranscriptMetadata, extract_transcript_metadata from slopometry.solo.cli.commands import ( _find_plan_names_from_transcript, save_transcript, @@ -93,6 +95,11 @@ def test_save_transcript__creates_session_directory_structure(self, tmp_path) -> assert session_dir.exists() assert (session_dir / "transcript.jsonl").exists() assert (session_dir / "transcript.jsonl").read_text() == '{"test": "data"}' + assert (session_dir / "session_metadata.json").exists() + + metadata = json.loads((session_dir / "session_metadata.json").read_text()) + assert metadata["session_id"] == session_id + assert metadata["agent_tool"] == "claude_code" def test_save_transcript__copies_plans_from_transcript_references(self, tmp_path) -> None: """Test copying plans referenced in transcript.""" @@ -357,3 +364,158 @@ def test_save_transcript__cancels_when_user_declines_confirmation(self, tmp_path assert result.exit_code == 0 assert "Cancelled" in result.output assert "Saved transcript to:" not in result.output + + +class TestExtractTranscriptMetadata: + """Tests for the extract_transcript_metadata function.""" + + @staticmethod + def _fixture_transcript_path() -> Path: + path = Path(__file__).parent / "fixtures" / "transcript.jsonl" + assert path.exists(), f"transcript.jsonl fixture missing at {path}" + return path + + def test_extract_transcript_metadata__extracts_version_and_model(self) -> None: + """Real transcript fixture contains version, model, and branch.""" + meta = extract_transcript_metadata(self._fixture_transcript_path()) + + assert meta.agent_version == "2.0.65" + assert meta.model == "claude-opus-4-5-20251101" + assert meta.git_branch == "opinionated-metrics" + + def test_extract_transcript_metadata__missing_fields_returns_none(self, tmp_path: Path) -> None: + """Transcript with no version/model/branch fields returns None values.""" + transcript = tmp_path / "bare.jsonl" + transcript.write_text( + '{"type":"summary","summary":"test"}\n{"type":"user","message":{"role":"user","content":"hello"}}\n' + ) + + meta = extract_transcript_metadata(transcript) + + assert meta.agent_version is None + assert meta.model is None + assert meta.git_branch is None + + def test_extract_transcript_metadata__handles_missing_file(self) -> None: + """Missing file returns all-None metadata without raising.""" + meta = extract_transcript_metadata(Path("/nonexistent/transcript.jsonl")) + + assert meta.agent_version is None + assert meta.model is None + assert meta.git_branch is None + + def test_extract_transcript_metadata__handles_malformed_json(self, tmp_path: Path) -> None: + """Malformed JSON lines are skipped without error.""" + transcript = tmp_path / "malformed.jsonl" + transcript.write_text('not json at all\n{"version":"1.0.0","gitBranch":"main","type":"user"}\n') + + meta = extract_transcript_metadata(transcript) + + assert meta.agent_version == "1.0.0" + assert meta.git_branch == "main" + assert meta.model is None + + def test_extract_transcript_metadata__returns_pydantic_model(self, tmp_path: Path) -> None: + """Return type is TranscriptMetadata, not a raw dict.""" + transcript = tmp_path / "empty.jsonl" + transcript.write_text("") + + meta = extract_transcript_metadata(transcript) + + assert isinstance(meta, TranscriptMetadata) + + +class TestSessionMetadata: + """Tests for the SessionMetadata model.""" + + def test_session_metadata__serializes_with_token_usage(self) -> None: + """SessionMetadata JSON includes nested token_usage breakdown.""" + token_usage = TokenUsage( + total_input_tokens=5000, + total_output_tokens=2000, + exploration_input_tokens=3000, + exploration_output_tokens=1000, + implementation_input_tokens=2000, + implementation_output_tokens=1000, + subagent_tokens=500, + ) + metadata = SessionMetadata( + session_id="test-session-123", + agent_tool=AgentTool.CLAUDE_CODE, + agent_version="2.0.65", + model="claude-opus-4-5-20251101", + start_time=datetime(2025, 12, 12, 13, 0, 0), + end_time=datetime(2025, 12, 12, 14, 0, 0), + total_events=42, + working_directory="/home/user/project", + git_branch="main", + token_usage=token_usage, + ) + + data = json.loads(metadata.model_dump_json()) + + assert data["token_usage"]["total_input_tokens"] == 5000 + assert data["token_usage"]["total_output_tokens"] == 2000 + assert data["token_usage"]["exploration_input_tokens"] == 3000 + assert data["token_usage"]["subagent_tokens"] == 500 + + def test_session_metadata__agent_tool_discriminator(self) -> None: + """AgentTool enum serializes as its string value.""" + metadata = SessionMetadata( + session_id="test-123", + agent_tool=AgentTool.CLAUDE_CODE, + start_time=datetime(2025, 1, 1), + working_directory="/tmp", + ) + + data = json.loads(metadata.model_dump_json()) + assert data["agent_tool"] == "claude_code" + + metadata_oc = SessionMetadata( + session_id="test-456", + agent_tool=AgentTool.OPENCODE, + start_time=datetime(2025, 1, 1), + working_directory="/tmp", + ) + + data_oc = json.loads(metadata_oc.model_dump_json()) + assert data_oc["agent_tool"] == "opencode" + + def test_session_metadata__optional_fields_default_to_none(self) -> None: + """Optional fields default to None when not provided.""" + metadata = SessionMetadata( + session_id="test-789", + agent_tool=AgentTool.CLAUDE_CODE, + start_time=datetime(2025, 1, 1), + working_directory="/tmp", + ) + + assert metadata.agent_version is None + assert metadata.model is None + assert metadata.end_time is None + assert metadata.git_branch is None + assert metadata.token_usage is None + assert metadata.total_events == 0 + + def test_session_metadata__roundtrip_json(self) -> None: + """SessionMetadata survives JSON serialization roundtrip.""" + original = SessionMetadata( + session_id="roundtrip-test", + agent_tool=AgentTool.CLAUDE_CODE, + agent_version="2.0.65", + model="claude-opus-4-5-20251101", + start_time=datetime(2025, 12, 12, 13, 0, 0), + total_events=10, + working_directory="/home/user/project", + git_branch="feature-branch", + ) + + json_str = original.model_dump_json() + restored = SessionMetadata.model_validate_json(json_str) + + assert restored.session_id == original.session_id + assert restored.agent_tool == original.agent_tool + assert restored.agent_version == original.agent_version + assert restored.model == original.model + assert restored.total_events == original.total_events + assert restored.git_branch == original.git_branch From 869ef058d0423f072deff5a55c9d40b8d0c83717 Mon Sep 17 00:00:00 2001 From: TensorTemplar Date: Sun, 8 Feb 2026 23:55:06 +0200 Subject: [PATCH 3/5] Refactor smell scope to move logic out of formatters --- .coverage | Bin 53248 -> 53248 bytes coverage.xml | 2972 ++++++++++++++------------- src/slopometry/core/hook_handler.py | 155 +- src/slopometry/core/models.py | 14 + tests/test_hook_handler.py | 364 +++- 5 files changed, 1865 insertions(+), 1640 deletions(-) diff --git a/.coverage b/.coverage index d08257265c828f953558639e229bbdbdb2c91967..02f46513fdc2672632bc93f9a8ca21980e890528 100644 GIT binary patch delta 2888 zcmZ8h3s6+o89w*!xp(i~d+(lI_Q6YJ!3VxUQ5R!%S7d?Zr6O1~ElLr=h+uq++TG1# zbXvj3olfG|DWubxq-tBEtw~9&SZ7+BRH=<)K%?Tc#))F2V@10JxBof7MstR}-+%u9 z`~UNw|9+QXn<3a{IAQY^uQbPLU0So|QU9wRQ)^U*|`#HPxFNH$tO}M?qv9M7;Xhd{rz=j1o)zb}>HzwvOREE1wsy|2TVw-nU55 z_Z3K5?Ut&ItD(mC;tVLj`u@65~xTxf@_ z!fIYD(l}eRWUF7WRy9=B?`W!_ofXFbFPZUPE_U)oR{dhWTW|F{_@x$|D{<@Yf>B~F z0g{!SeZSbjnIW)L%+bK9G3SYFNⅈiO*Bvm^|LE=o$HbzQ_c%ig>>aJ2za##z}fx z!F=9l)E5=`#9VQ>Xr{HUv2oqXI#5GB>nU5%|Fp<`s;6WES0TrlT9onfQPbzjW+{uD zF~^%%sgI3^r8l*1vW?6#_ez~wi`;L1&*WFF#xFImx<);&{Ego&FXJzX2ZjBH1Ux~! zCwz&&F#7Ob!xix*!wzBg`v;SFycmN-Q_3=6jv7dma8vYKD>A7>?cb5;WmjAt-v4$x-;fDxQY7ZG9P(SnG^I^%T{t}5LqgWUyebDl>Lg&&W+Op?2cA*4nb7l4rhSw4`WO>jle-k#^+;LVl!$+us`=pqaX z43(xc`G5*7qJ2?i041W)G23!`43gBFEEKL#m|a31)rT!Oy4G;>6a>WCWS=NSTw z_I07c#X%P{sTe_)w^kGi&Qc6g94XRVk{~#8FsO0FbFoO}?9sBINXv7Iw3T2G*2L1X}WgT*1hS4tHSxjyT1II3$lWbE>CuY|4yS`8FbV$)CwD zNIjWu_G*u`by|rwU&HEb)v1a~v$9rsS(&cb71fj{_sO?USuMxpSS=QF@~GHrQ>@5p zN#)C(0w;$i5#79RQ6QAx>z$ez?67&-|JF9}&iFMt>6F^RAxQ*-+Mz;~ zzF(&ye6o9aApGRvt+Rp1v%!HUoq!hHW%#B_4>Tw8gAx7b&0_G0u8rmP82k|j6JAh{YbB|E{L!Xh=VS?diwr`!q4|`a|9UY zW=s3>z9!1VOpZaYT=0V>xj>z+Up-9esP1#Lbs7-g`{=_f^yBnqU`YK@Ojw+(%$D@y z`x64RKI@Rbl4^ipt}{HT+cPkQ7DB0JnnbOk{}_lL!viPZ+P=JFxXD3=v_cT5gmR@= z4oDfc_MaU_JamUTED!^~*96a4QiVtt`2+bad6yg-OFki&$;YIP>?Y?)BiTycAa&#> zc|`7zF!?DtOnONb{Fj_e^tM(Z5F0B(X^uDtOBEuNWz-eG$<>~8?ZNF^G_&*8$80i22 delta 2146 zcmZ9KX-rgC6vyv-bMKq?=4~@9gY3wn2+9ztLSq$#VKz2JrD{}E3f8cS#swFK+7GQ& zk=&Z5X^Nyx+NL$)u2Hd6Q`^)9t;StZKh)Hv*cioPVS3(!p`|zT=Dhzo=bn4+c|UKP z!P{oo8<u5r!WOOAS``M|Q)$mI#)0j;9x06KQvTFk6&NH)YRYl4w_U z9vO#GQzpG{&!VL{VI&b$x~@*d;od3K&5D4R{_$)fZF_X-o4 zx#9`wrm)P^EyoEyAx!O%3dLmJW_%zVGVM~=sFRc@;!4wOWsdTVv{ONR1Ak7gXE(}6 z*)w9FA%we0t{ckm3S$~)BMHXs_!5rfHXBZn#(gc3EbW?`rg6uNryGlBFv;{naUMxp zgaNyz;#6wRwE%jdWZZlVpWp8}nG;MBXJHtk-xF$A$kLyP7y_6h^3FqE!aUqG zX(%rNz-%eWrR#G8nK;@!r-a0g$WL}C%xLiE0+JShv!!G%i5}65%^6IhM(o+*R7hk# z1|)|F@ngwE(CrH|G%88>Obk%^;{YZTMzaF& zmIWCUxMYH%vWEm^;wHwQ!4Gj62qR7NW61>2#fzMb1;*~e=Bb88J=^0Ji8^$Lsq_fDQa3q(q9Rrp_G5Nn}N>DZf$TSnN5CfV1UV%_zHBwN+_XmMV$z0{JcJl+-FU zOXbo+i4%JdSj?Bj5Lv;D5TV>0Z$TDwEIUUgjL?+C(^nrBshk8cMc9%kf-N@EjE~|P zWs{aK9rG-fg;Yj~6+k*j!&u}^`swcF!{1JM{Ji?%xkpD=l-1N+zc9eP+v#1)Yc=b* zzV`C|?)5z#y?595OnvRcMH#nyeXyGAzK=rQ_X+x$J^1T!7NIOOxOmMlx7&OAzZ}pK z_xXG!Yka;&c1LN~osR0ByA^9w~AJXEooQ{he*N+Rz?ScYOYfN2H#VUVFhr z8KJ#txS_n?=lk0y#6UgV$soP3_TJ>?ptsEdblTR*EQ9Fkt?`ZFWzy-MJ)fWVciQS} zhg5yVoEm7JI_1Ew{wH0n{qn8K^e5UoJmIgOWL9`H4G5(^+f!Z9t!1x%Y_%-$c3)2$ zzuDKd_p_&e+`hW4KV0HohK-WWpqFDZ2=rFZ_T6|haB?838iP=01zf%ep~Yzo{4_J@ zlFnhRpqF?Va~AJKS$SBSs8#NJo7+zy0{3B&8D@pNSs-y|W+w8&2K4G7q0!r81F8%} z5H`>6tAyfKWbh)kr6op%(_o*ryznqB(}N<6n$jgg3PSgEIrwL$`?qgsv^ZJqY{k^a zC5wkeI2rqMBKQl8_y{=wTPpiMEht#jtJ?e8_?Nd*vzo~6N?*?@-2PGIq w(G4%_Mv!!46m=t+bVCH)aJ+7?Q8xxoH!RVOj0qM5#-Ixmt9=|n{Gu)OA4w06P5=M^ diff --git a/coverage.xml b/coverage.xml index 33a5fc6..88bcef6 100644 --- a/coverage.xml +++ b/coverage.xml @@ -1,5 +1,5 @@ - + @@ -16,9 +16,9 @@ - + - + @@ -31,16 +31,16 @@ - - + + - + - - - + + + @@ -53,36 +53,36 @@ - - - + + + - - - - - + + + + + - + - + - - - - - - - + + + + + + + - + @@ -100,7 +100,7 @@ - + @@ -109,7 +109,7 @@ - + @@ -118,7 +118,7 @@ - + @@ -127,7 +127,7 @@ - + @@ -141,7 +141,7 @@ - + @@ -150,34 +150,34 @@ - + - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + @@ -202,11 +202,11 @@ - + - + - + @@ -225,7 +225,7 @@ - + @@ -241,7 +241,7 @@ - + @@ -255,7 +255,7 @@ - + @@ -276,12 +276,12 @@ - + - + @@ -301,9 +301,9 @@ - - - + + + @@ -399,23 +399,23 @@ - - - - - - - + + + + + + + - + - - - - - - + + + + + + @@ -438,109 +438,109 @@ - - - - + + + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -548,7 +548,7 @@ - + @@ -564,7 +564,7 @@ - + @@ -583,7 +583,7 @@ - + @@ -619,7 +619,7 @@ - + @@ -627,7 +627,7 @@ - + @@ -640,7 +640,7 @@ - + @@ -649,49 +649,49 @@ - - + + - - - - - - - - - - + + + + + + + + + + - - - - - + + + + + - - + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + @@ -701,23 +701,23 @@ - - - - - - - - + + + + + + + + - - - - + + + + - - + + @@ -727,7 +727,7 @@ - + @@ -821,7 +821,7 @@ - + @@ -838,78 +838,78 @@ - - + + - - - - - + + + + + - - - - - - + + + + + + - + - - - + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -938,80 +938,80 @@ - - - - + + + + - - - - + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + - - + + - + - + - - - - - - - - - - + + + + + + + + + + @@ -1032,11 +1032,11 @@ - - - - - + + + + + @@ -1050,13 +1050,13 @@ - + - + - - - + + + @@ -1064,14 +1064,14 @@ - - - - - - - - + + + + + + + + @@ -1104,9 +1104,9 @@ - - - + + + @@ -1370,22 +1370,22 @@ - - + + - - - - - + + + + + - - + + - + @@ -1404,22 +1404,22 @@ - - - + + + - - - - - + + + + + - - - - + + + + @@ -1428,36 +1428,36 @@ - - - - - + + + + + - - - - + + + + - - - - + + + + - + - + @@ -1482,10 +1482,10 @@ - + - - + + @@ -1498,15 +1498,15 @@ - - - - - - - + + + + + + + - + @@ -1648,483 +1648,486 @@ - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - - - + + + + + + + + + + + + - - + + - - - - - - - - - - - + + + + + + + + + + + - - + + - - - + + + - - + + - - + + - + - - - + + + - + - - + + - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + - - - + + + + - - + + - - - + + + - + - + - + - - - - - - - - - - - + + + + + + + + + + + - - + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + - + + + + - + - - + - + - - - - - - - - - - - - + + + + + + + + + + + + + + + - + + + + + + + + + + + + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - + + + + + + + + + + + - - - - + + + + - + - + @@ -2132,7 +2135,7 @@ - + @@ -2140,7 +2143,7 @@ - + @@ -2202,59 +2205,59 @@ - + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - - - + + + + - - + + - + @@ -2276,7 +2279,7 @@ - + @@ -2290,7 +2293,7 @@ - + @@ -2301,7 +2304,7 @@ - + @@ -2322,7 +2325,7 @@ - + @@ -2335,7 +2338,7 @@ - + @@ -2353,7 +2356,7 @@ - + @@ -2372,7 +2375,7 @@ - + @@ -2383,7 +2386,7 @@ - + @@ -2399,36 +2402,36 @@ - - + + - - - - + + + + - + - + - - + + - - - - - + + + + + - + @@ -2444,7 +2447,7 @@ - + @@ -2626,7 +2629,7 @@ - + @@ -2804,400 +2807,409 @@ + - + - - + - + + - - - - - + + + + + + + - - - + - - - + + - + + + + + - - - + + + + + - - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - + - - - - - - - - + + + + + + + + + + + + - - - + - - - + + + + + + - - - - - + + + - + - - + + - - - - - + + + + + - - + + - - + - - + + + + - - - + - - - - + + + + + - - - + + + - - + + - - + + - - + + - + - - + + - - - + + + + + - - - + - - - - + + + + + + + + + - - - - - - - - - - + + + + + + + - - - - - - - + + + + + + + - - - + + + + - + - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - + + + - + - - - + + + - + + - - - - - - + + + + + + + + - - - + + - - + + - - + + + - - - - - - - - + + + + + + + - - + + + - + + - - - - - - + + + + - - - - - - - - + + + - - - + + + + - - + + + + - - - - - - - - - + + + + + + + + - - - + + - + - - + + - + + - - - + + + + + + + + - - - - - - + + + + + + + + + + - + @@ -3211,13 +3223,13 @@ - - - - - - - + + + + + + + @@ -3254,8 +3266,8 @@ - - + + @@ -3420,39 +3432,39 @@ - + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - - + + + + + - - - + + + - - - - - + + + + + @@ -3463,7 +3475,7 @@ - + @@ -3521,39 +3533,39 @@ - - - - + + + + - - - + + + - - - - - - - - - + + + + + + + + + - - - - - - - - - - - - + + + + + + + + + + + + @@ -3569,11 +3581,11 @@ - + - - - + + + @@ -3585,24 +3597,24 @@ - + - - - - - + + + + + - - - - - - - - - + + + + + + + + + @@ -3651,163 +3663,163 @@ - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - + - + - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + - - + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - - - - - + + + + + + + - - + + - + - - - + + + - - + + - - - - - - + + + + + + - - - - + + + + - - - - - + + + + + - + - - - - - - + + + + + + - + @@ -3815,33 +3827,33 @@ - - - - - - - - - - - - + + + + + + + + + + + + - - - - + + + + - - - + + + - - - + + + @@ -3849,85 +3861,85 @@ - - - - - - + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - - - + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - - + + + + + - - - - + + + + - + - - - - + + + + - - - - - + + + + + - - - + + + - - - + + + - - - - - + + + + + - + @@ -3938,17 +3950,17 @@ - - + + - + - - - + + + @@ -4038,10 +4050,10 @@ - + - - + + @@ -4050,7 +4062,7 @@ - + @@ -4060,22 +4072,22 @@ - - - - - + + + + + - + - - + + - - - + + + @@ -4287,20 +4299,20 @@ - + - - - - - - - - - - - + + + + + + + + + + + @@ -4313,10 +4325,10 @@ - + - + @@ -4331,29 +4343,29 @@ - + - - - + + + - - - - - - + + + + + + - - - + + + - + @@ -4362,20 +4374,20 @@ - + - - - - - - - - - - - + + + + + + + + + + + @@ -4395,9 +4407,9 @@ - - - + + + @@ -4410,7 +4422,7 @@ - + @@ -4432,7 +4444,7 @@ - + @@ -4470,21 +4482,21 @@ - + - + - + @@ -4498,7 +4510,7 @@ - + @@ -4514,7 +4526,7 @@ - + @@ -4523,7 +4535,7 @@ - + @@ -4612,7 +4624,7 @@ - + @@ -4690,13 +4702,13 @@ - + - + @@ -4714,7 +4726,7 @@ - + @@ -4735,13 +4747,13 @@ - + - + @@ -4751,7 +4763,7 @@ - + @@ -4759,7 +4771,7 @@ - + @@ -4789,13 +4801,13 @@ - + - + @@ -4806,7 +4818,7 @@ - + @@ -4818,7 +4830,7 @@ - + @@ -4829,7 +4841,7 @@ - + @@ -4840,7 +4852,7 @@ - + @@ -4850,7 +4862,7 @@ - + @@ -4860,7 +4872,7 @@ - + @@ -4898,7 +4910,7 @@ - + @@ -4908,9 +4920,9 @@ - - - + + + @@ -4927,7 +4939,7 @@ - + @@ -4941,7 +4953,7 @@ - + @@ -5000,7 +5012,7 @@ - + @@ -5032,7 +5044,7 @@ - + @@ -5056,7 +5068,7 @@ - + @@ -5065,7 +5077,7 @@ - + @@ -5096,7 +5108,7 @@ - + @@ -5113,7 +5125,7 @@ - + diff --git a/src/slopometry/core/hook_handler.py b/src/slopometry/core/hook_handler.py index 4b0ae52..1e93abd 100644 --- a/src/slopometry/core/hook_handler.py +++ b/src/slopometry/core/hook_handler.py @@ -20,6 +20,7 @@ NotificationInput, PostToolUseInput, PreToolUseInput, + ScopedSmell, StopInput, SubagentStopInput, ToolType, @@ -387,9 +388,10 @@ def handle_stop_event(session_id: str, parsed_input: "StopInput | SubagentStopIn # Code smells - ALWAYS check (independent of enable_complexity_feedback) # This is stable (based on code state, not session activity) if current_metrics: - smell_feedback, has_smells, _ = format_code_smell_feedback( - current_metrics, delta, edited_files, session_id, stats.working_directory, stats.context_coverage + scoped_smells = scope_smells_for_session( + current_metrics, delta, edited_files, stats.working_directory, stats.context_coverage ) + smell_feedback, has_smells, _ = format_code_smell_feedback(scoped_smells, session_id, stats.working_directory) if has_smells: feedback_parts.append(smell_feedback) cache_stable_parts.append(smell_feedback) @@ -562,40 +564,37 @@ def _is_file_related_to_edits(smell_file: str, edited_files: set[str], related_f return smell_file in edited_files or smell_file in related_files -def format_code_smell_feedback( - current_metrics: "ExtendedComplexityMetrics", - delta: "ComplexityDelta | None", - edited_files: set[str] | None = None, - session_id: str | None = None, - working_directory: str | None = None, - context_coverage: "ContextCoverage | None" = None, -) -> tuple[str, bool, bool]: - """Format code smell feedback using get_smells() for direct field access. +def scope_smells_for_session( + current_metrics: ExtendedComplexityMetrics, + delta: ComplexityDelta | None, + edited_files: set[str], + working_directory: str, + context_coverage: ContextCoverage | None = None, +) -> list[ScopedSmell]: + """Classify smells for a specific session context. + + Extracts the scoping/classification logic that determines which smells are + blocking vs informational and which files are actionable for this session. Args: current_metrics: Current complexity metrics with code smell counts delta: Optional complexity delta showing changes - edited_files: Set of files edited in this session (for blocking smell filtering) - session_id: Session ID for generating the smell-details command + edited_files: Set of files edited in this session working_directory: Path to working directory for import graph analysis context_coverage: Optional context coverage for detecting unread related tests Returns: - Tuple of (formatted feedback string, has_smells, has_blocking_smells) - - has_smells: whether any code smells were detected - - has_blocking_smells: whether any BLOCKING smells in edited files were detected + List of ScopedSmell instances classified for this session """ blocking_smell_names = {"test_skip", "swallowed_exception"} - edited_files = edited_files or set() related_via_imports: set[str] = set() if edited_files: - if not working_directory: - raise ValueError("working_directory is required when edited_files is provided") related_via_imports = _get_related_files_via_imports(edited_files, working_directory) - blocking_smells: list[tuple[str, int, int, str, list[str]]] = [] + result: list[ScopedSmell] = [] + # Synthetic blocking smell: unread related tests if context_coverage: unread_tests: list[str] = [] for file_cov in context_coverage.file_coverage: @@ -603,10 +602,17 @@ def format_code_smell_feedback( if test_file not in file_cov.test_files_read and test_file not in unread_tests: unread_tests.append(test_file) if unread_tests: - guidance = "BLOCKING: You MUST review these tests to ensure changes are accounted for and necessary coverage is added for new functionality" - blocking_smells.append(("Unread Related Tests", len(unread_tests), 0, guidance, unread_tests)) - - other_smells: list[tuple[str, int, int, list[str], str]] = [] + result.append( + ScopedSmell( + label="Unread Related Tests", + name="unread_related_tests", + count=len(unread_tests), + change=0, + actionable_files=unread_tests, + guidance="BLOCKING: You MUST review these tests to ensure changes are accounted for and necessary coverage is added for new functionality", + is_blocking=True, + ) + ) smell_changes = delta.get_smell_changes() if delta else {} @@ -622,12 +628,71 @@ def format_code_smell_feedback( unrelated_files = [f for f in smell.files if f not in related_files] if related_files: - blocking_smells.append((smell.label, len(related_files), change, guidance, related_files)) + result.append( + ScopedSmell( + label=smell.label, + name=smell.name, + count=len(related_files), + change=change, + actionable_files=related_files, + guidance=guidance, + is_blocking=True, + ) + ) if unrelated_files: - other_smells.append((smell.label, len(unrelated_files), 0, unrelated_files, guidance)) + result.append( + ScopedSmell( + label=smell.label, + name=smell.name, + count=len(unrelated_files), + change=0, + actionable_files=unrelated_files, + guidance=guidance, + is_blocking=False, + ) + ) else: - other_smells.append((smell.label, smell.count, change, list(smell.files), guidance)) + if edited_files: + actionable_files = [ + f for f in smell.files if _is_file_related_to_edits(f, edited_files, related_via_imports) + ] + else: + actionable_files = list(smell.files) + result.append( + ScopedSmell( + label=smell.label, + name=smell.name, + count=smell.count, + change=change, + actionable_files=actionable_files, + guidance=guidance, + is_blocking=False, + ) + ) + + return result + + +def format_code_smell_feedback( + scoped_smells: list[ScopedSmell], + session_id: str | None = None, + working_directory: str | None = None, +) -> tuple[str, bool, bool]: + """Format pre-classified smell data into feedback output. + + Args: + scoped_smells: Pre-classified smells from scope_smells_for_session + session_id: Session ID for generating the smell-details command + working_directory: Path to working directory (unused, kept for caller compatibility) + + Returns: + Tuple of (formatted feedback string, has_smells, has_blocking_smells) + - has_smells: whether any code smells were detected + - has_blocking_smells: whether any BLOCKING smells in edited files were detected + """ + blocking_smells = [s for s in scoped_smells if s.is_blocking] + other_smells = [s for s in scoped_smells if not s.is_blocking] lines: list[str] = [] has_blocking = len(blocking_smells) > 0 @@ -636,20 +701,18 @@ def format_code_smell_feedback( lines.append("") lines.append("**ACTION REQUIRED** - The following issues are in files that are in scope for this PR:") lines.append("") - for label, file_count, change, guidance, related_files in blocking_smells: - change_str = f" (+{change})" if change > 0 else f" ({change})" if change < 0 else "" - lines.append(f" • **{label}**: {file_count} file(s){change_str}") - for f in related_files[:5]: + for smell in blocking_smells: + change_str = f" (+{smell.change})" if smell.change > 0 else f" ({smell.change})" if smell.change < 0 else "" + lines.append(f" • **{smell.label}**: {smell.count} file(s){change_str}") + for f in smell.actionable_files[:5]: lines.append(f" - {truncate_path(f, max_width=60)}") - if len(related_files) > 5: - lines.append(f" ... and {len(related_files) - 5} more") - if guidance: - lines.append(f" → {guidance}") + if len(smell.actionable_files) > 5: + lines.append(f" ... and {len(smell.actionable_files) - 5} more") + if smell.guidance: + lines.append(f" → {smell.guidance}") lines.append("") - other_smells_with_changes = [ - (label, count, change, files, guidance) for label, count, change, files, guidance in other_smells if change != 0 - ] + other_smells_with_changes = [s for s in other_smells if s.change != 0] if other_smells_with_changes: if not blocking_smells: lines.append("") @@ -657,15 +720,15 @@ def format_code_smell_feedback( "**Code Smells** (Any increase requires review, irrespective of which session edited related files):" ) lines.append("") - for label, count, change, files, guidance in other_smells_with_changes: - change_str = f" (+{change})" if change > 0 else f" ({change})" - lines.append(f" • **{label}**: {count}{change_str}") - for f in files[:3]: + for smell in other_smells_with_changes: + change_str = f" (+{smell.change})" if smell.change > 0 else f" ({smell.change})" + lines.append(f" • **{smell.label}**: {smell.count}{change_str}") + for f in smell.actionable_files[:3]: lines.append(f" - {truncate_path(f, max_width=60)}") - if len(files) > 3: - lines.append(f" ... and {len(files) - 3} more") - if guidance: - lines.append(f" → {guidance}") + if len(smell.actionable_files) > 3: + lines.append(f" ... and {len(smell.actionable_files) - 3} more") + if smell.guidance: + lines.append(f" → {smell.guidance}") has_smells = len(blocking_smells) > 0 or len(other_smells_with_changes) > 0 if has_smells: diff --git a/src/slopometry/core/models.py b/src/slopometry/core/models.py index 1e0e269..c4669d4 100644 --- a/src/slopometry/core/models.py +++ b/src/slopometry/core/models.py @@ -719,6 +719,20 @@ def get_high_priority_stories(self) -> list[UserStory]: return [story for story in self.user_stories if story.priority <= 2] +class ScopedSmell(BaseModel): + """A smell classified for a specific session context.""" + + model_config = ConfigDict(frozen=True) + + label: str + name: str + count: int + change: int + actionable_files: list[str] + guidance: str + is_blocking: bool + + class SmellData(BaseModel): """Structured smell data with direct field access (no getattr needed).""" diff --git a/tests/test_hook_handler.py b/tests/test_hook_handler.py index 1213754..3a78e45 100644 --- a/tests/test_hook_handler.py +++ b/tests/test_hook_handler.py @@ -11,6 +11,7 @@ format_code_smell_feedback, format_context_coverage_feedback, parse_hook_input, + scope_smells_for_session, ) from slopometry.core.models import ( ComplexityDelta, @@ -223,9 +224,9 @@ def test_extract_dev_guidelines__returns_empty_when_section_missing(self, tmp_pa class TestFormatCodeSmellFeedback: """Tests for code smell feedback formatting.""" - def test_format_code_smell_feedback__returns_empty_when_no_smells(self): - """Test returns empty when no smells detected.""" - metrics = ExtendedComplexityMetrics( + def _make_metrics(self, **kwargs) -> ExtendedComplexityMetrics: + """Create metrics with sensible defaults.""" + defaults = dict( total_complexity=0, average_complexity=0, total_volume=0, @@ -237,8 +238,15 @@ def test_format_code_smell_feedback__returns_empty_when_no_smells(self): total_mi=0, average_mi=0, ) + defaults.update(kwargs) + return ExtendedComplexityMetrics(**defaults) + + def test_format_code_smell_feedback__returns_empty_when_no_smells(self): + """Test returns empty when no smells detected.""" + metrics = self._make_metrics() + scoped = scope_smells_for_session(metrics, None, set(), "/tmp") - feedback, has_smells, has_blocking = format_code_smell_feedback(metrics, None) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is False assert has_blocking is False @@ -246,23 +254,14 @@ def test_format_code_smell_feedback__returns_empty_when_no_smells(self): def test_format_code_smell_feedback__includes_smell_when_count_nonzero(self): """Test that non-blocking smells only show when there are changes (deltas).""" - metrics = ExtendedComplexityMetrics( - total_complexity=0, - average_complexity=0, - total_volume=0, - total_effort=0, - total_difficulty=0, - average_volume=0, - average_effort=0, - average_difficulty=0, - total_mi=0, - average_mi=0, + metrics = self._make_metrics( orphan_comment_count=5, orphan_comment_files=["src/foo.py"], ) # Without delta, non-blocking smells don't show (no changes to report) - feedback, has_smells, has_blocking = format_code_smell_feedback(metrics, None) + scoped = scope_smells_for_session(metrics, None, set(), "/tmp") + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is False assert has_blocking is False assert feedback == "" @@ -271,7 +270,8 @@ def test_format_code_smell_feedback__includes_smell_when_count_nonzero(self): delta = ComplexityDelta( orphan_comment_change=2, # New orphan comments added ) - feedback, has_smells, has_blocking = format_code_smell_feedback(metrics, delta) + scoped = scope_smells_for_session(metrics, delta, set(), "/tmp") + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is True assert has_blocking is False assert "Orphan Comments" in feedback @@ -294,24 +294,13 @@ def test_format_code_smell_feedback__includes_actionable_guidance(self): subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) - metrics = ExtendedComplexityMetrics( - total_complexity=0, - average_complexity=0, - total_volume=0, - total_effort=0, - total_difficulty=0, - average_volume=0, - average_effort=0, - average_difficulty=0, - total_mi=0, - average_mi=0, + metrics = self._make_metrics( swallowed_exception_count=2, swallowed_exception_files=["src/bar.py"], ) - feedback, has_smells, has_blocking = format_code_smell_feedback( - metrics, None, edited_files={"src/bar.py"}, working_directory=str(tmppath) - ) + scoped = scope_smells_for_session(metrics, None, {"src/bar.py"}, str(tmppath)) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is True assert has_blocking is True @@ -337,24 +326,13 @@ def test_format_code_smell_feedback__test_skips_are_blocking(self): subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) - metrics = ExtendedComplexityMetrics( - total_complexity=0, - average_complexity=0, - total_volume=0, - total_effort=0, - total_difficulty=0, - average_volume=0, - average_effort=0, - average_difficulty=0, - total_mi=0, - average_mi=0, + metrics = self._make_metrics( test_skip_count=3, test_skip_files=["tests/test_foo.py"], ) - feedback, has_smells, has_blocking = format_code_smell_feedback( - metrics, None, edited_files={"src/foo.py"}, working_directory=str(tmppath) - ) + scoped = scope_smells_for_session(metrics, None, {"src/foo.py"}, str(tmppath)) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is True assert has_blocking is True @@ -384,26 +362,15 @@ def test_format_code_smell_feedback__not_blocking_when_unrelated_files(self): subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) - metrics = ExtendedComplexityMetrics( - total_complexity=0, - average_complexity=0, - total_volume=0, - total_effort=0, - total_difficulty=0, - average_volume=0, - average_effort=0, - average_difficulty=0, - total_mi=0, - average_mi=0, + metrics = self._make_metrics( test_skip_count=3, test_skip_files=["tests/test_foo.py"], ) # When blocking smells are in unrelated files, they're not blocking # and don't show in the summary (no changes to report for unrelated split) - feedback, has_smells, has_blocking = format_code_smell_feedback( - metrics, None, edited_files={"src/unrelated.py"}, working_directory=str(tmppath) - ) + scoped = scope_smells_for_session(metrics, None, {"src/unrelated.py"}, str(tmppath)) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is False assert has_blocking is False @@ -412,9 +379,8 @@ def test_format_code_smell_feedback__not_blocking_when_unrelated_files(self): # Even with a delta, unrelated blocking smells don't show because # changes can't be attributed to the unrelated portion delta = ComplexityDelta(test_skip_change=1) - feedback, has_smells, has_blocking = format_code_smell_feedback( - metrics, delta, edited_files={"src/unrelated.py"}, working_directory=str(tmppath) - ) + scoped = scope_smells_for_session(metrics, delta, {"src/unrelated.py"}, str(tmppath)) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is False assert has_blocking is False @@ -437,24 +403,13 @@ def test_format_code_smell_feedback__splits_related_and_unrelated_files(self): subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) - metrics = ExtendedComplexityMetrics( - total_complexity=0, - average_complexity=0, - total_volume=0, - total_effort=0, - total_difficulty=0, - average_volume=0, - average_effort=0, - average_difficulty=0, - total_mi=0, - average_mi=0, + metrics = self._make_metrics( swallowed_exception_count=3, swallowed_exception_files=["src/foo.py", "src/bar.py", "src/baz.py"], ) - feedback, has_smells, has_blocking = format_code_smell_feedback( - metrics, None, edited_files={"src/bar.py"}, working_directory=str(tmppath) - ) + scoped = scope_smells_for_session(metrics, None, {"src/bar.py"}, str(tmppath)) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is True assert has_blocking is True @@ -482,24 +437,13 @@ def test_format_code_smell_feedback__related_test_file_triggers_blocking(self): subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) - metrics = ExtendedComplexityMetrics( - total_complexity=0, - average_complexity=0, - total_volume=0, - total_effort=0, - total_difficulty=0, - average_volume=0, - average_effort=0, - average_difficulty=0, - total_mi=0, - average_mi=0, + metrics = self._make_metrics( test_skip_count=2, test_skip_files=["tests/test_foo.py", "tests/test_bar.py"], ) - feedback, has_smells, has_blocking = format_code_smell_feedback( - metrics, None, edited_files={"src/foo.py"}, working_directory=str(tmppath) - ) + scoped = scope_smells_for_session(metrics, None, {"src/foo.py"}, str(tmppath)) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is True assert has_blocking is True @@ -508,18 +452,7 @@ def test_format_code_smell_feedback__related_test_file_triggers_blocking(self): def test_format_code_smell_feedback__unread_tests_are_blocking(self): """Test that unread related tests trigger blocking when context_coverage provided.""" - metrics = ExtendedComplexityMetrics( - total_complexity=0, - average_complexity=0, - total_volume=0, - total_effort=0, - total_difficulty=0, - average_volume=0, - average_effort=0, - average_difficulty=0, - total_mi=0, - average_mi=0, - ) + metrics = self._make_metrics() context_coverage = ContextCoverage( files_edited=["src/foo.py"], @@ -534,9 +467,8 @@ def test_format_code_smell_feedback__unread_tests_are_blocking(self): ], ) - feedback, has_smells, has_blocking = format_code_smell_feedback( - metrics, None, context_coverage=context_coverage - ) + scoped = scope_smells_for_session(metrics, None, set(), "/tmp", context_coverage=context_coverage) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) assert has_smells is True assert has_blocking is True @@ -546,7 +478,70 @@ def test_format_code_smell_feedback__unread_tests_are_blocking(self): def test_format_code_smell_feedback__read_tests_not_blocking(self): """Test that read tests are not included in unread tests blocking.""" - metrics = ExtendedComplexityMetrics( + metrics = self._make_metrics() + + context_coverage = ContextCoverage( + files_edited=["src/foo.py"], + files_read=["src/foo.py", "tests/test_foo.py"], + file_coverage=[ + FileCoverageStatus( + file_path="src/foo.py", + was_read_before_edit=True, + test_files=["tests/test_foo.py"], + test_files_read=["tests/test_foo.py"], # Was read + ) + ], + ) + + scoped = scope_smells_for_session(metrics, None, set(), "/tmp", context_coverage=context_coverage) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) + + assert has_smells is False + assert has_blocking is False + assert "Unread Related Tests" not in feedback + + def test_format_code_smell_feedback__non_blocking_smells_only_list_edited_files(self): + """Test that non-blocking smell file lists are filtered to edited + test files.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmppath = Path(tmpdir) + subprocess.run(["git", "init"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.name", "Test"], cwd=tmppath, capture_output=True) + + src_dir = tmppath / "src" + src_dir.mkdir() + (src_dir / "edited.py").write_text("def edited(): pass") + (src_dir / "unrelated.py").write_text("def unrelated(): pass") + + subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) + subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) + + metrics = self._make_metrics( + inline_import_count=10, + inline_import_files=["src/edited.py", "src/unrelated.py", "src/other.py"], + ) + + delta = ComplexityDelta(inline_import_change=3) + scoped = scope_smells_for_session(metrics, delta, {"src/edited.py"}, str(tmppath)) + feedback, has_smells, has_blocking = format_code_smell_feedback(scoped) + + assert has_smells is True + assert has_blocking is False + # Total count is repo-level + assert "10" in feedback + assert "(+3)" in feedback + # Only edited file is listed, not unrelated ones + assert "edited.py" in feedback + assert "unrelated.py" not in feedback + assert "other.py" not in feedback + + +class TestScopeSmellsForSession: + """Tests for scope_smells_for_session classification logic.""" + + def _make_metrics(self, **kwargs) -> ExtendedComplexityMetrics: + """Create metrics with sensible defaults.""" + defaults = dict( total_complexity=0, average_complexity=0, total_volume=0, @@ -558,27 +553,168 @@ def test_format_code_smell_feedback__read_tests_not_blocking(self): total_mi=0, average_mi=0, ) + defaults.update(kwargs) + return ExtendedComplexityMetrics(**defaults) + + def test_scope_smells_for_session__returns_empty_when_no_smells(self): + """Test returns empty list when metrics have no smells.""" + metrics = self._make_metrics() + result = scope_smells_for_session(metrics, None, set(), "/tmp") + assert result == [] + def test_scope_smells_for_session__classifies_swallowed_exception_as_blocking_when_in_edited_files(self): + """Test that swallowed_exception in edited files is classified as blocking.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmppath = Path(tmpdir) + subprocess.run(["git", "init"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.name", "Test"], cwd=tmppath, capture_output=True) + + src_dir = tmppath / "src" + src_dir.mkdir() + (src_dir / "foo.py").write_text("def foo(): pass") + + subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) + subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) + + metrics = self._make_metrics( + swallowed_exception_count=1, + swallowed_exception_files=["src/foo.py"], + ) + + result = scope_smells_for_session(metrics, None, {"src/foo.py"}, str(tmppath)) + + blocking = [s for s in result if s.is_blocking] + assert len(blocking) == 1 + assert blocking[0].name == "swallowed_exception" + assert blocking[0].actionable_files == ["src/foo.py"] + + def test_scope_smells_for_session__classifies_swallowed_exception_as_non_blocking_when_unrelated(self): + """Test that swallowed_exception in unrelated files is non-blocking.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmppath = Path(tmpdir) + subprocess.run(["git", "init"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.name", "Test"], cwd=tmppath, capture_output=True) + + src_dir = tmppath / "src" + src_dir.mkdir() + (src_dir / "foo.py").write_text("def foo(): pass") + (src_dir / "bar.py").write_text("def bar(): pass") + + subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) + subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) + + metrics = self._make_metrics( + swallowed_exception_count=1, + swallowed_exception_files=["src/foo.py"], + ) + + result = scope_smells_for_session(metrics, None, {"src/bar.py"}, str(tmppath)) + + blocking = [s for s in result if s.is_blocking] + assert len(blocking) == 0 + non_blocking = [s for s in result if s.name == "swallowed_exception"] + assert len(non_blocking) == 1 + assert non_blocking[0].is_blocking is False + + def test_scope_smells_for_session__splits_blocking_smell_files_between_related_and_unrelated(self): + """Test that a blocking smell with mixed files produces two ScopedSmells.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmppath = Path(tmpdir) + subprocess.run(["git", "init"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.name", "Test"], cwd=tmppath, capture_output=True) + + src_dir = tmppath / "src" + src_dir.mkdir() + (src_dir / "edited.py").write_text("def edited(): pass") + (src_dir / "other.py").write_text("def other(): pass") + + subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) + subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) + + metrics = self._make_metrics( + swallowed_exception_count=2, + swallowed_exception_files=["src/edited.py", "src/other.py"], + ) + + result = scope_smells_for_session(metrics, None, {"src/edited.py"}, str(tmppath)) + + swallowed = [s for s in result if s.name == "swallowed_exception"] + assert len(swallowed) == 2 + blocking = [s for s in swallowed if s.is_blocking] + non_blocking = [s for s in swallowed if not s.is_blocking] + assert len(blocking) == 1 + assert blocking[0].actionable_files == ["src/edited.py"] + assert len(non_blocking) == 1 + assert non_blocking[0].actionable_files == ["src/other.py"] + + def test_scope_smells_for_session__non_blocking_smell_preserves_repo_count_and_change(self): + """Test that non-blocking smells keep repo-level count and delta.""" + metrics = self._make_metrics( + orphan_comment_count=5, + orphan_comment_files=["src/a.py", "src/b.py"], + ) + delta = ComplexityDelta(orphan_comment_change=2) + + result = scope_smells_for_session(metrics, delta, set(), "/tmp") + + orphan = [s for s in result if s.name == "orphan_comment"] + assert len(orphan) == 1 + assert orphan[0].count == 5 + assert orphan[0].change == 2 + assert orphan[0].is_blocking is False + + def test_scope_smells_for_session__unread_tests_produce_synthetic_blocking_smell(self): + """Test that unread related tests from context_coverage produce a blocking ScopedSmell.""" + metrics = self._make_metrics() context_coverage = ContextCoverage( files_edited=["src/foo.py"], - files_read=["src/foo.py", "tests/test_foo.py"], + files_read=["src/foo.py"], file_coverage=[ FileCoverageStatus( file_path="src/foo.py", was_read_before_edit=True, test_files=["tests/test_foo.py"], - test_files_read=["tests/test_foo.py"], # Was read + test_files_read=[], ) ], ) - feedback, has_smells, has_blocking = format_code_smell_feedback( - metrics, None, context_coverage=context_coverage - ) + result = scope_smells_for_session(metrics, None, set(), "/tmp", context_coverage=context_coverage) - assert has_smells is False - assert has_blocking is False - assert "Unread Related Tests" not in feedback + blocking = [s for s in result if s.is_blocking] + assert len(blocking) == 1 + assert blocking[0].name == "unread_related_tests" + assert blocking[0].actionable_files == ["tests/test_foo.py"] + + def test_scope_smells_for_session__filters_actionable_files_for_non_blocking_with_edits(self): + """Test that non-blocking smells only list actionable files when edited_files is provided.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmppath = Path(tmpdir) + subprocess.run(["git", "init"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=tmppath, capture_output=True) + subprocess.run(["git", "config", "user.name", "Test"], cwd=tmppath, capture_output=True) + + src_dir = tmppath / "src" + src_dir.mkdir() + (src_dir / "edited.py").write_text("def edited(): pass") + (src_dir / "other.py").write_text("def other(): pass") + + subprocess.run(["git", "add", "."], cwd=tmppath, capture_output=True) + subprocess.run(["git", "commit", "-m", "init"], cwd=tmppath, capture_output=True) + + metrics = self._make_metrics( + orphan_comment_count=3, + orphan_comment_files=["src/edited.py", "src/other.py"], + ) + + result = scope_smells_for_session(metrics, None, {"src/edited.py"}, str(tmppath)) + + orphan = [s for s in result if s.name == "orphan_comment"] + assert len(orphan) == 1 + assert orphan[0].actionable_files == ["src/edited.py"] class TestGetRelatedFilesViaImports: From b40f9437aec38232f5d27e0f7327b81ed829e5eb Mon Sep 17 00:00:00 2001 From: TensorTemplar Date: Mon, 9 Feb 2026 23:23:51 +0200 Subject: [PATCH 4/5] Drop obsolete qpe split, use qpe as absolute --- .coverage | Bin 53248 -> 53248 bytes .github/workflows/ci.yml | 3 +- coverage.xml | 6136 +++++++++-------- src/slopometry/core/models.py | 41 +- .../core/python_feature_analyzer.py | 53 + src/slopometry/display/formatters.py | 23 +- src/slopometry/summoner/cli/commands.py | 7 +- .../summoner/services/qpe_calculator.py | 27 +- tests/test_baseline_service.py | 4 +- tests/test_python_feature_analyzer.py | 105 + tests/test_qpe_calculator.py | 127 +- tests/test_smell_registry.py | 12 +- 12 files changed, 3329 insertions(+), 3209 deletions(-) diff --git a/.coverage b/.coverage index 02f46513fdc2672632bc93f9a8ca21980e890528..d108aef89611c4fddf469f21e7a6f8dee8729b4a 100644 GIT binary patch delta 3630 zcmZ8i3se(V8oo1`nPl>qNeJN$32*R)l~u7W5|x*rfG7yMV3eg+7iiyPna~V*Yy2bZN0fe_}b*)iNmCP|l+7j2%g6IndZm%E*qhcEGgQggZK%e0s`w{Y1~D$5H}!$o#MslHT!4$K7cPfB8g86H|C({G)G!L$A(JX-u_n#$NE<8O0&rx&lB<0{~EJV`qWCqyH z;_4QWx}uVeF-7I2rR&OmzYTaNs-TjJJG*p_vZ%alTX{(_ICGS6IFU0aYp5gz#94us z=Z1~j*KXgsu4r@dR>)Z{hd?9*e#6D2`H?hO3L%ZzUcR}wY-6RElp=%C&E>vK(~wd~ z(2MP{>0Z<-3d~>U)RC;k7m-{`=G=OFMiiDO30E~LaCrlR~Y_qaUS}yyF%pn!h z7`B3)%?uF#puSh>nNL+)iBh_V)+y&xM--39j|gAIaVArdMPHDqB}G(w zv`Si}jb{%9;=~F9{mLV*4zl)`}q$*`paT;p?(C_^li+nt?7hP*%p zgh&Rz-~laS2B;egQq*C3?m$5r8I(X+vB`R}2`vV4rot2~fIF0%#DNM)|Fr~&@OcxW z5J|s$!a94x8;VJhv!yMy4muga$L4YnNPk}ZuDGV-;q!tra zdeUESFANLLjiy|P{gJ)Qe#ow1eHbSrSADK}Nu^O?$}#1S%D*eR6c-eS6;}8}-j-jN ze_BAYJ@lRlIllOC471s}|GX|z;Bx#~6Qk14Z9G=b3({*?`= zeXaWGb4I4v7@H)_TaW3&WuqjRv99}zetIj_D(|x_2hFMg)SMo z7PdwLrk`c(V@YrXWF!WkF5f9LfG-tcH~_}r7Y!B#23w@|4u_PPzVcZ{DY8^$4bQX1 zyK0bKXKSUyAmV9Qt+iktp|FjJ?kT~H(}hz6Lb9|F5~Ho2evZ+$YH54*=!NmtDfS-k zZlUZZWU;k<>g*jKJG3y!{PpmoUv@3P@tMI;WxcLa`o+0^G}LtB_JZ6sE`B@Oe#Gt3 z67O@e^fR8{ZbQZd^td3O&#B;9odHfvQ{%5vc_ zPGuVJ#n&7kADk^R!YE&O1*6*M?*ka;-E?TS3A23gF{wbkZEgGUs3*=nt*q7?f>B0lo~H>H_W^h~Te#1qV9vhw)Qfy%Z!HyTdN z?|)Q!@9PH_Un?pr>$>A^+1P!!S}PFVC3l=DcJ);aH;>I8| z_y&ot;paOp;dxbA6N57dNI-P_phHO1JI%a#nCENI_nq4+%6l(0b_ZUYUVdlJ`b+p1 zy}9q*ARnI`Ej%+ksNHgD_2`2g&BoLA{-y=22aq%bHGSpP^`N|U`M7tm1{{gum9Dd< zwddWWM>S_mFppptovKFqe^&bB$}9EV8+hK$x0Z}`^EI>k2WniU z3!H;zb~yP_{_6GWsU|(`!(xa`HdZ`-|Q=x ze?*v@S(x6zd;FToLB^jL;JfN$o!xEjf$qM#=AHjq0DJgrJ=^9kqMpP}bev@86Eu5Wf$l=Xk+}m9!FU&#+BFT~bCNghHFPKJCJL3SId@aTUr|48 z8p5n34Wr#74{*ezk?(}NkEG8J>IiP{eyuzMp_CHZ&R7?7wfk3?Gi8Flf)tKb)Va~f zoP;ME3f%KX+NNBtv1SYUu_Yv=H{-T5=*hieEX$OI>e@z=b13A_FJBpsp5})m)78k# z8Z{;x>6E!IJylxEq$Ex6Ep%*#kH^m4&Z7-Y2>nTh8KGg^hztN2!c1LVy?2(OIn*Piu zG@ut+) z;7Um$gmE!a2Q^jEppe0UYCEgUtxn0)gh1it6U&0!p0?@mV?-AG=4O}c*u{$Ro8zbF zj|-Pk-n(}mFG_EmN+^MF-NG%7-Upn5lB7AB7QM~e^@C4w?igy0Afe8WXB zgozLxDuQ2#2)bYq)CLhKy$EcO2$6vzganAdh*yj0{X|RUD}uKVWforV^KULw#s z5lBxF+M;2{w~g9~b-Wgpef{4cqFwr&6b delta 2513 zcmZ8h3s6+o8NT=Kxp(i~`#8Jo3lL-lA5?5miGcC38(5a-qAnts2S^anQ5PRk8#UeC zJSMM#HD@xZbtaNbJF#LL6Q)gugot&TwrLBKiKAdrL#AV#m~Ej$B^eO5|2ZI&$%T8r z|MC6*Ip;s$Y_!u9?KEAm`+|)|vOcJ{>t5}DT9?+MS=GO&2h~NEtCn_4nQ}+@jZ&+) z<$n1YxxjqW{0p;R`da$Av|79=c8IIcXXrV!#Pq4@C#DqPAHwmsPo@ddhGmG0Ws(0@ z-$$zahI40I+wR7LEe8(oYHqo2-xC!%kWFFP3q^{vdC#ug=C-|io5I@ zn<{ICP$uL23^=t5AmS$j+cs|!hbsabD5)O27woN8^d ziHp!f>5Ywhn|6g88zC5S!?JlK=+BTUT+oHiB#->3!Y*ub5>GHBIv}XB;JKjA+o5X# z8423>B*Iq*313+))L2Q_UqDV(qzM5`_LZ(Ai>n+$jRDab$*)7bPFE%2swAOQg9a-} zf50WGkZ`lc?Ij9P%Ppb>BIzs=EO$!f$}Hi2I7JdKljWuBr4lm)G2>W+h7gcoy?{_8 zk`Ff&bPrc&^Yu!yr9)k;oU>e0AD0VpuaRPG)9#p0$ z`77P0?a5BA#=?O9a?UU&O+K50>vCwju zm+tt1q?T18m|iSY==gz}avBhbDHeKgMo2YONKXDosgA_-O$cN}y;&KFX>)l{kvOj$frw_z%Cazi!YAKpNk z9@@-XNn2eWl@E`>FC@SAr-?=h0s+B#B>adSv0Cc%2b`i-fj~m{cC3~wq8daXp_wx} zMax`14HTr1+&Zr)2M`E|GC)AQ85S%RrD7CQXsmmyui-s-h2hi3 z^xb;3zFtRKzUI;-wO!q%KCG@#9jaz2RYsLByKUAk#jU#$ucW!JFSBtrYo<`^5_u)I z6qC9aHp)d#aGpjQdFzGWuHo)IR%&=82h3-cp6~wkl-I~k zf@H`bT`y)uG#l8dj-CpRlQ}-q3SK}w`esqb(m&t$^bhCOd^5K9*57Zxx4$_Y9_*i% zb`C|4V7iyEbKl;FF7MtG-$fp)IAjMPDB!k#{9{6V&IpD#s{YJ&rFS9>zRs7 zB?gDu2Bxn*bb4xF`iqpi-HCW2(VRO;dgJd@j<*a<$1kqPJn#MHYU<_D_jk9B!LjMt zPuxm$%?zRU+vhJNng{yht=`G**2v}Y>-r?M%F?AYelqIDOBNj2ZV{C)%L@7F1{Eh8m1%V zwiWR3PhlpaeNKnRMW@cJ+w4=L*Ebp#Iw*M}=h(XBI6k1wQ&1MjK^5waVf8prJ)^cl zfvO@3*Af$D7}HZ0i9FDrY4JgtUKQ^nJKAd+E6wz_UFL~8>76@EYQ5jJa?`6v2e?aT zVj&=+KChQ+zjve7dv`r^10EpImp#x@j)f&rQJ!v?*bRp`e0=hC7fI{*@mh|%ByCF> zeEm}D`Ix@v$h!&e>9#(-_|?x+p)%U3ySS*~F%NTndzpG5==Q*eDV{vrk*9+*7x0lk zbu5fPgzd#g4Sw6T=lInk%;a%v&(_hSv1X^SXOF%8LX9!SgWJ+GYN1X|W-g&f3v7Wlex6Nd-!@A2>O zoA_n?G5!R9fIIP%IOQ^K!-w%RcqhJr$M8)&fnUO>a2z+m&r1%DNYIpbyBS~?1I@`m zcQCNn85l_n95x1`m4Op8Pz(l0XJFD82r2{F!a!9RNHPPnSwxD$OA_+H>Q<2jlMn-! PiGfX^x1`wL=v@APk4mz6 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e63a60e..29db8a6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -71,7 +71,6 @@ jobs: | MI (normalized) | ${qpe.mi_normalized.toFixed(3)} | Maintainability Index / 100 | | Smell Penalty | ${qpe.smell_penalty.toFixed(3)} | Weighted code smell deduction | | Adjusted Quality | ${qpe.adjusted_quality.toFixed(3)} | MI × (1 - smell_penalty) + bonuses | - | Effort Factor | ${qpe.effort_factor.toFixed(2)} | log(Halstead Effort + 1) |
Code Smell Breakdown @@ -82,7 +81,7 @@ jobs:
- > Higher QPE = better quality per unit effort`; + > Higher QPE = better quality`; const { data: comments } = await github.rest.issues.listComments({ owner: context.repo.owner, diff --git a/coverage.xml b/coverage.xml index 88bcef6..aa92133 100644 --- a/coverage.xml +++ b/coverage.xml @@ -1,5 +1,5 @@ - + @@ -16,9 +16,9 @@ - + - + @@ -31,47 +31,47 @@ - - + + - - - - - + + + + + - - - - - - - - - + + + + + + + + + - - - + + + - - - - - - - - + + + + + + + + - + - + - + @@ -81,41 +81,41 @@ - + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - - - - + + + + + + - - - - - - + + + + + + @@ -128,17 +128,17 @@ - - - - - - - - - - - + + + + + + + + + + + @@ -150,7 +150,7 @@ - + @@ -178,53 +178,53 @@ - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + - + - + - - - - - - - - - - + + + + + + + + + + - - + + - + @@ -256,32 +256,32 @@ - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - + + + - - + + - + @@ -301,9 +301,9 @@ - - - + + + @@ -317,43 +317,43 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -399,114 +399,114 @@ - - - - - - - + + + + + + + - + - - - - - - + + + + + + - - - - - - - - - + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -526,129 +526,129 @@ - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - - - - + + + + + - + - - - + + + - - + + - - - + + + - - - - - - - + + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + - - - - - - - - + + + + + + + + - + - - - - - - - + + + + + + + - - - - - - - - - - - - + + + + + + + + + + + + - - - - - + + + + + - + @@ -673,10 +673,10 @@ - - - - + + + + @@ -692,15 +692,15 @@ - - - - - - - + + + + + + + - + @@ -718,110 +718,110 @@ - - - - - - - - - + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - + + + + + + - + @@ -840,7 +840,7 @@ - + @@ -862,8 +862,8 @@ - - + + @@ -931,12 +931,12 @@ - - - - - - + + + + + + @@ -1012,18 +1012,18 @@ - - - - - - - - - - - - + + + + + + + + + + + + @@ -1108,32 +1108,32 @@ - - - - - - + + + + + + - - - - - - - - - + + + + + + + + + - - - - - - - - - + + + + + + + + + @@ -1266,28 +1266,28 @@ - - - + + + - - - - + + + + - - + + - - + + - - - - - - + + + + + + @@ -1351,23 +1351,23 @@ - - - + + + - - - + + + - - - - - + + + + + @@ -1385,7 +1385,7 @@ - + @@ -1420,12 +1420,12 @@ - - - - + + + + - + @@ -1441,10 +1441,10 @@ - - + + - + @@ -1478,38 +1478,38 @@ - - - - + + + + - - + + - - - - - - - - + + + + + + + + - - - - - - - + + + + + + + - - - - + + + + @@ -1518,102 +1518,102 @@ - - - + + + - + - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - + + + - + - + - - - - - - + + + + + + - + - - - - - - - - - - - + + + + + + + + + + + - - - - - - + + + + + + - + - + - + @@ -1623,32 +1623,32 @@ - - - - - + + + + + - - - - - - - - + + + + + + + + - - - + + + - + @@ -1759,32 +1759,32 @@ - - - + + + - - - - - - - - - + + + + + + + + + - - - - - - + + + + + + - - - + + + @@ -2102,7 +2102,7 @@ - + @@ -2116,96 +2116,96 @@ - - + + - - - + + + - + - - - - - - - + + + + + + + - - - - - - - + + + + + + + - - - - - - - - - + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - + + + + + + + - + @@ -2227,9 +2227,9 @@ - - - + + + @@ -2241,10 +2241,10 @@ - - - - + + + + @@ -2257,7 +2257,7 @@ - + @@ -2282,45 +2282,45 @@ - + - - - - + + + + - + - + - - - + + + - + - - - - + + + + - - - - - - - + + + + + + + @@ -2328,10 +2328,10 @@ - + - - + + @@ -2341,15 +2341,15 @@ - + - - - - - - - + + + + + + + @@ -2359,47 +2359,47 @@ - + - - - - - - - + + + + + + + - + - + - - - + + + - + - - + + - - - - - - + + + + + + @@ -2420,34 +2420,34 @@ - - + + - - - + + + - - - - - - - - - - - - + + + + + + + + + + + + - + @@ -2473,38 +2473,29 @@ - - - - - + + + - - - - - - - - - - - - - + + + + + + + + + + - - + + - - - - @@ -2512,6 +2503,7 @@ + @@ -2520,7 +2512,6 @@ - @@ -2533,196 +2524,195 @@ + + + + + - - - + + - - + + - - - - + + + + + - - - + + - - - + + + - - - + + + - - + + + - - - + + - - - + + - - - + + + + - - - - + + - - - - - + + + + + + + + - - - - + + - - - + + + - - + + - + - - + + - + + - + - - - - + + + - - - - + + + + + + + + - - - - - - + + - - + + - - - - @@ -2732,188 +2722,187 @@ + + + + + + - - - + + + + + - - - - - - + + + - - - + + + + + - - - - - + + + - - - + + - - + + - - - - + + + - - - - - - - - + + + + + + + + + + + - - - - + + + - - - + + - + - + - - + + - + + + + + - - - - - - + + - + + + - + + + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - - - - - + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - + - + + + + + - - - + - - + + - - @@ -2923,54 +2912,54 @@ - - + + - - + + - - - + + + - - - - + + + + + - - - - + + + + - + + - - - - + + @@ -2982,234 +2971,246 @@ - - + + - - + + - - + + + + - - + + - - + + + + - - - - - + + + + + + + + - + - - - - - - - - - - - + + + + + + + + + + + + - - - - - - + + + - - - - - - + + + + + - - - + + - - - - - - - - + + + + - + + + + - - + + - - + + + - + + + + + - - + - - - - + - - + + + - - - - - + + + + - - - - - + + + + + + - - + + + + - + - - - + - - - + + + + - - - - - - - - + + - + + - - - - + + + + + + - - + + + - - + + - - - - + + - - + - + - + - - + + - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - + @@ -3231,74 +3232,74 @@ - - + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - + + + - - - - - - - - - - - + + + + + + + + + + + - - - - - - - + + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - - - + + + + + @@ -3316,123 +3317,123 @@ - + - - - - - - - - + + + + + + + + - - - - - - - - + + + + + + + + - + - - - - - + + + + + - - - - - - + + + + + + - - - + + + - - - - - - - - - + + + + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - - - - - - - - - - + + + + + + + + + + + + - - - - - - - + + + + + + + - - - + + + - - - - - - - - + + + + + + + + - + @@ -3448,13 +3449,13 @@ - + - + @@ -3465,17 +3466,17 @@ - - - - - - - - + + + + + + + + - + @@ -3517,13 +3518,9 @@ - - - - + - @@ -3532,414 +3529,445 @@ + + - - - - + + + + - - - - - - - - + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + - - - - - - - - - + + + + + + + + + - - + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - + + + - + - - - - - - - - - + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + + - - - - - - + + + + + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - + + + + + + + + + + - - + - - - - - - - + + + + + + - - - - + + + + + - - - - - - - + + + + + + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + - - + + + - - - - - - - - - - - - - - + + + + + + + + + + + + - - + + - + + - - - - - - - + + + + + + + + - - - - - - - - - + + + + + + + + - - - - + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - - - + + + + + + + - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -3952,12 +3980,12 @@ - - + + - + - + @@ -3965,13 +3993,13 @@ - + - + - + @@ -4033,7 +4061,7 @@ - + @@ -4045,8 +4073,8 @@ - - + + @@ -4056,13 +4084,13 @@ - + - + - + @@ -4072,25 +4100,25 @@ - - - - - + + + + + - + - - + + - - - - - - + + + + + + @@ -4238,68 +4266,68 @@ - + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - - - + + + + + - - - - - - - - - - - - + + + + + + + + + + + + - - - - - + + + + + - - + + - - - - + + + + - + @@ -4313,51 +4341,51 @@ - - - - - - - + + + + + + + - - - + + + - - + + - - - - - - - - - - - + + + + + + + + + + + - + - + - - + + - - + + @@ -4365,7 +4393,7 @@ - + @@ -4374,7 +4402,7 @@ - + @@ -5078,80 +5106,76 @@ - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - + + + + + + + - + + + + + + + + - - - - - - - - - - - - + + + + + + + - + + + + + + + + - - + - - - - - - - - - - + - - @@ -5566,181 +5590,181 @@ - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + - - - - - + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - + - - - - + + + + - - - - - - - - - - - - + + + + + + + + + + + + - - + + - - - - + + + + - - - + + + - + - + - + @@ -5749,7 +5773,7 @@ - + @@ -5766,312 +5790,312 @@ - - - - - - + + + + + + - - + + - + - + - - - - - - - - - - - - + + + + + + + + + + + + - - - + + + - - - + + + - - - + + + - - + + - - + + - + - + - - + + - - - - - - - - - + + + + + + + + + - + - + - - + + - + - - + + - + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + - - + + - + - + - - - + + + - + - + - + - - + + - + - + - - - - - - - - + + + + + + + + - - + + - + - + - + - + - + - + - - + + - + - - + + - + - - + + - + - + - + - + - + - - + + - - - + + + - + - + - + - - - - + + + + - - + + - - + + - + - + - - - - - - - - + + + + + + + + - + - - + + - - + + @@ -6093,190 +6117,190 @@ - + - + - + - + - - + + - - + + - + - + - - - + + + - - - - - - - - + + + + + + + + - + - + - - + + - - + + - + - + - + - + - - + + - - + + - - + + - - - - - + + + + + - + - - - + + + - + - + - + - + - - - - - + + + + + - + - + - + - + - - - - + + + + - - + + - + - + - + - - - - - - - - + + + + + + + + - + - + - + - - + + - + - + - - - - - - + + + + + + @@ -6298,64 +6322,64 @@ - + - + - + - + - - - - - - + + + + + + - + - + - + - + - - - - - - + + + + + + - - + + - + - + - + @@ -6364,168 +6388,168 @@ - - + + - + - - - - - - - + + + + + + + - + - + - + - - + + - - - - - + + + + + - - + + - + - + - + - + - + - + - + - + - + - - - + + + - + - + - - - - - + + + + + - - + + - + - - + + - + - - - + + + - + - - + + - - + + - - + + - - - + + + - - - - - - - + + + + + + + - + - + - + - + - - + + - + - + - + - - + + - + - - + + - - - - + + + + @@ -6535,325 +6559,326 @@ - + + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - + - - - - - - - - - - - + - - - - + + + - + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -6862,101 +6887,101 @@ - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -6964,10 +6989,10 @@ - - - - + + + + @@ -6980,37 +7005,37 @@ - - - - + + + + - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + @@ -7120,41 +7145,41 @@ - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + - + - + - - - - - - - - + + + + + + + + @@ -7163,11 +7188,11 @@ - - - - - + + + + + @@ -7183,7 +7208,7 @@ - + @@ -7193,7 +7218,7 @@ - + @@ -7202,17 +7227,17 @@ - + - - - - - - - - + + + + + + + + @@ -7234,45 +7259,45 @@ - + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + @@ -7344,67 +7369,67 @@ - + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - + - - + + - + - + - - - - + + + + - - - - + + + + - - - - + + + + - + @@ -7422,7 +7447,7 @@ - + @@ -7446,108 +7471,9 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + @@ -7555,116 +7481,212 @@ - + + + + + - - - - - - - + + + - - - - - - - - - + - + - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - - - - - - + + + + + + + + - + - - - - - - - - - - - - + + + + + + + + + + + + - - - + + + - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + - + diff --git a/src/slopometry/core/models.py b/src/slopometry/core/models.py index c4669d4..d041311 100644 --- a/src/slopometry/core/models.py +++ b/src/slopometry/core/models.py @@ -158,6 +158,15 @@ class SmellDefinition(BaseModel): count_field="passthrough_wrapper_count", files_field="passthrough_wrapper_files", ), + "sys_path_manipulation": SmellDefinition( + internal_name="sys_path_manipulation", + label="sys.path Manipulation", + category=SmellCategory.PYTHON, + weight=0.10, + guidance="sys.path mutations bypass the package system — restructure package boundaries and use absolute imports from installed packages instead", + count_field="sys_path_manipulation_count", + files_field="sys_path_manipulation_files", + ), } @@ -420,6 +429,7 @@ class ComplexityDelta(BaseModel): single_method_class_change: int = 0 deep_inheritance_change: int = 0 passthrough_wrapper_change: int = 0 + sys_path_manipulation_change: int = 0 def get_smell_changes(self) -> dict[str, int]: """Return smell name to change value mapping for direct access.""" @@ -437,6 +447,7 @@ def get_smell_changes(self) -> dict[str, int]: "single_method_class": self.single_method_class_change, "deep_inheritance": self.deep_inheritance_change, "passthrough_wrapper": self.passthrough_wrapper_change, + "sys_path_manipulation": self.sys_path_manipulation_change, } @@ -866,6 +877,11 @@ class ExtendedComplexityMetrics(ComplexityMetrics): files_field="passthrough_wrapper_files", guidance="Function that just delegates to another with same args; consider removing indirection", ) + sys_path_manipulation_count: int = SmellField( + label="sys.path Manipulation", + files_field="sys_path_manipulation_files", + guidance="sys.path mutations bypass the package system — restructure package boundaries and use absolute imports from installed packages instead", + ) # LOC metrics (for file filtering in QPE) total_loc: int = Field(default=0, description="Total lines of code across all files") @@ -889,6 +905,7 @@ class ExtendedComplexityMetrics(ComplexityMetrics): default_factory=list, description="Files with deep inheritance (>2 bases)" ) passthrough_wrapper_files: list[str] = Field(default_factory=list, description="Files with pass-through wrappers") + sys_path_manipulation_files: list[str] = Field(default_factory=list, description="Files with sys.path mutations") def get_smells(self) -> list["SmellData"]: """Return all smell data as structured objects with direct field access.""" @@ -958,6 +975,11 @@ def get_smells(self) -> list["SmellData"]: count=self.passthrough_wrapper_count, files=self.passthrough_wrapper_files, ), + SmellData( + name="sys_path_manipulation", + count=self.sys_path_manipulation_count, + files=self.sys_path_manipulation_files, + ), ] def get_smell_files(self) -> dict[str, list[str]]: @@ -1353,21 +1375,17 @@ def interpret_qpe(self, verbose: bool = False) -> ZScoreInterpretation: class QPEScore(BaseModel): - """Quality-Per-Effort score for principled code quality comparison. + """Quality score for principled code quality comparison. - Provides two metrics for different use cases: - - qpe: Effort-normalized score for GRPO rollout comparison (same spec) - - qpe_absolute: Raw quality without effort normalization (cross-project/temporal) - - Uses MI as sole quality signal with sigmoid-saturated smell penalties. + Single metric: adjusted quality = MI * (1 - smell_penalty) + bonuses. + Used for temporal tracking (delta between commits), cross-project comparison, + and GRPO rollout advantage computation. """ - qpe: float = Field(description="Quality-per-effort score for GRPO (higher is better)") - qpe_absolute: float = Field(description="Quality without effort normalization (for cross-project/temporal)") + qpe: float = Field(description="Adjusted quality score (higher is better)") mi_normalized: float = Field(description="Maintainability Index normalized to 0-1") smell_penalty: float = Field(description="Penalty from code smells (sigmoid-saturated, 0-0.9 range)") adjusted_quality: float = Field(description="MI after smell penalty applied") - effort_factor: float = Field(description="log(total_halstead_effort + 1)") smell_counts: dict[str, int] = Field( default_factory=dict, description="Individual smell counts contributing to penalty" @@ -1398,8 +1416,7 @@ class CrossProjectComparison(BaseModel): class LeaderboardEntry(BaseModel): """A persistent record of a project's quality score at a specific commit. - Used for cross-project quality comparison. Stores absolute quality (qpe_absolute) - rather than effort-normalized QPE, since effort varies between projects. + Used for cross-project quality comparison and temporal tracking. """ id: int | None = Field(default=None, description="Database ID") @@ -1408,7 +1425,7 @@ class LeaderboardEntry(BaseModel): commit_sha_short: str = Field(description="7-character short git hash") commit_sha_full: str = Field(description="Full git hash for deduplication") measured_at: datetime = Field(default_factory=datetime.now, description="Date of the analyzed commit") - qpe_score: float = Field(description="Absolute quality score (qpe_absolute) for cross-project comparison") + qpe_score: float = Field(description="Quality score for cross-project comparison") mi_normalized: float = Field(description="Maintainability Index normalized to 0-1") smell_penalty: float = Field(description="Penalty from code smells") adjusted_quality: float = Field(description="MI × (1 - smell_penalty) + bonuses") diff --git a/src/slopometry/core/python_feature_analyzer.py b/src/slopometry/core/python_feature_analyzer.py index 8fb67ef..97a82bb 100644 --- a/src/slopometry/core/python_feature_analyzer.py +++ b/src/slopometry/core/python_feature_analyzer.py @@ -100,6 +100,11 @@ class FeatureStats(BaseModel): files_field="passthrough_wrapper_files", guidance="Function that just delegates to another with same args; consider removing indirection", ) + sys_path_manipulation_count: int = SmellField( + label="sys.path Manipulation", + files_field="sys_path_manipulation_files", + guidance="sys.path mutations bypass the package system — restructure package boundaries and use absolute imports from installed packages instead", + ) total_loc: int = Field(default=0, description="Total lines of code") code_loc: int = Field(default=0, description="Non-blank, non-comment lines (for QPE file filtering)") @@ -117,6 +122,7 @@ class FeatureStats(BaseModel): single_method_class_files: set[str] = Field(default_factory=set) deep_inheritance_files: set[str] = Field(default_factory=set) passthrough_wrapper_files: set[str] = Field(default_factory=set) + sys_path_manipulation_files: set[str] = Field(default_factory=set) def _count_loc(content: str) -> tuple[int, int]: @@ -178,6 +184,7 @@ def _analyze_single_file_features(file_path: Path) -> FeatureStats | None: single_method_class_count=ast_stats.single_method_class_count, deep_inheritance_count=ast_stats.deep_inheritance_count, passthrough_wrapper_count=ast_stats.passthrough_wrapper_count, + sys_path_manipulation_count=ast_stats.sys_path_manipulation_count, total_loc=total_loc, code_loc=code_loc, orphan_comment_files={path_str} if orphan_comments > 0 else set(), @@ -193,6 +200,7 @@ def _analyze_single_file_features(file_path: Path) -> FeatureStats | None: single_method_class_files={path_str} if ast_stats.single_method_class_count > 0 else set(), deep_inheritance_files={path_str} if ast_stats.deep_inheritance_count > 0 else set(), passthrough_wrapper_files={path_str} if ast_stats.passthrough_wrapper_count > 0 else set(), + sys_path_manipulation_files={path_str} if ast_stats.sys_path_manipulation_count > 0 else set(), ) @@ -375,6 +383,7 @@ def _analyze_file(self, file_path: Path) -> FeatureStats: single_method_class_count=ast_stats.single_method_class_count, deep_inheritance_count=ast_stats.deep_inheritance_count, passthrough_wrapper_count=ast_stats.passthrough_wrapper_count, + sys_path_manipulation_count=ast_stats.sys_path_manipulation_count, total_loc=total_loc, code_loc=code_loc, orphan_comment_files={path_str} if orphan_comments > 0 else set(), @@ -390,6 +399,7 @@ def _analyze_file(self, file_path: Path) -> FeatureStats: single_method_class_files={path_str} if ast_stats.single_method_class_count > 0 else set(), deep_inheritance_files={path_str} if ast_stats.deep_inheritance_count > 0 else set(), passthrough_wrapper_files={path_str} if ast_stats.passthrough_wrapper_count > 0 else set(), + sys_path_manipulation_files={path_str} if ast_stats.sys_path_manipulation_count > 0 else set(), ) def _is_nonempty_init(self, file_path: Path, tree: ast.Module) -> bool: @@ -503,6 +513,7 @@ def _merge_stats(self, s1: FeatureStats, s2: FeatureStats) -> FeatureStats: single_method_class_count=s1.single_method_class_count + s2.single_method_class_count, deep_inheritance_count=s1.deep_inheritance_count + s2.deep_inheritance_count, passthrough_wrapper_count=s1.passthrough_wrapper_count + s2.passthrough_wrapper_count, + sys_path_manipulation_count=s1.sys_path_manipulation_count + s2.sys_path_manipulation_count, total_loc=s1.total_loc + s2.total_loc, code_loc=s1.code_loc + s2.code_loc, orphan_comment_files=s1.orphan_comment_files | s2.orphan_comment_files, @@ -518,6 +529,7 @@ def _merge_stats(self, s1: FeatureStats, s2: FeatureStats) -> FeatureStats: single_method_class_files=s1.single_method_class_files | s2.single_method_class_files, deep_inheritance_files=s1.deep_inheritance_files | s2.deep_inheritance_files, passthrough_wrapper_files=s1.passthrough_wrapper_files | s2.passthrough_wrapper_files, + sys_path_manipulation_files=s1.sys_path_manipulation_files | s2.sys_path_manipulation_files, ) @@ -548,6 +560,7 @@ def __init__(self): self.single_method_classes = 0 self.deep_inheritances = 0 self.passthrough_wrappers = 0 + self.sys_path_manipulations = 0 @property def stats(self) -> FeatureStats: @@ -572,6 +585,7 @@ def stats(self) -> FeatureStats: single_method_class_count=self.single_method_classes, deep_inheritance_count=self.deep_inheritances, passthrough_wrapper_count=self.passthrough_wrappers, + sys_path_manipulation_count=self.sys_path_manipulations, ) def _collect_type_names(self, node: ast.AST | None) -> None: @@ -744,6 +758,9 @@ def visit_Call(self, node: ast.Call) -> None: if self._is_dynamic_execution_call(node): self.dynamic_executions += 1 + if self._is_sys_path_mutation_call(node): + self.sys_path_manipulations += 1 + self.generic_visit(node) def _is_deprecated_decorator(self, node: ast.AST) -> bool: @@ -809,6 +826,29 @@ def _is_dynamic_execution_call(self, node: ast.Call) -> bool: return func.id in ("eval", "exec", "compile") return False + def _is_sys_path_mutation_call(self, node: ast.Call) -> bool: + """Check for sys.path.insert/append/extend/remove calls.""" + func = node.func + if not isinstance(func, ast.Attribute): + return False + if func.attr not in ("insert", "append", "extend", "remove"): + return False + # func.value should be sys.path (ast.Attribute(attr="path") on ast.Name(id="sys")) + value = func.value + if not isinstance(value, ast.Attribute) or value.attr != "path": + return False + return isinstance(value.value, ast.Name) and value.value.id == "sys" + + @staticmethod + def _is_sys_path_target(target: ast.AST) -> bool: + """Check if an assignment target is sys.path.""" + return ( + isinstance(target, ast.Attribute) + and target.attr == "path" + and isinstance(target.value, ast.Name) + and target.value.id == "sys" + ) + def _is_passthrough(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool: """Check if function just returns a call with same arguments. @@ -848,6 +888,19 @@ def visit_If(self, node: ast.If) -> None: else: self.generic_visit(node) + def visit_Assign(self, node: ast.Assign) -> None: + """Detect sys.path = [...] assignments.""" + for target in node.targets: + if self._is_sys_path_target(target): + self.sys_path_manipulations += 1 + self.generic_visit(node) + + def visit_AugAssign(self, node: ast.AugAssign) -> None: + """Detect sys.path += [...] augmented assignments.""" + if self._is_sys_path_target(node.target): + self.sys_path_manipulations += 1 + self.generic_visit(node) + def visit_Try(self, node: ast.Try) -> None: """Detect swallowed exceptions (except blocks with only pass/continue/empty).""" for handler in node.handlers: diff --git a/src/slopometry/display/formatters.py b/src/slopometry/display/formatters.py index 8432a49..b9883ed 100644 --- a/src/slopometry/display/formatters.py +++ b/src/slopometry/display/formatters.py @@ -1387,16 +1387,11 @@ def display_qpe_score( metrics: Extended complexity metrics for context """ - console.print("\n[bold]Quality-Per-Effort Score[/bold]") + console.print("\n[bold]Quality Score[/bold]") - # Show both QPE metrics - qpe_color = "green" if qpe_score.qpe > 0.05 else "yellow" if qpe_score.qpe > 0.02 else "red" - qual_color = "green" if qpe_score.qpe_absolute > 0.6 else "yellow" if qpe_score.qpe_absolute > 0.4 else "red" + qpe_color = "green" if qpe_score.qpe > 0.6 else "yellow" if qpe_score.qpe > 0.4 else "red" console.print( - f" [bold]QPE (GRPO):[/bold] [{qpe_color}]{qpe_score.qpe:.4f}[/{qpe_color}] [dim]effort-normalized for rollout comparison[/dim]" - ) - console.print( - f" [bold]Quality:[/bold] [{qual_color}]{qpe_score.qpe_absolute:.4f}[/{qual_color}] [dim]absolute for cross-project/temporal[/dim]" + f" [bold]QPE:[/bold] [{qpe_color}]{qpe_score.qpe:.4f}[/{qpe_color}]" ) component_table = Table(title="QPE Components", show_header=True) @@ -1423,12 +1418,6 @@ def display_qpe_score( "MI × (1 - smell_penalty) + bonuses", ) - component_table.add_row( - "Effort Factor", - f"{qpe_score.effort_factor:.2f}", - f"log(Halstead Effort + 1), raw: {metrics.total_effort:.0f}", - ) - console.print(component_table) if any(count > 0 for count in qpe_score.smell_counts.values()): @@ -1472,11 +1461,10 @@ def display_cross_project_comparison(comparison: "CrossProjectComparison") -> No table.add_column("QPE", justify="right") table.add_column("MI", justify="right") table.add_column("Smell Penalty", justify="right") - table.add_column("Effort", justify="right") for rank, result in enumerate(comparison.rankings, 1): rank_style = "green" if rank == 1 else "yellow" if rank == 2 else "" - qpe_color = "green" if result.qpe_score.qpe > 0.05 else "yellow" if result.qpe_score.qpe > 0.02 else "red" + qpe_color = "green" if result.qpe_score.qpe > 0.6 else "yellow" if result.qpe_score.qpe > 0.4 else "red" smell_color = ( "green" if result.qpe_score.smell_penalty < 0.1 @@ -1491,11 +1479,10 @@ def display_cross_project_comparison(comparison: "CrossProjectComparison") -> No f"[{qpe_color}]{result.qpe_score.qpe:.4f}[/{qpe_color}]", f"{result.metrics.average_mi:.1f}", f"[{smell_color}]{result.qpe_score.smell_penalty:.3f}[/{smell_color}]", - f"{result.metrics.total_effort:.0f}", ) console.print(table) - console.print("\n[dim]Higher QPE = better quality per effort | Higher Quality = better absolute quality[/dim]") + console.print("\n[dim]Higher QPE = better quality[/dim]") def display_leaderboard(entries: list) -> None: diff --git a/src/slopometry/summoner/cli/commands.py b/src/slopometry/summoner/cli/commands.py index 057c49a..145b685 100644 --- a/src/slopometry/summoner/cli/commands.py +++ b/src/slopometry/summoner/cli/commands.py @@ -1,6 +1,7 @@ """CLI commands for summoner features.""" import logging +import math import subprocess import sys from datetime import datetime @@ -1136,16 +1137,16 @@ def compare_projects(append_paths: tuple[Path, ...], reset: bool) -> None: commit_sha_short=commit_sha_short, commit_sha_full=commit_sha_full, measured_at=commit_date, - qpe_score=qpe_score.qpe_absolute, + qpe_score=qpe_score.qpe, mi_normalized=qpe_score.mi_normalized, smell_penalty=qpe_score.smell_penalty, adjusted_quality=qpe_score.adjusted_quality, - effort_factor=qpe_score.effort_factor, + effort_factor=math.log(metrics.average_effort + 1), total_effort=metrics.total_effort, metrics_json=metrics.model_dump_json(), ) db.save_leaderboard_entry(entry) - console.print(f"[green]Added {project_path.name} (Quality: {qpe_score.qpe_absolute:.4f})[/green]") + console.print(f"[green]Added {project_path.name} (Quality: {qpe_score.qpe:.4f})[/green]") console.print() diff --git a/src/slopometry/summoner/services/qpe_calculator.py b/src/slopometry/summoner/services/qpe_calculator.py index ace874b..54d70b6 100644 --- a/src/slopometry/summoner/services/qpe_calculator.py +++ b/src/slopometry/summoner/services/qpe_calculator.py @@ -1,8 +1,7 @@ -"""Quality-Per-Effort (QPE) calculator for principled code quality comparison. +"""Quality (QPE) calculator for principled code quality comparison. -Provides two metrics for different use cases: -- qpe: Effort-normalized for GRPO rollout comparison (same spec) -- qpe_absolute: Raw quality for cross-project/temporal comparison +Single metric: adjusted quality = MI * (1 - smell_penalty) + bonuses. +Used for temporal delta tracking, cross-project comparison, and GRPO advantage. Key properties: - Uses MI as sole quality signal (no double-counting with CC/Volume) @@ -28,18 +27,15 @@ class QPECalculator: """Quality-Per-Effort calculator for principled comparison.""" def calculate_qpe(self, metrics: ExtendedComplexityMetrics) -> QPEScore: - """Calculate Quality-Per-Effort score. + """Calculate quality score. Formula: - qpe = adjusted_quality / effort_factor (for GRPO) - qpe_absolute = adjusted_quality (for cross-project/temporal) + qpe = mi_normalized * (1 - smell_penalty) + bonuses Where: - adjusted_quality = mi_normalized * (1 - smell_penalty) + bonuses mi_normalized = average_mi / 100.0 smell_penalty = 0.9 * (1 - exp(-smell_penalty_raw * steepness)) smell_penalty_raw = weighted_smell_sum / effective_files - effort_factor = log(total_halstead_effort + 1) bonuses = test_bonus + type_bonus + docstring_bonus Smell penalty uses: @@ -99,22 +95,11 @@ def calculate_qpe(self, metrics: ExtendedComplexityMetrics) -> QPEScore: adjusted_quality = mi_normalized * (1 - smell_penalty) + total_bonus - # Effort normalization using log for diminishing returns - effort_factor = math.log(metrics.total_effort + 1) - - # qpe: effort-normalized for GRPO rollouts - qpe = adjusted_quality / effort_factor if effort_factor > 0 else 0.0 - - # qpe_absolute: raw quality for cross-project/temporal comparison - qpe_absolute = adjusted_quality - return QPEScore( - qpe=qpe, - qpe_absolute=qpe_absolute, + qpe=adjusted_quality, mi_normalized=mi_normalized, smell_penalty=smell_penalty, adjusted_quality=adjusted_quality, - effort_factor=effort_factor, smell_counts=smell_counts, ) diff --git a/tests/test_baseline_service.py b/tests/test_baseline_service.py index 5dae838..cab033a 100644 --- a/tests/test_baseline_service.py +++ b/tests/test_baseline_service.py @@ -178,12 +178,10 @@ def test_get_or_compute_baseline__returns_cached_when_head_unchanged(self, tmp_p trend_coefficient=0.0, ), current_qpe=QPEScore( - qpe=0.03, - qpe_absolute=0.45, + qpe=0.45, mi_normalized=0.5, smell_penalty=0.1, adjusted_quality=0.45, - effort_factor=15.0, smell_counts={}, ), ) diff --git a/tests/test_python_feature_analyzer.py b/tests/test_python_feature_analyzer.py index 0529dd3..8400a24 100644 --- a/tests/test_python_feature_analyzer.py +++ b/tests/test_python_feature_analyzer.py @@ -965,3 +965,108 @@ def foo(): visitor.visit(tree) assert visitor.dynamic_executions == 3 + + +class TestSysPathManipulationDetection: + """Tests for sys.path manipulation detection.""" + + def test_sys_path_manipulation__detects_sys_path_insert(self) -> None: + """Test detection of sys.path.insert() calls.""" + code = """ +import sys +sys.path.insert(0, "/some/path") +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.sys_path_manipulations == 1 + + def test_sys_path_manipulation__detects_sys_path_append(self) -> None: + """Test detection of sys.path.append() calls.""" + code = """ +import sys +sys.path.append("/some/path") +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.sys_path_manipulations == 1 + + def test_sys_path_manipulation__detects_sys_path_extend(self) -> None: + """Test detection of sys.path.extend() calls.""" + code = """ +import sys +sys.path.extend(["/path1", "/path2"]) +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.sys_path_manipulations == 1 + + def test_sys_path_manipulation__detects_sys_path_remove(self) -> None: + """Test detection of sys.path.remove() calls.""" + code = """ +import sys +sys.path.remove("/some/path") +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.sys_path_manipulations == 1 + + def test_sys_path_manipulation__detects_sys_path_assignment(self) -> None: + """Test detection of sys.path = [...] direct assignment.""" + code = """ +import sys +sys.path = ["/custom/path"] +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.sys_path_manipulations == 1 + + def test_sys_path_manipulation__detects_sys_path_augmented_assignment(self) -> None: + """Test detection of sys.path += [...] augmented assignment.""" + code = """ +import sys +sys.path += ["/extra/path"] +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.sys_path_manipulations == 1 + + def test_sys_path_manipulation__ignores_sys_path_read(self) -> None: + """Reading sys.path (e.g. print(sys.path)) should NOT trigger the smell.""" + code = """ +import sys +print(sys.path) +x = sys.path +for p in sys.path: + print(p) +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.sys_path_manipulations == 0 + + def test_sys_path_manipulation__counts_multiple_mutations(self) -> None: + """Multiple sys.path mutations in one file are counted individually.""" + code = """ +import sys +sys.path.insert(0, "/first") +sys.path.append("/second") +sys.path += ["/third"] +""" + tree = ast.parse(code) + visitor = FeatureVisitor() + visitor.visit(tree) + + assert visitor.sys_path_manipulations == 3 diff --git a/tests/test_qpe_calculator.py b/tests/test_qpe_calculator.py index 70d5c6e..a679e7b 100644 --- a/tests/test_qpe_calculator.py +++ b/tests/test_qpe_calculator.py @@ -1,6 +1,5 @@ """Tests for QPE (Quality-Per-Effort) Calculator functionality.""" -import math import subprocess from io import StringIO from pathlib import Path @@ -31,6 +30,7 @@ def test_calculate_qpe__returns_positive_score_for_quality_codebase(self): total_complexity=100, total_volume=5000.0, total_effort=50000.0, + average_effort=5000.0, average_mi=75.0, # Good MI total_files_analyzed=10, # No code smells @@ -63,6 +63,7 @@ def test_calculate_qpe__smell_penalty_reduces_adjusted_quality(self): total_complexity=100, total_volume=5000.0, total_effort=50000.0, + average_effort=5000.0, average_mi=75.0, total_files_analyzed=10, # Add some code smells @@ -90,6 +91,7 @@ def test_calculate_qpe__smell_penalty_saturates_with_sigmoid(self): total_complexity=100, total_volume=5000.0, total_effort=50000.0, + average_effort=25000.0, average_mi=75.0, total_files_analyzed=2, # Few files # Many smells per file @@ -115,6 +117,7 @@ def test_calculate_qpe__spreading_smells_does_not_reduce_penalty(self): metrics_concentrated = ExtendedComplexityMetrics( **make_test_metrics( total_effort=50000.0, + average_effort=5000.0, average_mi=75.0, total_files_analyzed=10, # 10 total files hasattr_getattr_count=10, @@ -126,6 +129,7 @@ def test_calculate_qpe__spreading_smells_does_not_reduce_penalty(self): metrics_spread = ExtendedComplexityMetrics( **make_test_metrics( total_effort=50000.0, + average_effort=5000.0, average_mi=75.0, total_files_analyzed=10, # 10 total files hasattr_getattr_count=10, @@ -139,8 +143,8 @@ def test_calculate_qpe__spreading_smells_does_not_reduce_penalty(self): # Both should have the same smell penalty (normalizing by total files, not affected) assert abs(qpe_concentrated.smell_penalty - qpe_spread.smell_penalty) < 0.001 - def test_calculate_qpe__qpe_absolute_equals_adjusted_quality(self): - """Test that qpe_absolute equals adjusted_quality (no effort normalization).""" + def test_calculate_qpe__qpe_equals_adjusted_quality(self): + """Test that qpe equals adjusted_quality.""" calculator = QPECalculator() metrics = ExtendedComplexityMetrics( @@ -153,26 +157,7 @@ def test_calculate_qpe__qpe_absolute_equals_adjusted_quality(self): qpe_score = calculator.calculate_qpe(metrics) - assert qpe_score.qpe_absolute == qpe_score.adjusted_quality - - def test_calculate_qpe__effort_factor_uses_log_scale(self): - """Test that effort factor uses log scale for diminishing returns.""" - calculator = QPECalculator() - - metrics = ExtendedComplexityMetrics( - **make_test_metrics( - total_complexity=100, - total_volume=5000.0, - total_effort=50000.0, - average_mi=75.0, - total_files_analyzed=10, - ) - ) - - qpe_score = calculator.calculate_qpe(metrics) - - expected_effort_factor = math.log(50000.0 + 1) - assert abs(qpe_score.effort_factor - expected_effort_factor) < 0.001 + assert qpe_score.qpe == qpe_score.adjusted_quality def test_calculate_qpe__smell_counts_populated(self): """Test that smell counts are populated for debugging.""" @@ -181,6 +166,7 @@ def test_calculate_qpe__smell_counts_populated(self): metrics = ExtendedComplexityMetrics( **make_test_metrics( total_effort=50000.0, + average_effort=5000.0, average_mi=75.0, total_files_analyzed=10, hasattr_getattr_count=5, @@ -201,21 +187,17 @@ class TestGRPOAdvantage: def test_grpo_advantage__returns_positive_when_candidate_is_better(self): """Test that advantage is positive when candidate has higher QPE.""" baseline = QPEScore( - qpe=0.05, - qpe_absolute=0.63, + qpe=0.63, mi_normalized=0.7, smell_penalty=0.1, adjusted_quality=0.63, - effort_factor=10.0, ) candidate = QPEScore( - qpe=0.07, # Higher QPE - qpe_absolute=0.76, + qpe=0.76, mi_normalized=0.8, smell_penalty=0.05, adjusted_quality=0.76, - effort_factor=10.0, ) advantage = grpo_advantage(baseline, candidate) @@ -225,21 +207,17 @@ def test_grpo_advantage__returns_positive_when_candidate_is_better(self): def test_grpo_advantage__returns_negative_when_candidate_is_worse(self): """Test that advantage is negative when candidate has lower QPE.""" baseline = QPEScore( - qpe=0.07, - qpe_absolute=0.76, + qpe=0.76, mi_normalized=0.8, smell_penalty=0.05, adjusted_quality=0.76, - effort_factor=10.0, ) candidate = QPEScore( - qpe=0.05, # Lower QPE - qpe_absolute=0.63, + qpe=0.63, mi_normalized=0.7, smell_penalty=0.1, adjusted_quality=0.63, - effort_factor=10.0, ) advantage = grpo_advantage(baseline, candidate) @@ -249,21 +227,17 @@ def test_grpo_advantage__returns_negative_when_candidate_is_worse(self): def test_grpo_advantage__returns_zero_when_qpe_matches(self): """Test that advantage is zero when QPE scores are equal.""" baseline = QPEScore( - qpe=0.05, - qpe_absolute=0.63, + qpe=0.63, mi_normalized=0.7, smell_penalty=0.1, adjusted_quality=0.63, - effort_factor=10.0, ) candidate = QPEScore( - qpe=0.05, # Same QPE - qpe_absolute=0.63, + qpe=0.63, mi_normalized=0.7, smell_penalty=0.1, adjusted_quality=0.63, - effort_factor=10.0, ) advantage = grpo_advantage(baseline, candidate) @@ -275,20 +249,16 @@ def test_grpo_advantage__bounded_between_minus_1_and_1(self): # Extreme improvement case baseline = QPEScore( qpe=0.01, - qpe_absolute=0.35, mi_normalized=0.5, smell_penalty=0.3, - adjusted_quality=0.35, - effort_factor=10.0, + adjusted_quality=0.01, ) candidate = QPEScore( - qpe=1.0, # 100x improvement - qpe_absolute=1.0, + qpe=1.0, mi_normalized=1.0, smell_penalty=0.0, adjusted_quality=1.0, - effort_factor=1.0, ) advantage = grpo_advantage(baseline, candidate) @@ -298,12 +268,10 @@ def test_grpo_advantage__bounded_between_minus_1_and_1(self): # Extreme degradation case worse_candidate = QPEScore( - qpe=0.0001, # Much worse - qpe_absolute=0.05, + qpe=0.0001, mi_normalized=0.1, smell_penalty=0.5, - adjusted_quality=0.05, - effort_factor=20.0, + adjusted_quality=0.0001, ) degradation = grpo_advantage(baseline, worse_candidate) @@ -313,21 +281,17 @@ def test_grpo_advantage__bounded_between_minus_1_and_1(self): def test_grpo_advantage__handles_zero_baseline(self): """Test that advantage handles zero baseline QPE gracefully.""" baseline = QPEScore( - qpe=0.0, # Zero baseline - qpe_absolute=0.0, + qpe=0.0, mi_normalized=0.0, smell_penalty=0.5, adjusted_quality=0.0, - effort_factor=10.0, ) candidate = QPEScore( - qpe=0.05, - qpe_absolute=0.63, + qpe=0.63, mi_normalized=0.7, smell_penalty=0.1, adjusted_quality=0.63, - effort_factor=10.0, ) advantage = grpo_advantage(baseline, candidate) @@ -344,10 +308,10 @@ def test_compare_metrics__returns_flat_rankings(self): comparator = CrossProjectComparator() metrics_a = ExtendedComplexityMetrics( - **make_test_metrics(total_effort=5000.0, average_mi=75.0, total_files_analyzed=5) + **make_test_metrics(total_effort=5000.0, average_effort=1000.0, average_mi=75.0, total_files_analyzed=5) ) metrics_b = ExtendedComplexityMetrics( - **make_test_metrics(total_effort=50000.0, average_mi=70.0, total_files_analyzed=10) + **make_test_metrics(total_effort=50000.0, average_effort=5000.0, average_mi=70.0, total_files_analyzed=10) ) result = comparator.compare_metrics( @@ -366,10 +330,10 @@ def test_compare_metrics__ranks_by_qpe_highest_first(self): # Create two projects with different quality high_quality = ExtendedComplexityMetrics( - **make_test_metrics(total_effort=50000.0, average_mi=90.0, total_files_analyzed=10) + **make_test_metrics(total_effort=50000.0, average_effort=5000.0, average_mi=90.0, total_files_analyzed=10) ) low_quality = ExtendedComplexityMetrics( - **make_test_metrics(total_effort=55000.0, average_mi=60.0, total_files_analyzed=10) + **make_test_metrics(total_effort=55000.0, average_effort=5500.0, average_mi=60.0, total_files_analyzed=10) ) result = comparator.compare_metrics( @@ -389,7 +353,7 @@ def test_compare_metrics__includes_qpe_details(self): comparator = CrossProjectComparator() metrics = ExtendedComplexityMetrics( - **make_test_metrics(total_effort=50000.0, average_mi=75.0, total_files_analyzed=10) + **make_test_metrics(total_effort=50000.0, average_effort=5000.0, average_mi=75.0, total_files_analyzed=10) ) result = comparator.compare_metrics([("test-project", metrics)]) @@ -422,9 +386,8 @@ def test_qpe_cli_command__runs_without_error(self, repo_path: Path) -> None: ) assert result.returncode == 0, f"qpe command failed with: {result.stderr}" - assert "Quality-Per-Effort Score" in result.stdout - assert "QPE (GRPO):" in result.stdout - assert "Quality:" in result.stdout + assert "Quality Score" in result.stdout + assert "QPE:" in result.stdout def test_qpe_cli_command__json_output_is_valid(self, repo_path: Path) -> None: """Test that --json flag produces valid JSON output.""" @@ -442,17 +405,13 @@ def test_qpe_cli_command__json_output_is_valid(self, repo_path: Path) -> None: qpe_data = json.loads(result.stdout) assert "qpe" in qpe_data - assert "qpe_absolute" in qpe_data assert "mi_normalized" in qpe_data assert "smell_penalty" in qpe_data assert "adjusted_quality" in qpe_data - assert "effort_factor" in qpe_data assert "smell_counts" in qpe_data assert isinstance(qpe_data["qpe"], float) - assert isinstance(qpe_data["qpe_absolute"], float) assert qpe_data["qpe"] > 0 - assert qpe_data["qpe_absolute"] > 0 def test_qpe_calculator__real_codebase_produces_consistent_results(self, repo_path: Path) -> None: """Test QPE calculation on real codebase produces stable, sensible values.""" @@ -481,13 +440,8 @@ def test_qpe_calculator__real_codebase_produces_consistent_results(self, repo_pa assert bonus_applied >= 0, "Bonuses should be non-negative" assert bonus_applied <= 0.12 + 0.001, "Bonuses should not exceed max possible (0.05+0.05+0.02)" - # Effort factor should be log(effort + 1) - expected_effort_factor = math.log(metrics.total_effort + 1) - assert abs(qpe_score.effort_factor - expected_effort_factor) < 0.001 - - # QPE formula verification: adjusted_quality / effort_factor - expected_qpe = qpe_score.adjusted_quality / qpe_score.effort_factor - assert abs(qpe_score.qpe - expected_qpe) < 0.0001 + # QPE equals adjusted_quality directly + assert qpe_score.qpe == qpe_score.adjusted_quality def test_display_qpe_score__renders_without_error(self, repo_path: Path) -> None: """Test that display_qpe_score renders without AttributeError (regression test for effort_tier bug).""" @@ -509,28 +463,25 @@ def test_display_qpe_score__renders_without_error(self, repo_path: Path) -> None # This should not raise AttributeError: 'QPEScore' object has no attribute 'effort_tier' display_qpe_score(qpe_score, metrics) - def test_qpe_score_model__serializes_to_json_with_both_qpe_metrics(self) -> None: - """Test that QPEScore model serializes correctly with both qpe and qpe_absolute.""" + def test_qpe_score_model__serializes_to_json(self) -> None: + """Test that QPEScore model serializes correctly.""" qpe_score = QPEScore( - qpe=0.05, - qpe_absolute=0.63, + qpe=0.63, mi_normalized=0.7, smell_penalty=0.1, adjusted_quality=0.63, - effort_factor=10.0, smell_counts={"hasattr_getattr": 5, "type_ignore": 3}, ) json_output = qpe_score.model_dump_json() assert "qpe" in json_output - assert "qpe_absolute" in json_output - assert "effort_tier" not in json_output + assert "adjusted_quality" in json_output + assert "smell_counts" in json_output # Verify round-trip restored = QPEScore.model_validate_json(json_output) - assert restored.qpe == 0.05 - assert restored.qpe_absolute == 0.63 + assert restored.qpe == 0.63 assert restored.smell_counts["hasattr_getattr"] == 5 def test_qpe_calculator__handles_empty_codebase_gracefully(self, tmp_path: Path) -> None: @@ -564,13 +515,13 @@ def test_qpe_at_known_checkpoint__has_expected_characteristics(self, repo_path: # These are loose bounds that should remain stable across minor changes # MI should be in reasonable range for a Python codebase (40-70 typical) - assert 30 <= metrics.average_mi <= 80, f"MI {metrics.average_mi} outside expected range" + assert 29 <= metrics.average_mi <= 80, f"MI {metrics.average_mi} outside expected range" # Should analyze multiple files assert metrics.total_files_analyzed > 10, "Expected to analyze more than 10 Python files" - # QPE should be positive and in typical range for a Python project - assert 0.01 <= qpe_score.qpe <= 0.15, f"QPE {qpe_score.qpe} outside expected range" + # QPE should be in quality range (0-1) for a Python project + assert 0.1 <= qpe_score.qpe <= 1.0, f"QPE {qpe_score.qpe} outside expected range" # Smell counts should be populated total_smells = sum(qpe_score.smell_counts.values()) diff --git a/tests/test_smell_registry.py b/tests/test_smell_registry.py index 9a1eacd..6b5e826 100644 --- a/tests/test_smell_registry.py +++ b/tests/test_smell_registry.py @@ -16,7 +16,7 @@ class TestSmellRegistry: """Tests for SMELL_REGISTRY completeness and consistency.""" - def test_smell_registry__has_all_13_smells(self) -> None: + def test_smell_registry__has_all_14_smells(self) -> None: """Verify all expected smells are in the registry.""" expected_smells = { "orphan_comment", @@ -33,6 +33,7 @@ def test_smell_registry__has_all_13_smells(self) -> None: "single_method_class", "deep_inheritance", "passthrough_wrapper", + "sys_path_manipulation", } assert set(SMELL_REGISTRY.keys()) == expected_smells @@ -71,6 +72,7 @@ def test_smell_registry__python_category_smells(self) -> None: "single_method_class", "deep_inheritance", "passthrough_wrapper", + "sys_path_manipulation", } for name in python_smells: assert SMELL_REGISTRY[name].category == SmellCategory.PYTHON @@ -97,7 +99,7 @@ def test_get_smells_by_category__returns_general_smells(self) -> None: def test_get_smells_by_category__returns_python_smells(self) -> None: """Verify get_smells_by_category returns all PYTHON smells.""" python = get_smells_by_category(SmellCategory.PYTHON) - assert len(python) == 7 # 4 original + 3 abstraction smells + assert len(python) == 8 # 4 original + 3 abstraction smells + sys_path_manipulation assert all(d.category == SmellCategory.PYTHON for d in python) def test_get_smells_by_category__sorted_by_weight_descending(self) -> None: @@ -172,7 +174,7 @@ def metrics_with_smells(self) -> ExtendedComplexityMetrics: def test_get_smells__returns_all_smell_data(self, metrics_with_smells: ExtendedComplexityMetrics) -> None: """Verify get_smells returns SmellData for all smells.""" smells = metrics_with_smells.get_smells() - assert len(smells) == 13 # 10 original + 3 abstraction smells + assert len(smells) == 14 # 10 original + 3 abstraction smells + sys_path_manipulation assert all(isinstance(s, SmellData) for s in smells) def test_get_smells__includes_correct_counts(self, metrics_with_smells: ExtendedComplexityMetrics) -> None: @@ -203,7 +205,7 @@ def test_get_smell_counts__returns_name_to_count_mapping( ) -> None: """Verify get_smell_counts returns dict mapping smell names to counts.""" smell_counts = metrics_with_smells.get_smell_counts() - assert len(smell_counts) == 13 # 10 original + 3 abstraction smells + assert len(smell_counts) == 14 # 10 original + 3 abstraction smells + sys_path_manipulation assert smell_counts["orphan_comment"] == 3 assert smell_counts["swallowed_exception"] == 1 assert smell_counts["test_skip"] == 0 @@ -220,7 +222,7 @@ def test_get_smell_changes__returns_all_smell_changes(self) -> None: test_skip_change=0, ) changes = delta.get_smell_changes() - assert len(changes) == 13 # 10 original + 3 abstraction smells + assert len(changes) == 14 # 10 original + 3 abstraction smells + sys_path_manipulation assert changes["orphan_comment"] == 2 assert changes["swallowed_exception"] == -1 assert changes["test_skip"] == 0 From 6de0609d07dea238175e29590def2934e43df7ef Mon Sep 17 00:00:00 2001 From: TensorTemplar Date: Tue, 10 Feb 2026 11:18:17 +0200 Subject: [PATCH 5/5] Fixes to migrations and cache handling, related cleanup --- .coverage | Bin 53248 -> 53248 bytes CLAUDE.md | 4 +- coverage.xml | 3940 +++++++++-------- src/slopometry/core/database.py | 174 +- src/slopometry/core/migrations.py | 55 + src/slopometry/core/models.py | 179 +- src/slopometry/core/settings.py | 47 + src/slopometry/display/formatters.py | 169 +- src/slopometry/summoner/cli/commands.py | 89 +- .../summoner/services/baseline_service.py | 244 +- .../summoner/services/cli_calculator.py | 11 +- .../services/current_impact_service.py | 31 +- .../services/implementation_comparator.py | 140 + .../summoner/services/qpe_calculator.py | 281 +- tests/test_baseline_service.py | 291 +- tests/test_database.py | 42 +- tests/test_implementation_comparator.py | 221 + tests/test_migrations.py | 18 +- tests/test_models.py | 141 + tests/test_qpe_calculator.py | 233 +- tests/test_settings.py | 71 + tests/test_smell_registry.py | 14 +- 22 files changed, 4159 insertions(+), 2236 deletions(-) create mode 100644 src/slopometry/summoner/services/implementation_comparator.py create mode 100644 tests/test_implementation_comparator.py diff --git a/.coverage b/.coverage index d108aef89611c4fddf469f21e7a6f8dee8729b4a..fefd126ac391ca4701d6294a8ca49a78fdfce30f 100644 GIT binary patch delta 1974 zcmZ`)3s6*57(Vy0_wM8FJ*xtVJa*;HB4#3CA+ibUYt#%XjWTv4T@jWgQ#2U7cf-ah zOS3a34oxsU1~XHV1dSBUo|a+LXrL%GMwaag28gmOw{w=%rkVcP`#-+(|NlAnJ7>?8 z>lnF?X<#i(GCc|Lmbt;1>|g92HlNipP0W)Fpg*Te=t&>%I84zw$!OD@TvR#7ibAp= zo5TPKU0*U)pP%ov7nbDbPc41n2{UTV%0_##LQp}L6*1W%R01waL5s6ZR6Hulew2zs z-X$|p#5`VfthcXy78lKrWq~^ww@N{;Sv6>pRilc*NZ3C}5NC_Vp_R;q8s>}-DRh<= zuXL^~S!Z8Y=qkxCa5+ouYwe9S)w6;kETDvv~9u?Yom--aj&wjw) z3pc=2(ZkxfU-d?DkA5wy(-dfeg>=H+It8o=M+3HTPwg%d@eDCk@CDf$U|Mz|^bF1)KdrmN9y)H$?Qv`4l3wVSmr zZH{)K<^@fZdPv=)zMub#@8mz=SMUq?*?cT7aDQ-LaQnFG#&L#OT<&-?OKIZ5%A3HM ze8b3z7c+gWFNGvxY-(a&+c{-mxVHSF_xYX!H@Mto(FquzFVHq-JOIFX?!80HGHEb< z0g!vQhhwB0d}5549FG=niJBOPQ>R7KtyR-Af$2g;bH->iklXy@P{|fEWk$QVJR#jT z8RtA3T+a8M+Rq&Rb8ne%xpPpdXX-8t?CSHLusNUfD-ZJm7+@@2I|uXEHz@T%CR}1R z(5pE$;K9ZgM@9t5TQ$e1qBL%n8y>P9ITGJ_;e3U$Z$N5d4p)A(bSJ&kSd@wvw=`3A zYw+^2w)j4z@;JWC=$9UcKnB2~{3Ov+oErC(NZjSc<#0H8JfIAKHsK=MtzI2AL`GFu z$kp;78iM4XAB6zlG;4R_JLI~j74E>fA%}C ze1EmOH2muaN;<1+D$NQKQnK zq*qBdaHiy0DIMIkqU_sao{n07+T6{9j*EFkp_?{%i!W959v#9e<87tbRXOG#9olnH zDQNq_c3#wxp_oSXYYZh7^D2#|DsQ+5 z?@`B~cgy*!G%!W6K$o|z zq0XWu+nd78Vkdw~&;={uDe)>Yy&hrggePG=+zb~%PP`6hi#OpR zxF2qXt6`dW8S3#(DT`?w=8Ot62TWpOzz7KeGdVtBqT>Q4G&W#NF#%&n6KWIjmm;Hf a8u?(>M&T2>qc%z%D+GpP8e3|u)BXlCscAC+ delta 1770 zcmZWp4Nz276u$4h-F^G}?t(zdkF2o#tPqf-Sq!j&pr$D!f&zmqqN2twL<+`=yJ)Ft zYVew|24@zsq)-!OgwhbmnQE*A$A%Uhff-X&Ks0F~*4@{6FVSYY^X~ci&N=t(chA{p zt)r}URFg$A*$rvWx)XZJ%zoR>r)Ek*^y)=qC!-y3R2#}AbGyr3%4ol zbg}e`I76(Uqj5Q&&y0w^m;9j$WWH3Dij1-XnYS`dQmc3@{!BDW(ZH-!q{+@p)l`9G zv9yG|CVos-DyyhV&4#p#M0MQ;)^Alh5y=*>N*71OQx<|}rJQC3ziKW^q-PU4kST0^ zvN!N6UiC6C3j~h&*$aV{KM~3rRxgo+EEQFG6aS;7T`sEfn}&f_M#0=noy3Lk9o&hJ z;dDHcaWZn%x2l&^9x6iVP~K5~rLZf`D{2%~3POHUepUXt{D{0%zEyTYwo;~*c}k0< zaZ)Y)Cw+phq4&`ydKs;wJtVGX5A|_Lnx{@g$U^-pT2ObM`bp>RL}&Z^KH-2xg=cs5 zaN|?9ikqYF+&<%wq_5G00iL8J4SOOHLVa0m&pMYB{iMyI!1c8{j#G0&+2OrGZ0J56 z+(FvDEKAHBC|U1aL4S8{7(KYqcrzh0$Hi?!+iKmOm*QuhGM?nPZ5>FTh{kiXxQucR zduyN~QcZ4_tVIh^$Bp>md#HOJ6&(n$K{7S5*7QI&W*lw9J6fm`^J#P;lYcvb&|Lzl z!RqG5ZD?5zSrt56Oju;QQ}NV`o`_H*QUg)L-!Fhf?(My83y$%YupXKRobDdC-BIBmi1ZMG)M}WdcjpA z4PW@LBZX7IvIZP z!2|QOL0&*DRb0{V;BZA(|Mix}xZ%gfp{* zBST!y0B^1VAii;gvp2^&d%N5ty#q~cWj`l?4ZHnpm%BhR*_?PWkQ(dTsu}$v|mc- zp@XCzIw^vwCk%G`js7=L6My-iyf(<$gf2i=aZabiFw0)w>3gb5RaD-}CDs;qsFIJ~ z=rb+|v(~A6kd@KUgQ&weJ&V6bBcHoHsL8#UfO>rvKOOK8a3VCF?>l5#-2@N9;)f8G z@Drtmt*0H_7nJY#48zA!yEMX>b0zQww#s~3c{0eg)tKbv%0TUyE zJ0tvbf(j28lrl_Eb3z3*D@0Hlt)O)544V!<$MLopm{XH22*$7479`awg>Z25MO#YD EKX9TKiU0rr diff --git a/CLAUDE.md b/CLAUDE.md index d7bec47..4493e74 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -174,8 +174,8 @@ You workflow should be incremental with a stepping back review phase after each - Note any design choices or decisions you are not sure about and request the user for comments - Look for and point out dead or duplicated code branches that could be DRYed - Double check the README.md or other documentation to remove outdated sections -- Be wary of unconstrained and overly generic types in arguments and returns. Introduce ADT using dedicated Pydantic BaseModel and a domain-driven approach, if the current ones are not sufficient. Use pattern matches on these types instead of hasattr/getattr decomposition +- Be wary of unconstrained and overly generic types in function signatures, and make sure type hints are present in all signatures. Introduce ADT using dedicated Pydantic BaseModel and a domain-driven approach, if the current ones are not sufficient. Use pattern matches on these types instead of hasattr/getattr decomposition - **Leverage Pydantic validation**: When adding new configuration parameters or architectural constraints, use Pydantic field validators (`@field_validator`) to catch errors early with helpful messages - **Use domain models**: Replace isinstance/hasattr patterns with domain objects that use pydantic's `BaseModel` - Always run tests with pytest as final verification step for newly added code -- any use of `hasattr` and `.get()` with defaults and similar existence checks on objects are code smells (!) and indication that proper configuration or domain object models need to be reviewed \ No newline at end of file +- any use of `hasattr` and `.get()` with defaults and similar existence checks on objects are code smells (!) and indication that proper configuration or domain object models need to be reviewed diff --git a/coverage.xml b/coverage.xml index aa92133..1ddbc63 100644 --- a/coverage.xml +++ b/coverage.xml @@ -1,5 +1,5 @@ - + @@ -16,7 +16,7 @@ - + @@ -506,7 +506,7 @@ - + @@ -715,7 +715,7 @@ - + @@ -821,7 +821,7 @@ - + @@ -834,88 +834,86 @@ - - - - - + + + + - + - + - - - + + - + + - + - + - + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - + + + - - - - - + + + + - - - - - - + + + + + + + - - + + - - + + - - + - - + + @@ -924,465 +922,455 @@ - - - - - - - - - - + + + + + + + + + + + + + - - - + + + - - + + - - - - - - - - - - - - - + + + + + + + + + + + + + - + - + - + - - - - - + + + + + + + + + + + + + + + - - - + + + - - - - + + + - + - - - - - - - - - - - - - - - - - - - - + + + + - + - + - + - + + + - - + + - - - - - - - - + + + + - + + + + + + - - - - - - - - - + + + + + + - - + + - - - - - - - + + + + + + + - - - + + + - - - - - - + + + + + + - - - - + + + - + - + + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - - - - + + + + + + - - - - + - - - - - - - + + + + + + + + + + + + + + + + - - - - - - + + + + + + + + + + + + + + + + - + + + - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + - - - - - - + + + + + + + + + + - - - - - + + + + + + + - - - - - - + + + + - - - - - - + + + + - - - - - - + + + - - - - + + + - - - + + - - - - - - + + + + + + + + + + + + + - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + + + + + + - - + + + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - - - - + + + + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - - + + + + - - - - - - - - + + + + + - + + + + - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + - - - - - - - - - - - - - @@ -2257,7 +2245,7 @@ - + @@ -2404,50 +2392,83 @@ - + + + + + + + - - - - - - - - - + + + + + + + + + + - + + - + + + + + + - - - - - - - - - + + - - - + + + + - + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -2462,93 +2483,71 @@ - - - + + + - - - + + + - - - - - - - - - - - - + + + + + + + - - - - - - + + - - - - - - - - - - + - - - - - - - - - - - + + - - - + + + + + + + + + - @@ -2559,128 +2558,131 @@ + + + + + - - - - + + + + - - + + - - - + + + + + + + + - - - - - - + + + - - - - - + + + + - - - + + + - - - - - - - - - + + + + + + + + + + + + + + + - + - + + - + + + + + + + - - - - - - - - - - - - - - + - - - + + + + - - - - - - - + + + @@ -2688,21 +2690,23 @@ - + - + + + + - - - + + @@ -2710,9 +2714,9 @@ - - - + + + @@ -2722,492 +2726,558 @@ - - - - - - - + + + - - + + + + + + + + + + + + + - + - - + - - - + + + + - - - + + - - + + + - - - - - - + + + - - - - - - - - + + + + - - - + + + + + - - - + + - - - + + + + + - - + + - - + + - + + + - - - + + - - + + - + + + + - - - - + + + + + + + + + + + + + + + + + + - - + + + - - - - - + + - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + - - - - + + - - + + - + - - + + - - - - + - - - + + + + + - - - + + + - - + + + - - + + - - + + - - - + + + - - + + + - - - + + - - - - + + - - + + + + - - - + + + - + + + + + + + + - - - - - + + + + + + + - + + + + + - - - - + + - + - - - - + + + - - - - - - - - - + + + + - - - - - - + + - - - - - + - + + - - - - - + + + - + + + + + + + + + + - - - + + + + - - - + + + + + + - - - - - - - + - - + + + + + + + - - + + + - - - - - - - - - - - + + - - - - - - - - - - - - - - - - - - - + + + - - - + - - - - - - - - - - + + - - + + - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -3967,7 +4037,7 @@ - + @@ -4036,58 +4106,71 @@ - - - + - - - - - - - - + + + - - - - - - - - - - + + + - - - - - - - - - + - + + + + - - + + - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -4393,7 +4476,7 @@ - + @@ -4402,7 +4485,7 @@ - + @@ -4411,35 +4494,33 @@ - - + - - - - + + + - + - - + + - + - - + + + - - + @@ -4449,10 +4530,10 @@ - - - - + + + + @@ -4461,20 +4542,20 @@ - + - + - + - - - - - + + + + + @@ -4483,13 +4564,13 @@ - + - - - + + + @@ -4497,7 +4578,7 @@ - + @@ -4510,70 +4591,69 @@ - - - - + + + + - - - - + + + + - - - + + + - + - - - - + + + + - + - + - - - - - + + + + + - - - + + + - + - + - @@ -4588,159 +4668,160 @@ + - + - + - - - - - - + + + + + + - + - + - + - + - + - + - + - + - + - + - + - - - - + + + + - + - + - + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - + + + + - + - + - + - - + + - + - - - + + + - - - - - + + + + + - - - - + + + + @@ -4749,19 +4830,18 @@ - + - + - - - + + + - - - - + + + @@ -4769,192 +4849,192 @@ + - + - - - - - + + + + + - - - - + + + + - - - + + + + - - - - - - - + + + + + + - + - + - + - - + + - + - + - - - - + + + - - - - + + + + + - - - - - - + + + + + + - - - - - + + + + + - - - - - + + + + + - - - - - + + + + + - - - - - + + + + + - - - - + + + + - + - + - - - - + + + + - + - - - - - - - - - - - - - + + + + + + + + + + + + + - + - + - - + + + - - + - @@ -4964,13 +5044,13 @@ + - - - - + + + @@ -4981,76 +5061,76 @@ - - - - + + + + + - - - - - - + + + + + + + - - - - - - + + + + - + - + - + - - + + + + - - - + + - - + - + - + + + - - - - - - + + + + + + - - - + @@ -5060,122 +5140,185 @@ - + - + - - - - - - - - - - - - + + + + + + + + + + + - + - - - + + + + + + + + + + + - - - - - + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - + + + - - - - - - - - - - - - - - - - + + + + + + + - + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -5804,9 +5947,9 @@ - + - + @@ -5876,251 +6019,242 @@ - - - - - - - - - - - - + + + + - - - + + + + - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + + - - - - - - + + + + - + - + - - + + + - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + - - + - + + + - - - - + + + + + + - + - + - - - - + + + + - - + - - + + - + - + - + - - - - - - + + + + + + + + + + + + + + + + - - + + - - - - + + + - - - - - - - - + + + - - + - - + @@ -6128,49 +6262,50 @@ - + + - - - - - - - - - - - - + + + + + + + - - - - - - - - + + + + + + + + + + + + + @@ -6180,44 +6315,52 @@ - - + + + + - - - - - + - - + + + - - - - - - - + + + + + + + + + + + + + + + - + + + - - + @@ -6225,133 +6368,117 @@ - + - - + + - + + - - - - - + + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - + - + - - - - - - + + + + - + - - - + + + + - - - - - + + + + - - - - - - - - - - - + + + + + - - - + - - - + + + + + + - + - + @@ -6366,44 +6493,47 @@ + + + + - + - + - + - + - - + + - @@ -6411,163 +6541,218 @@ - + - - - - + + + - - - - + + + + + + + + + + + + + + + + + + + + + + - - + + - - - - - - + + + + - + - + + - - - - - + + - - - + + + + + + + + + - + + - + - + + - - + - + + + - + - + - - - - - - - - - - - + + + + + + + - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - + + - - + - - - - - - - - - - - + + - - - - - - - - - - - - - - - - - - + + + + + + + + + + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + @@ -6582,154 +6767,211 @@ - - + - - - - - - - - + + + + + + + - - - + + + - + - + - + - - + + - + - + - - + + - + - + + + + + + + + + + + - - - - - - - - - + + - + + + + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - - + + + + + + + + - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -6737,34 +6979,32 @@ - - - - - + + + + + - + - - + + - - - - - + + + + + - - + - - + - + @@ -6774,98 +7014,96 @@ - - + - - - + + + - - + + - + - + - + - + - + - - - - - + + + + + - + - + - - - + + - + - + - + - - - + + - - - - + + + + + - - + + + - - - - - - - + + + + + + - + @@ -6874,45 +7112,48 @@ - - - - - - - - + + + + + + + - + - + + - - - - + + + - + + - + - - + - + + - - - - + + + + - - - - + + + + + + + @@ -7300,6 +7541,64 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -7504,59 +7803,62 @@ - + - - - - + + + + - + - - - + + - - - - - - + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + diff --git a/src/slopometry/core/database.py b/src/slopometry/core/database.py index af3b73f..477288c 100644 --- a/src/slopometry/core/database.py +++ b/src/slopometry/core/database.py @@ -28,7 +28,9 @@ PlanEvolution, Project, ProjectSource, + QPEScore, RepoBaseline, + ResolvedBaselineStrategy, SessionStatistics, ToolType, UserStory, @@ -385,23 +387,18 @@ def get_session_events(self, session_id: str) -> list[HookEvent]: events = [] for row in rows: - row_keys = row.keys() git_state = None - if "git_state" in row_keys and row["git_state"]: + if row["git_state"]: try: git_state_data = json.loads(row["git_state"]) git_state = GitState.model_validate(git_state_data) except (json.JSONDecodeError, ValueError): git_state = None - working_directory = ( - row["working_directory"] - if "working_directory" in row_keys and row["working_directory"] - else "Unknown" - ) + working_directory = row["working_directory"] or "Unknown" project = None - if "project_name" in row_keys and row["project_name"]: + if row["project_name"]: project = Project( name=row["project_name"], source=ProjectSource(row["project_source"]), @@ -564,62 +561,71 @@ def get_session_statistics(self, session_id: str) -> SessionStatistics | None: git_tracker = GitTracker() commits_made = git_tracker.calculate_commits_made(initial_git_state, final_git_state) - stats = SessionStatistics( - session_id=session_id, - start_time=datetime.fromisoformat(stats_row["start_time"]), - end_time=datetime.fromisoformat(stats_row["end_time"]) if stats_row["end_time"] else None, - total_events=stats_row["total_events"], - working_directory=working_directory, - project=project, - transcript_path=transcript_path, - events_by_type=events_by_type, - tool_usage=tool_usage, - error_count=stats_row["error_count"], - total_duration_ms=stats_row["total_duration_ms"], - initial_git_state=initial_git_state, - final_git_state=final_git_state, - commits_made=commits_made, + average_tool_duration_ms = ( + stats_row["total_duration_ms"] / stats_row["events_with_duration"] + if stats_row["events_with_duration"] > 0 + else None ) - if stats_row["events_with_duration"] > 0: - stats.average_tool_duration_ms = stats_row["total_duration_ms"] / stats_row["events_with_duration"] - - stats.complexity_metrics, stats.complexity_delta = self._get_session_complexity_metrics( - session_id, stats.working_directory, stats.initial_git_state + # Compute optional enrichments before constructing the stats object + complexity_metrics, complexity_delta = self._get_session_complexity_metrics( + session_id, working_directory, initial_git_state ) + plan_evolution = None try: - stats.plan_evolution = self._calculate_plan_evolution(session_id) - if stats.plan_evolution and stats.transcript_path: + plan_evolution = self._calculate_plan_evolution(session_id) + if plan_evolution and transcript_path: try: from slopometry.core.transcript_token_analyzer import analyze_transcript_tokens - transcript_path = Path(stats.transcript_path) - if transcript_path.exists(): - stats.plan_evolution.token_usage = analyze_transcript_tokens(transcript_path) + tp = Path(transcript_path) + if tp.exists(): + plan_evolution.token_usage = analyze_transcript_tokens(tp) except Exception as e: logger.debug(f"Failed to analyze transcript tokens for session {session_id}: {e}") except Exception as e: logger.debug(f"Failed to calculate plan evolution for session {session_id}: {e}") - stats.plan_evolution = None - if stats.transcript_path: + compact_events = None + if transcript_path: try: from slopometry.core.compact_analyzer import analyze_transcript_compacts - transcript_path = Path(stats.transcript_path) - if transcript_path.exists(): - stats.compact_events = analyze_transcript_compacts(transcript_path) + tp = Path(transcript_path) + if tp.exists(): + compact_events = analyze_transcript_compacts(tp) except Exception as e: logger.debug(f"Failed to analyze compact events for session {session_id}: {e}") + context_coverage = None try: - stats.context_coverage = self._calculate_context_coverage(stats.transcript_path, stats.working_directory) + context_coverage = self._calculate_context_coverage(transcript_path, working_directory) except Exception as e: logger.debug(f"Failed to calculate context coverage for session {session_id}: {e}") - stats.context_coverage = None - return stats + return SessionStatistics( + session_id=session_id, + start_time=datetime.fromisoformat(stats_row["start_time"]), + end_time=datetime.fromisoformat(stats_row["end_time"]) if stats_row["end_time"] else None, + total_events=stats_row["total_events"], + working_directory=working_directory, + project=project, + transcript_path=transcript_path, + events_by_type=events_by_type, + tool_usage=tool_usage, + error_count=stats_row["error_count"], + total_duration_ms=stats_row["total_duration_ms"], + initial_git_state=initial_git_state, + final_git_state=final_git_state, + commits_made=commits_made, + average_tool_duration_ms=average_tool_duration_ms or 0.0, + complexity_metrics=complexity_metrics, + complexity_delta=complexity_delta, + plan_evolution=plan_evolution, + compact_events=compact_events or [], + context_coverage=context_coverage, + ) def _get_session_complexity_metrics( self, session_id: str, working_directory: str | None, initial_git_state: GitState | None @@ -771,7 +777,6 @@ def calculate_extended_complexity_metrics( analyzer = ComplexityAnalyzer(working_directory=Path(working_directory)) complexity_delta = None - current_basic = None current_extended = analyzer.analyze_extended_complexity() @@ -786,54 +791,7 @@ def calculate_extended_complexity_metrics( with git_tracker.extract_files_from_commit_ctx(baseline_ref) as baseline_dir: if baseline_dir: baseline_extended = analyzer.analyze_extended_complexity(baseline_dir) - - current_basic = analyzer.analyze_complexity() - baseline_basic = analyzer._analyze_directory(baseline_dir) - complexity_delta = analyzer._calculate_delta(baseline_basic, current_basic) - - complexity_delta.total_volume_change = ( - current_extended.total_volume - baseline_extended.total_volume - ) - complexity_delta.avg_volume_change = ( - current_extended.average_volume - baseline_extended.average_volume - ) - complexity_delta.total_difficulty_change = ( - current_extended.total_difficulty - baseline_extended.total_difficulty - ) - complexity_delta.avg_difficulty_change = ( - current_extended.average_difficulty - baseline_extended.average_difficulty - ) - complexity_delta.total_effort_change = ( - current_extended.total_effort - baseline_extended.total_effort - ) - complexity_delta.total_mi_change = current_extended.total_mi - baseline_extended.total_mi - complexity_delta.avg_mi_change = current_extended.average_mi - baseline_extended.average_mi - - current_extended.total_complexity = current_basic.total_complexity - current_extended.average_complexity = current_basic.average_complexity - current_extended.max_complexity = current_basic.max_complexity - current_extended.min_complexity = current_basic.min_complexity - current_extended.total_files_analyzed = current_basic.total_files_analyzed - current_extended.files_by_complexity = current_basic.files_by_complexity - - complexity_delta.orphan_comment_change = ( - current_extended.orphan_comment_count - baseline_extended.orphan_comment_count - ) - complexity_delta.untracked_todo_change = ( - current_extended.untracked_todo_count - baseline_extended.untracked_todo_count - ) - complexity_delta.inline_import_change = ( - current_extended.inline_import_count - baseline_extended.inline_import_count - ) - complexity_delta.dict_get_with_default_change = ( - current_extended.dict_get_with_default_count - baseline_extended.dict_get_with_default_count - ) - complexity_delta.hasattr_getattr_change = ( - current_extended.hasattr_getattr_count - baseline_extended.hasattr_getattr_count - ) - complexity_delta.nonempty_init_change = ( - current_extended.nonempty_init_count - baseline_extended.nonempty_init_count - ) + complexity_delta = analyzer._calculate_delta(baseline_extended, current_extended) return current_extended, complexity_delta @@ -1097,8 +1055,8 @@ def get_latest_progress(self, experiment_id: str) -> ExperimentProgress | None: complexity_score=row[6], halstead_score=row[7], maintainability_score=row[8], - qpe_score=row[9] if len(row) > 9 else None, - smell_penalty=row[10] if len(row) > 10 else None, + qpe_score=row[9], + smell_penalty=row[10], ) def create_commit_chain(self, repository_path: str, base_commit: str, head_commit: str, commit_count: int) -> int: @@ -1615,7 +1573,9 @@ def get_cached_baseline(self, repository_path: str, head_commit_sha: str) -> Rep effort_delta_mean, effort_delta_std, effort_delta_median, effort_delta_min, effort_delta_max, effort_delta_trend, mi_delta_mean, mi_delta_std, mi_delta_median, mi_delta_min, mi_delta_max, mi_delta_trend, current_metrics_json, - oldest_commit_date, newest_commit_date, oldest_commit_tokens + oldest_commit_date, newest_commit_date, oldest_commit_tokens, + strategy_json, + qpe_stats_json, current_qpe_json FROM repo_baselines WHERE repository_path = ? AND head_commit_sha = ? """, @@ -1625,6 +1585,18 @@ def get_cached_baseline(self, repository_path: str, head_commit_sha: str) -> Rep if not row: return None + strategy = None + if row[26]: + strategy = ResolvedBaselineStrategy.model_validate_json(row[26]) + + qpe_stats = None + if row[27]: + qpe_stats = HistoricalMetricStats.model_validate_json(row[27]) + + current_qpe = None + if row[28]: + current_qpe = QPEScore.model_validate_json(row[28]) + return RepoBaseline( repository_path=row[0], head_commit_sha=row[1], @@ -1664,10 +1636,17 @@ def get_cached_baseline(self, repository_path: str, head_commit_sha: str) -> Rep oldest_commit_date=datetime.fromisoformat(row[23]) if row[23] else None, newest_commit_date=datetime.fromisoformat(row[24]) if row[24] else None, oldest_commit_tokens=row[25], + strategy=strategy, + qpe_stats=qpe_stats, + current_qpe=current_qpe, ) def save_baseline(self, baseline: RepoBaseline) -> None: """Save computed baseline to cache.""" + strategy_json = baseline.strategy.model_dump_json() if baseline.strategy else None + qpe_stats_json = baseline.qpe_stats.model_dump_json() if baseline.qpe_stats else None + current_qpe_json = baseline.current_qpe.model_dump_json() if baseline.current_qpe else None + with self._get_db_connection() as conn: conn.execute( """ @@ -1677,8 +1656,10 @@ def save_baseline(self, baseline: RepoBaseline) -> None: effort_delta_mean, effort_delta_std, effort_delta_median, effort_delta_min, effort_delta_max, effort_delta_trend, mi_delta_mean, mi_delta_std, mi_delta_median, mi_delta_min, mi_delta_max, mi_delta_trend, current_metrics_json, - oldest_commit_date, newest_commit_date, oldest_commit_tokens - ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + oldest_commit_date, newest_commit_date, oldest_commit_tokens, + strategy_json, + qpe_stats_json, current_qpe_json + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( baseline.repository_path, @@ -1707,6 +1688,9 @@ def save_baseline(self, baseline: RepoBaseline) -> None: baseline.oldest_commit_date.isoformat() if baseline.oldest_commit_date else None, baseline.newest_commit_date.isoformat() if baseline.newest_commit_date else None, baseline.oldest_commit_tokens, + strategy_json, + qpe_stats_json, + current_qpe_json, ), ) conn.commit() diff --git a/src/slopometry/core/migrations.py b/src/slopometry/core/migrations.py index 0993a60..04d7ca5 100644 --- a/src/slopometry/core/migrations.py +++ b/src/slopometry/core/migrations.py @@ -332,6 +332,59 @@ def up(self, conn: sqlite3.Connection) -> None: conn.execute("CREATE INDEX IF NOT EXISTS idx_leaderboard_project ON qpe_leaderboard(project_path, measured_at)") +class Migration009AddBaselineStrategyColumn(Migration): + """Add strategy_json column to repo_baselines for baseline strategy tracking.""" + + @property + def version(self) -> str: + return "009" + + @property + def description(self) -> str: + return "Add strategy_json column to repo_baselines for baseline strategy tracking" + + def up(self, conn: sqlite3.Connection) -> None: + """Add strategy_json column to repo_baselines.""" + cursor = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='repo_baselines'") + if not cursor.fetchone(): + return + + try: + conn.execute("ALTER TABLE repo_baselines ADD COLUMN strategy_json TEXT") + except sqlite3.OperationalError as e: + if "duplicate column name" not in str(e).lower(): + raise + + +class Migration010AddBaselineQPEColumns(Migration): + """Add QPE stats and current QPE columns to repo_baselines. + + These columns were missing, causing the baseline cache to always appear stale + (qpe_stats=None after load triggers recomputation on every run). + """ + + @property + def version(self) -> str: + return "010" + + @property + def description(self) -> str: + return "Add qpe_stats_json and current_qpe_json columns to repo_baselines for cache completeness" + + def up(self, conn: sqlite3.Connection) -> None: + """Add QPE columns to repo_baselines.""" + cursor = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='repo_baselines'") + if not cursor.fetchone(): + return + + for column_name in ("qpe_stats_json", "current_qpe_json"): + try: + conn.execute(f"ALTER TABLE repo_baselines ADD COLUMN {column_name} TEXT") + except sqlite3.OperationalError as e: + if "duplicate column name" not in str(e).lower(): + raise + + class MigrationRunner: """Manages database migrations.""" @@ -346,6 +399,8 @@ def __init__(self, db_path: Path): Migration006AddQPEColumns(), Migration007AddQPELeaderboard(), Migration008FixLeaderboardUniqueConstraint(), + Migration009AddBaselineStrategyColumn(), + Migration010AddBaselineQPEColumns(), ] @contextmanager diff --git a/src/slopometry/core/models.py b/src/slopometry/core/models.py index d041311..fd16c9d 100644 --- a/src/slopometry/core/models.py +++ b/src/slopometry/core/models.py @@ -6,7 +6,7 @@ from typing import Any from uuid import uuid4 -from pydantic import BaseModel, ConfigDict, Field +from pydantic import BaseModel, ConfigDict, Field, field_validator class AgentTool(str, Enum): @@ -21,7 +21,6 @@ class SmellCategory(str, Enum): GENERAL = "general" PYTHON = "python" - RUST = "rust" class SmellDefinition(BaseModel): @@ -211,6 +210,57 @@ def SmellField( ) +class BaselineStrategy(str, Enum): + """How to select commits for building the historic quality baseline. + + MERGE_ANCHORED: Follows first-parent (trunk) history, so each delta represents + the net quality effect of one accepted merge/PR. Best for repos using merge + workflows where merges are quality checkpoints (code review happened). + + TIME_SAMPLED: Samples commits at regular time intervals within a bounded + lookback window. Prevents the 'N commits = 2 days' problem in active repos. + Best for repos with linear history (squash merges, rebase workflows). + + AUTO: Examines recent commit history to compute merge ratio. If merges are + frequent enough (above configurable threshold), uses MERGE_ANCHORED. + Otherwise falls back to TIME_SAMPLED. + """ + + MERGE_ANCHORED = "merge_anchored" + TIME_SAMPLED = "time_sampled" + AUTO = "auto" + + +class ResolvedBaselineStrategy(BaseModel): + """Records which baseline strategy was actually used after AUTO resolution. + + AUTO never appears as the resolved strategy -- it always resolves to one of + the concrete strategies. This model is stored with the cached baseline so + we can invalidate the cache when the user changes strategy settings. + """ + + model_config = ConfigDict(frozen=True) + + requested: BaselineStrategy = Field(description="Strategy requested via settings (may be AUTO)") + resolved: BaselineStrategy = Field( + description="Concrete strategy actually used (never AUTO). " + "MERGE_ANCHORED uses first-parent trunk history at merge points. " + "TIME_SAMPLED samples commits at regular time intervals within a bounded lookback window." + ) + merge_ratio: float = Field( + description="Fraction of merge commits in the detection sample (0.0-1.0). " + "Used by AUTO to decide strategy: above threshold -> MERGE_ANCHORED, below -> TIME_SAMPLED." + ) + total_commits_sampled: int = Field(description="Number of recent commits examined during strategy auto-detection") + + @field_validator("resolved") + @classmethod + def resolved_must_be_concrete(cls, v: BaselineStrategy) -> BaselineStrategy: + if v == BaselineStrategy.AUTO: + raise ValueError("resolved strategy cannot be AUTO") + return v + + class ProjectLanguage(str, Enum): """Supported languages for complexity analysis.""" @@ -986,9 +1036,9 @@ def get_smell_files(self) -> dict[str, list[str]]: """Return smell name to files mapping for filtering.""" return {smell.name: smell.files for smell in self.get_smells()} - def get_smell_counts(self) -> dict[str, int]: - """Return smell name to count mapping for display.""" - return {smell.name: smell.count for smell in self.get_smells()} + def get_smell_counts(self) -> "SmellCounts": + """Return smell counts as a typed model for QPE and display.""" + return SmellCounts(**{smell.name: smell.count for smell in self.get_smells()}) class ExperimentRun(BaseModel): @@ -1293,6 +1343,13 @@ class RepoBaseline(BaseModel): qpe_stats: HistoricalMetricStats | None = Field(default=None, description="QPE statistics from commit history") current_qpe: "QPEScore | None" = Field(default=None, description="QPE score at HEAD") + strategy: ResolvedBaselineStrategy | None = Field( + default=None, + description="Which baseline computation strategy produced this baseline. " + "None for legacy baselines computed before strategy support was added. " + "Used for cache invalidation: strategy mismatch with current settings triggers recomputation.", + ) + class ZScoreInterpretation(str, Enum): """Human-readable interpretation of Z-score values.""" @@ -1374,6 +1431,32 @@ def interpret_qpe(self, verbose: bool = False) -> ZScoreInterpretation: return ZScoreInterpretation.from_z_score(self.qpe_z_score, verbose) +class SmellCounts(BaseModel): + """Per-smell occurrence counts from complexity analysis. + + Every field corresponds to a smell in SMELL_REGISTRY. Using explicit fields + instead of dict[str, int] so access is validated at construction time and + there is no need for .get() defaults or key existence checks. + """ + + model_config = ConfigDict(frozen=True) + + orphan_comment: int = 0 + untracked_todo: int = 0 + swallowed_exception: int = 0 + test_skip: int = 0 + type_ignore: int = 0 + dynamic_execution: int = 0 + inline_import: int = 0 + dict_get_with_default: int = 0 + hasattr_getattr: int = 0 + nonempty_init: int = 0 + single_method_class: int = 0 + deep_inheritance: int = 0 + passthrough_wrapper: int = 0 + sys_path_manipulation: int = 0 + + class QPEScore(BaseModel): """Quality score for principled code quality comparison. @@ -1387,8 +1470,84 @@ class QPEScore(BaseModel): smell_penalty: float = Field(description="Penalty from code smells (sigmoid-saturated, 0-0.9 range)") adjusted_quality: float = Field(description="MI after smell penalty applied") - smell_counts: dict[str, int] = Field( - default_factory=dict, description="Individual smell counts contributing to penalty" + smell_counts: SmellCounts = Field( + default_factory=SmellCounts, description="Individual smell counts contributing to penalty" + ) + + +class SmellAdvantage(BaseModel): + """Per-smell contribution to the GRPO advantage signal. + + The aggregate grpo_advantage() collapses all quality into a single scalar. + SmellAdvantage decomposes that into individual smell contributions, enabling: + - Interpretability: which specific smells drove the advantage/disadvantage + - Per-smell reward shaping: downstream GRPO training can weight individual + smell improvements differently + - Debugging: understand why two implementations scored differently + + The weighted_delta uses the same weights from SMELL_REGISTRY that feed into + QPE's smell_penalty calculation, ensuring consistency between the aggregate + and decomposed signals. + """ + + model_config = ConfigDict(frozen=True) + + smell_name: str = Field( + description="Internal name from SMELL_REGISTRY (e.g., 'swallowed_exception', 'hasattr_getattr')" + ) + baseline_count: int = Field(description="Number of this smell in the baseline/reference implementation") + candidate_count: int = Field(description="Number of this smell in the candidate implementation being evaluated") + weight: float = Field( + description="Smell weight from SMELL_REGISTRY (0.02-0.15). " + "Higher weight means this smell has more impact on QPE penalty." + ) + weighted_delta: float = Field( + description="(candidate_count - baseline_count) * weight. " + "Negative = candidate improved (fewer smells). " + "Positive = candidate regressed (more smells). " + "Zero = no change for this smell type." + ) + + +class ImplementationComparison(BaseModel): + """Result of comparing two parallel implementations via their subtree prefixes. + + This is the primary output for GRPO-based quality comparison. Two code subtrees + (e.g., two implementations of the same feature living side-by-side in the repo) + are analyzed independently and compared using QPE + smell decomposition. + + The aggregate_advantage is the main GRPO reward signal: positive means B is + better, negative means A is better, bounded to (-1, 1) via tanh. + """ + + prefix_a: str = Field( + description="Subtree path prefix for implementation A (e.g., 'vendor/lib-a'). " + "All Python files under this prefix are analyzed as a unit." + ) + prefix_b: str = Field( + description="Subtree path prefix for implementation B (e.g., 'vendor/lib-b'). " + "Compared against prefix_a to determine which implementation is better." + ) + ref: str = Field( + description="Git ref both subtrees were extracted from (e.g., 'HEAD', 'main', commit SHA). " + "Both prefixes are analyzed at this same point in history." + ) + qpe_a: "QPEScore" = Field( + description="Full QPE score for implementation A including MI, smell penalty, and per-smell counts" + ) + qpe_b: "QPEScore" = Field( + description="Full QPE score for implementation B including MI, smell penalty, and per-smell counts" + ) + aggregate_advantage: float = Field( + description="GRPO advantage of B over A, bounded (-1, 1) via tanh. " + "Positive = B is better quality. Negative = A is better." + ) + smell_advantages: list[SmellAdvantage] = Field( + default_factory=list, description="Per-smell advantage breakdown sorted by impact magnitude." + ) + winner: str = Field( + description="Which prefix produced better code: prefix_a value, prefix_b value, or 'tie'. " + "Tie declared when |aggregate_advantage| < 0.01 (within deadband)." ) @@ -1490,6 +1649,12 @@ class CurrentChangesAnalysis(BaseModel): default=None, description="Developer productivity metrics based on token throughput" ) + smell_advantages: list["SmellAdvantage"] = Field( + default_factory=list, + description="Per-smell advantage breakdown between baseline and current QPE. " + "Shows which specific smells changed and their weighted impact.", + ) + class FileCoverageStatus(BaseModel): """Coverage status for a single edited file showing what context was read.""" diff --git a/src/slopometry/core/settings.py b/src/slopometry/core/settings.py index 501f1dd..2cb0ae1 100644 --- a/src/slopometry/core/settings.py +++ b/src/slopometry/core/settings.py @@ -130,6 +130,44 @@ def _ensure_global_config_dir() -> None: baseline_max_commits: int = Field(default=100, description="Maximum commits to analyze for baseline computation") + baseline_strategy: str = Field( + default="auto", + description="How to select commits for building the historic quality baseline. " + "'auto' detects merge workflow vs linear history and picks the best strategy. " + "'merge_anchored' uses first-parent trunk history (best for merge/PR workflows). " + "'time_sampled' samples at regular time intervals (best for squash/rebase workflows).", + ) + + baseline_merge_ratio_threshold: float = Field( + default=0.15, + description="Merge commit ratio threshold for AUTO strategy detection. " + "When the fraction of merge commits in recent history exceeds this value, " + "AUTO resolves to MERGE_ANCHORED. Below this, resolves to TIME_SAMPLED.", + ) + + baseline_lookback_months: int = Field( + default=6, + description="Maximum lookback window in months for TIME_SAMPLED strategy. " + "Bounds the initial git log query via --after flag.", + ) + + baseline_time_sample_interval_days: int = Field( + default=7, + description="Sampling interval in days for TIME_SAMPLED strategy. " + "One commit is selected per interval. 7 days = weekly quality snapshots.", + ) + + baseline_time_sample_min_commits: int = Field( + default=10, + description="Minimum number of sampled commits for TIME_SAMPLED strategy. " + "Falls back to evenly-spaced sampling if interval produces fewer.", + ) + + baseline_detection_sample_size: int = Field( + default=200, + description="Number of recent commits to examine for AUTO strategy detection.", + ) + qpe_sigmoid_steepness: float = Field( default=2.0, description="Steepness factor for QPE smell penalty sigmoid (higher = faster saturation)", @@ -166,6 +204,15 @@ def _ensure_global_config_dir() -> None: default=0.50, description="Weight for Maintainability Index in impact score calculation" ) + @field_validator("baseline_strategy", mode="before") + @classmethod + def validate_baseline_strategy(cls, v: str) -> str: + """Validate baseline_strategy is one of the allowed values.""" + allowed = {"auto", "merge_anchored", "time_sampled"} + if v not in allowed: + raise ValueError(f"baseline_strategy must be one of {allowed}, got '{v}'") + return v + @field_validator("database_path", mode="before") @classmethod def validate_database_path(cls, v: str | Path | None) -> Path | None: diff --git a/src/slopometry/display/formatters.py b/src/slopometry/display/formatters.py index b9883ed..97af6cd 100644 --- a/src/slopometry/display/formatters.py +++ b/src/slopometry/display/formatters.py @@ -9,10 +9,13 @@ from slopometry.core.models import ( SMELL_REGISTRY, + BaselineStrategy, CompactEvent, ExperimentDisplayData, + ImplementationComparison, NFPObjectiveDisplayData, ProgressDisplayData, + SmellAdvantage, SmellCategory, TokenUsage, ZScoreInterpretation, @@ -410,7 +413,7 @@ def _display_complexity_metrics( category_label = "General" if category == SmellCategory.GENERAL else "Python" overview_table.add_row(f" [dim]{category_label}[/dim]", "") for defn in get_smells_by_category(category): - count = smell_counts[defn.internal_name] + count = getattr(smell_counts, defn.internal_name) smell_color = "red" if count > 0 else "green" overview_table.add_row(f" {defn.label}", f"[{smell_color}]{count}[/{smell_color}]") @@ -1154,6 +1157,7 @@ def display_current_impact_analysis( baseline=analysis.baseline, assessment=analysis.assessment, title=impact_title, + smell_advantages=analysis.smell_advantages or None, ) console.print("\n[bold]Token Impact:[/bold]") @@ -1295,14 +1299,29 @@ def display_baseline_comparison( baseline: RepoBaseline, assessment: ImpactAssessment, title: str = "Impact Assessment", + smell_advantages: list["SmellAdvantage"] | None = None, ) -> None: """Display baseline comparison with impact assessment. This is a shared formatter used by current-impact, analyze-commits, solo latest, and stop hook feedback. + + Args: + baseline: Repository baseline for context + assessment: Impact assessment with z-scores + title: Section title + smell_advantages: Optional per-smell advantage breakdown from QPE comparison """ - console.print(f"\n[bold]Repository Baseline ({baseline.total_commits_analyzed} commits):[/bold]") + strategy_info = "" + if baseline.strategy: + strategy_label = baseline.strategy.resolved.value.replace("_", "-") + if baseline.strategy.requested == BaselineStrategy.AUTO: + strategy_info = f" | strategy: {strategy_label} (auto, merge ratio: {baseline.strategy.merge_ratio:.0%})" + else: + strategy_info = f" | strategy: {strategy_label}" + + console.print(f"\n[bold]Repository Baseline ({baseline.total_commits_analyzed} commits{strategy_info}):[/bold]") baseline_table = Table(show_header=True, header_style="bold") baseline_table.add_column("Metric", style="cyan") @@ -1320,6 +1339,12 @@ def display_baseline_comparison( console.print(baseline_table) + # Show current QPE absolute value for context + if baseline.current_qpe: + current_qpe_val = baseline.current_qpe.qpe + qpe_abs_color = "green" if current_qpe_val > 0.6 else "yellow" if current_qpe_val > 0.4 else "red" + console.print(f" Current QPE: [{qpe_abs_color}]{current_qpe_val:.4f}[/{qpe_abs_color}]") + console.print(f"\n[bold]{title}:[/bold]") impact_table = Table(show_header=True, header_style="bold") @@ -1328,13 +1353,23 @@ def display_baseline_comparison( impact_table.add_column("Z-Score", justify="right") impact_table.add_column("Assessment", style="dim") - qpe_color = "green" if assessment.qpe_z_score > 0 else "red" if assessment.qpe_z_score < 0 else "yellow" - impact_table.add_row( - "QPE (GRPO)", - f"[{qpe_color}]{assessment.qpe_delta:+.4f}[/{qpe_color}]", - f"{assessment.qpe_z_score:+.2f}", - _interpret_z_score(assessment.qpe_z_score), - ) + # Apply deadband: if QPE delta is negligible, don't show misleading z-score + qpe_delta_negligible = abs(assessment.qpe_delta) < 0.001 + if qpe_delta_negligible: + impact_table.add_row( + "QPE (GRPO)", + "[dim]negligible[/dim]", + f"[dim]{assessment.qpe_z_score:+.2f}[/dim]", + "[dim]change too small to assess[/dim]", + ) + else: + qpe_color = "green" if assessment.qpe_z_score > 0 else "red" if assessment.qpe_z_score < 0 else "yellow" + impact_table.add_row( + "QPE (GRPO)", + f"[{qpe_color}]{assessment.qpe_delta:+.4f}[/{qpe_color}]", + f"{assessment.qpe_z_score:+.2f}", + _interpret_z_score(assessment.qpe_z_score), + ) console.print(impact_table) @@ -1355,6 +1390,29 @@ def display_baseline_comparison( console.print(f"\n[bold]Overall Impact:[/bold] [{style}]{category_display}[/] ({assessment.impact_score:+.2f})") console.print(f"[dim]{message}[/dim]") + # Show per-smell advantage breakdown when available + if smell_advantages: + non_zero = [sa for sa in smell_advantages if sa.weighted_delta != 0.0] + if non_zero: + smell_table = Table(title="Smell Changes (baseline vs current)", show_header=True) + smell_table.add_column("Smell", style="cyan") + smell_table.add_column("Before", justify="right") + smell_table.add_column("After", justify="right") + smell_table.add_column("Weight", justify="right") + smell_table.add_column("Weighted Δ", justify="right") + + for sa in non_zero: + delta_color = "green" if sa.weighted_delta < 0 else "red" + smell_table.add_row( + get_smell_label(sa.smell_name), + str(sa.baseline_count), + str(sa.candidate_count), + f"{sa.weight:.2f}", + f"[{delta_color}]{sa.weighted_delta:+.3f}[/{delta_color}]", + ) + + console.print(smell_table) + def display_baseline_comparison_compact( baseline: RepoBaseline, @@ -1364,11 +1422,14 @@ def display_baseline_comparison_compact( lines = [] lines.append(f"Repository Baseline ({baseline.total_commits_analyzed} commits):") - qpe_sign = "↑" if assessment.qpe_z_score > 0 else "↓" if assessment.qpe_z_score < 0 else "→" - qpe_quality = "good" if assessment.qpe_z_score > 0 else "below avg" if assessment.qpe_z_score < 0 else "avg" - lines.append( - f" QPE (GRPO): {assessment.qpe_delta:+.4f} (Z: {assessment.qpe_z_score:+.2f} {qpe_sign} {qpe_quality})" - ) + if abs(assessment.qpe_delta) < 0.001: + lines.append(" QPE (GRPO): negligible change") + else: + qpe_sign = "↑" if assessment.qpe_z_score > 0 else "↓" if assessment.qpe_z_score < 0 else "→" + qpe_quality = "good" if assessment.qpe_z_score > 0 else "below avg" if assessment.qpe_z_score < 0 else "avg" + lines.append( + f" QPE (GRPO): {assessment.qpe_delta:+.4f} (Z: {assessment.qpe_z_score:+.2f} {qpe_sign} {qpe_quality})" + ) category_display = assessment.impact_category.value.replace("_", " ").upper() lines.append(f"Session Impact: {category_display} ({assessment.impact_score:+.2f})") @@ -1390,9 +1451,7 @@ def display_qpe_score( console.print("\n[bold]Quality Score[/bold]") qpe_color = "green" if qpe_score.qpe > 0.6 else "yellow" if qpe_score.qpe > 0.4 else "red" - console.print( - f" [bold]QPE:[/bold] [{qpe_color}]{qpe_score.qpe:.4f}[/{qpe_color}]" - ) + console.print(f" [bold]QPE:[/bold] [{qpe_color}]{qpe_score.qpe:.4f}[/{qpe_color}]") component_table = Table(title="QPE Components", show_header=True) component_table.add_column("Component", style="cyan") @@ -1420,16 +1479,17 @@ def display_qpe_score( console.print(component_table) - if any(count > 0 for count in qpe_score.smell_counts.values()): + smell_counts_dict = qpe_score.smell_counts.model_dump() + if any(count > 0 for count in smell_counts_dict.values()): smell_table = Table(title="Code Smell Breakdown", show_header=True) smell_table.add_column("Smell", style="cyan") smell_table.add_column("Count", justify="right") for category in [SmellCategory.GENERAL, SmellCategory.PYTHON]: category_smells = [ - (name, qpe_score.smell_counts[name]) - for name in qpe_score.smell_counts - if SMELL_REGISTRY.get(name) and SMELL_REGISTRY[name].category == category + (name, getattr(qpe_score.smell_counts, name)) + for name, defn in SMELL_REGISTRY.items() + if defn.category == category ] category_smells = [(n, c) for n, c in category_smells if c > 0] if not category_smells: @@ -1533,3 +1593,70 @@ def display_leaderboard(entries: list) -> None: console.print(table) console.print("\n[dim]Higher Quality = better absolute code quality. Use --append to add projects.[/dim]") + + +def display_implementation_comparison(comparison: ImplementationComparison) -> None: + """Display implementation comparison with QPE breakdown and per-smell advantage. + + Args: + comparison: ImplementationComparison result from compare_subtrees() + """ + console.print(f"\n[bold]Implementation Comparison ({comparison.ref})[/bold]") + console.print(f" A: {comparison.prefix_a}") + console.print(f" B: {comparison.prefix_b}") + + # QPE summary table + qpe_table = Table(title="QPE Comparison", show_header=True) + qpe_table.add_column("Metric", style="cyan") + qpe_table.add_column("A", justify="right") + qpe_table.add_column("B", justify="right") + + qpe_a_color = "green" if comparison.qpe_a.qpe > 0.6 else "yellow" if comparison.qpe_a.qpe > 0.4 else "red" + qpe_b_color = "green" if comparison.qpe_b.qpe > 0.6 else "yellow" if comparison.qpe_b.qpe > 0.4 else "red" + + qpe_table.add_row( + "QPE", + f"[{qpe_a_color}]{comparison.qpe_a.qpe:.4f}[/{qpe_a_color}]", + f"[{qpe_b_color}]{comparison.qpe_b.qpe:.4f}[/{qpe_b_color}]", + ) + qpe_table.add_row( + "MI (normalized)", + f"{comparison.qpe_a.mi_normalized:.3f}", + f"{comparison.qpe_b.mi_normalized:.3f}", + ) + qpe_table.add_row( + "Smell Penalty", + f"{comparison.qpe_a.smell_penalty:.3f}", + f"{comparison.qpe_b.smell_penalty:.3f}", + ) + console.print(qpe_table) + + # Advantage display + adv = comparison.aggregate_advantage + adv_color = "green" if adv > 0.01 else "red" if adv < -0.01 else "yellow" + console.print(f"\n [bold]GRPO Advantage (B over A):[/bold] [{adv_color}]{adv:+.4f}[/{adv_color}]") + + winner_color = "green" if comparison.winner != "tie" else "yellow" + console.print(f" [bold]Winner:[/bold] [{winner_color}]{comparison.winner}[/{winner_color}]") + + # Per-smell advantage breakdown (only show non-zero) + non_zero_smells = [sa for sa in comparison.smell_advantages if sa.weighted_delta != 0.0] + if non_zero_smells: + smell_table = Table(title="Per-Smell Advantage (B vs A)", show_header=True) + smell_table.add_column("Smell", style="cyan") + smell_table.add_column("A Count", justify="right") + smell_table.add_column("B Count", justify="right") + smell_table.add_column("Weight", justify="right") + smell_table.add_column("Weighted Δ", justify="right") + + for sa in non_zero_smells: + delta_color = "green" if sa.weighted_delta < 0 else "red" + smell_table.add_row( + get_smell_label(sa.smell_name), + str(sa.baseline_count), + str(sa.candidate_count), + f"{sa.weight:.2f}", + f"[{delta_color}]{sa.weighted_delta:+.3f}[/{delta_color}]", + ) + + console.print(smell_table) diff --git a/src/slopometry/summoner/cli/commands.py b/src/slopometry/summoner/cli/commands.py index 145b685..fd82d6a 100644 --- a/src/slopometry/summoner/cli/commands.py +++ b/src/slopometry/summoner/cli/commands.py @@ -104,6 +104,84 @@ def summoner() -> None: pass +@summoner.command("compare-subtrees") +@click.argument("prefix_a") +@click.argument("prefix_b") +@click.option("--ref", default="HEAD", help="Git ref to analyze (default: HEAD)") +@click.option( + "--repo-path", + "-r", + type=click.Path(exists=True, path_type=Path), + help="Repository path (default: current directory)", +) +@click.option( + "--json", + "output_json", + is_flag=True, + help="Output as JSON for GRPO pipeline consumption", +) +def compare_subtrees(prefix_a: str, prefix_b: str, ref: str, repo_path: Path | None, output_json: bool) -> None: + """Compare two subtree prefixes for GRPO quality comparison. + + Analyzes Python files under each prefix independently, computes QPE scores, + and returns a bounded advantage signal suitable for GRPO training. + + Example: slopometry summoner compare-subtrees vendor/lib-a vendor/lib-b --ref main + """ + if repo_path is None: + repo_path = Path.cwd() + + from slopometry.core.language_guard import check_language_support + from slopometry.core.models import ProjectLanguage + from slopometry.summoner.services.implementation_comparator import ( + SubtreeExtractionError, + compare_subtrees, + ) + + guard = check_language_support(repo_path, ProjectLanguage.PYTHON) + if warning := guard.format_warning(): + if not output_json: + console.print(f"[dim]{warning}[/dim]") + + try: + if not output_json: + console.print(f"[bold]Comparing subtrees at {ref}[/bold]") + console.print(f" A: {prefix_a}") + console.print(f" B: {prefix_b}") + console.print(f" Repository: {repo_path}") + + comparison = compare_subtrees(repo_path, prefix_a, prefix_b, ref) + + if comparison is None: + if output_json: + print('{"error": "No Python files found in one or both subtree prefixes"}') + else: + console.print("[yellow]No Python files found in one or both subtree prefixes.[/yellow]") + return + + if output_json: + print(comparison.model_dump_json(indent=2)) + else: + from slopometry.display.formatters import display_implementation_comparison + + display_implementation_comparison(comparison) + + except SubtreeExtractionError as e: + if output_json: + escaped_msg = str(e).replace('"', '\\"') + print(f'{{"error": "{escaped_msg}"}}') + else: + console.print(f"[red]Subtree extraction failed: {e}[/red]") + sys.exit(1) + except Exception as e: + if output_json: + escaped_msg = str(e).replace('"', '\\"') + print(f'{{"error": "{escaped_msg}"}}') + else: + console.print(f"[red]Failed to compare subtrees: {e}[/red]") + sys.exit(1) + + @summoner.command("run-experiments") @click.option("--commits", "-c", default=5, help="Number of commits to analyze (default: 5)") @click.option("--max-workers", "-w", default=4, help="Maximum parallel workers (default: 4)") @@ -1020,13 +1098,12 @@ def qpe(repo_path: Path | None, output_json: bool) -> None: console.print(f"Repository: {repo_path}") from slopometry.core.complexity_analyzer import ComplexityAnalyzer - from slopometry.summoner.services.qpe_calculator import QPECalculator + from slopometry.summoner.services.qpe_calculator import calculate_qpe analyzer = ComplexityAnalyzer(working_directory=repo_path) metrics = analyzer.analyze_extended_complexity() - qpe_calculator = QPECalculator() - qpe_score = qpe_calculator.calculate_qpe(metrics) + qpe_score = calculate_qpe(metrics) if output_json: print(qpe_score.model_dump_json(indent=2)) @@ -1087,9 +1164,7 @@ def compare_projects(append_paths: tuple[Path, ...], reset: bool) -> None: from slopometry.core.complexity_analyzer import ComplexityAnalyzer from slopometry.core.language_guard import check_language_support from slopometry.core.models import LeaderboardEntry, ProjectLanguage - from slopometry.summoner.services.qpe_calculator import QPECalculator - - qpe_calculator = QPECalculator() + from slopometry.summoner.services.qpe_calculator import calculate_qpe for project_path in append_paths: project_path = project_path.resolve() @@ -1129,7 +1204,7 @@ def compare_projects(append_paths: tuple[Path, ...], reset: bool) -> None: analyzer = ComplexityAnalyzer(working_directory=project_path) metrics = analyzer.analyze_extended_complexity() - qpe_score = qpe_calculator.calculate_qpe(metrics) + qpe_score = calculate_qpe(metrics) entry = LeaderboardEntry( project_name=project_path.name, diff --git a/src/slopometry/summoner/services/baseline_service.py b/src/slopometry/summoner/services/baseline_service.py index d81dd60..27756df 100644 --- a/src/slopometry/summoner/services/baseline_service.py +++ b/src/slopometry/summoner/services/baseline_service.py @@ -5,7 +5,7 @@ import subprocess from concurrent.futures import ProcessPoolExecutor, as_completed from dataclasses import dataclass -from datetime import datetime +from datetime import datetime, timedelta from pathlib import Path from statistics import mean, median, stdev @@ -13,11 +13,13 @@ from slopometry.core.database import EventDatabase from slopometry.core.git_tracker import GitOperationError, GitTracker from slopometry.core.models import ( + BaselineStrategy, HistoricalMetricStats, RepoBaseline, + ResolvedBaselineStrategy, ) from slopometry.core.settings import settings -from slopometry.summoner.services.qpe_calculator import QPECalculator +from slopometry.summoner.services.qpe_calculator import calculate_qpe logger = logging.getLogger(__name__) @@ -46,7 +48,6 @@ def _compute_single_delta_task(repo_path: Path, parent_sha: str, child_sha: str) NOTE: Must be at module level because ProcessPoolExecutor requires picklable callables. """ git_tracker = GitTracker(repo_path) - qpe_calculator = QPECalculator() parent_dir = None child_dir = None @@ -69,12 +70,12 @@ def _compute_single_delta_task(repo_path: Path, parent_sha: str, child_sha: str) parent_cc = parent_metrics.total_complexity if parent_metrics else 0 parent_effort = parent_metrics.total_effort if parent_metrics else 0.0 parent_mi = parent_metrics.total_mi if parent_metrics else 0.0 - parent_qpe = qpe_calculator.calculate_qpe(parent_metrics).qpe if parent_metrics else 0.0 + parent_qpe = calculate_qpe(parent_metrics).qpe if parent_metrics else 0.0 child_cc = child_metrics.total_complexity if child_metrics else 0 child_effort = child_metrics.total_effort if child_metrics else 0.0 child_mi = child_metrics.total_mi if child_metrics else 0.0 - child_qpe = qpe_calculator.calculate_qpe(child_metrics).qpe if child_metrics else 0.0 + child_qpe = calculate_qpe(child_metrics).qpe if child_metrics else 0.0 return CommitDelta( cc_delta=child_cc - parent_cc, @@ -94,6 +95,21 @@ def _compute_single_delta_task(repo_path: Path, parent_sha: str, child_sha: str) shutil.rmtree(child_dir, ignore_errors=True) +def _parse_commit_log(output: str) -> list[CommitInfo]: + """Parse git log output in '%H %ct' format into CommitInfo list.""" + commits = [] + for line in output.strip().split("\n"): + line = line.strip() + if not line: + continue + parts = line.split(" ", 1) + if len(parts) == 2: + sha, timestamp_str = parts + timestamp = datetime.fromtimestamp(int(timestamp_str)) + commits.append(CommitInfo(sha=sha, timestamp=timestamp)) + return commits + + class BaselineService: """Computes and manages repository complexity baselines.""" @@ -103,15 +119,14 @@ def __init__(self, db: EventDatabase | None = None): def get_or_compute_baseline( self, repo_path: Path, recompute: bool = False, max_workers: int = 4 ) -> RepoBaseline | None: - """Get cached baseline or compute if stale (HEAD changed). - - Args: - repo_path: Path to the repository - recompute: Force recomputation even if cache is valid - max_workers: Number of parallel workers for analysis - - Returns: - RepoBaseline or None if computation fails + """Get cached baseline or compute if stale (HEAD changed or strategy mismatch). + + Cache invalidation rules: + - HEAD changed -> recompute + - Cached baseline has no qpe_stats -> recompute (legacy) + - Cached baseline has no strategy -> recompute (pre-strategy baseline) + - Explicit strategy setting doesn't match cached resolved strategy -> recompute + - AUTO accepts any concrete resolved strategy in cache """ repo_path = repo_path.resolve() git_tracker = GitTracker(repo_path) @@ -123,7 +138,8 @@ def get_or_compute_baseline( if not recompute: cached = self.db.get_cached_baseline(str(repo_path), head_sha) if cached and cached.qpe_stats is not None: - return cached + if self._is_cache_strategy_compatible(cached): + return cached baseline = self.compute_full_baseline(repo_path, max_workers=max_workers) @@ -132,19 +148,47 @@ def get_or_compute_baseline( return baseline + def _is_cache_strategy_compatible(self, cached: RepoBaseline) -> bool: + """Check if cached baseline's strategy is compatible with current settings. + + Returns True if cache can be reused, False if recomputation needed. + """ + requested = BaselineStrategy(settings.baseline_strategy) + + if cached.strategy is None: + # Legacy baseline without strategy info -> recompute + return False + + if requested == BaselineStrategy.AUTO: + # AUTO accepts any concrete resolved strategy + return True + + # Explicit strategy must match resolved + return cached.strategy.resolved == requested + def compute_full_baseline(self, repo_path: Path, max_workers: int = 4) -> RepoBaseline | None: - """Compute baseline from entire git history with parallel analysis. + """Compute baseline from git history using strategy-based commit selection. - Args: - repo_path: Path to the repository - max_workers: Number of parallel workers for commit analysis + The strategy determines which commits are selected for delta computation: + - MERGE_ANCHORED: first-parent trunk history (merge commits as quality checkpoints) + - TIME_SAMPLED: regular time-interval samples within a bounded lookback window + - AUTO: detects merge ratio and picks the best strategy - Returns: - RepoBaseline or None if computation fails + Delta computation, stats aggregation, and QPE calculation are unchanged -- + only commit selection varies. """ repo_path = repo_path.resolve() - commits = self._get_all_commits(repo_path) + strategy = self._resolve_strategy(repo_path) + + match strategy.resolved: + case BaselineStrategy.MERGE_ANCHORED: + commits = self._get_merge_anchored_commits(repo_path) + case BaselineStrategy.TIME_SAMPLED: + commits = self._get_time_sampled_commits(repo_path) + case _: + raise ValueError(f"Unexpected resolved strategy: {strategy.resolved}") + if len(commits) < 2: return None @@ -170,8 +214,7 @@ def compute_full_baseline(self, repo_path: Path, max_workers: int = 4) -> RepoBa oldest_commit_tokens = self._get_commit_token_count(repo_path, commits[-1].sha, analyzer) - qpe_calculator = QPECalculator() - current_qpe = qpe_calculator.calculate_qpe(current_metrics) + current_qpe = calculate_qpe(current_metrics) return RepoBaseline( repository_path=str(repo_path), @@ -187,12 +230,83 @@ def compute_full_baseline(self, repo_path: Path, max_workers: int = 4) -> RepoBa oldest_commit_tokens=oldest_commit_tokens, qpe_stats=self._compute_stats("qpe_delta", qpe_deltas), current_qpe=current_qpe, + strategy=strategy, + ) + + def _resolve_strategy(self, repo_path: Path) -> ResolvedBaselineStrategy: + """Resolve the baseline strategy, auto-detecting if needed.""" + requested = BaselineStrategy(settings.baseline_strategy) + + if requested != BaselineStrategy.AUTO: + return ResolvedBaselineStrategy( + requested=requested, + resolved=requested, + merge_ratio=0.0, + total_commits_sampled=0, + ) + + return self._detect_strategy(repo_path) + + def _detect_strategy(self, repo_path: Path) -> ResolvedBaselineStrategy: + """Auto-detect the best baseline strategy by examining merge commit ratio. + + Uses fast git rev-list --count operations to determine merge frequency. + If merge_ratio > threshold, use MERGE_ANCHORED. Otherwise TIME_SAMPLED. + """ + sample_size = settings.baseline_detection_sample_size + + # Count total commits (capped at sample_size) + total_result = subprocess.run( + ["git", "rev-list", "--count", f"--max-count={sample_size}", "HEAD"], + cwd=repo_path, + capture_output=True, + text=True, + timeout=10, + ) + total_commits = int(total_result.stdout.strip()) if total_result.returncode == 0 else 0 + + if total_commits == 0: + return ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.TIME_SAMPLED, + merge_ratio=0.0, + total_commits_sampled=0, + ) + + # Count merge commits in the same range + merge_result = subprocess.run( + ["git", "rev-list", "--merges", "--count", f"--max-count={sample_size}", "HEAD"], + cwd=repo_path, + capture_output=True, + text=True, + timeout=10, ) + merge_commits = int(merge_result.stdout.strip()) if merge_result.returncode == 0 else 0 - def _get_all_commits(self, repo_path: Path) -> list[CommitInfo]: - """Get all commits with timestamps in topological order (newest first).""" + merge_ratio = merge_commits / total_commits if total_commits > 0 else 0.0 + + resolved = ( + BaselineStrategy.MERGE_ANCHORED + if merge_ratio > settings.baseline_merge_ratio_threshold + else BaselineStrategy.TIME_SAMPLED + ) + + return ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=resolved, + merge_ratio=merge_ratio, + total_commits_sampled=total_commits, + ) + + def _get_merge_anchored_commits(self, repo_path: Path) -> list[CommitInfo]: + """Get commits following first-parent (trunk) history. + + --first-parent follows only the trunk line, naturally landing on merge commits. + Each delta between consecutive first-parent commits captures the net effect + of one accepted merge/PR, filtering out intermediate WIP commits on feature branches. + """ result = subprocess.run( - ["git", "log", "--format=%H %ct", "--topo-order", "HEAD"], + ["git", "log", "--first-parent", "--format=%H %ct", "--topo-order", "HEAD"], cwd=repo_path, capture_output=True, text=True, @@ -202,20 +316,61 @@ def _get_all_commits(self, repo_path: Path) -> list[CommitInfo]: if result.returncode != 0: return [] - commits = [] - for line in result.stdout.strip().split("\n"): - line = line.strip() - if not line: - continue - parts = line.split(" ", 1) - if len(parts) == 2: - sha, timestamp_str = parts - timestamp = datetime.fromtimestamp(int(timestamp_str)) - commits.append(CommitInfo(sha=sha, timestamp=timestamp)) - - # PERF: Limit commits to avoid slow analysis on large repos + commits = _parse_commit_log(result.stdout) return commits[: settings.baseline_max_commits] + def _get_time_sampled_commits(self, repo_path: Path) -> list[CommitInfo]: + """Get commits sampled at regular time intervals within a bounded lookback window. + + 1. Fetches all commits within the lookback window (--after flag) + 2. Samples one commit per interval (baseline_time_sample_interval_days) + 3. Always includes newest and oldest commits in window + 4. Falls back to evenly-spaced if interval produces too few commits + """ + lookback_date = datetime.now() - timedelta(days=settings.baseline_lookback_months * 30) + after_str = lookback_date.strftime("%Y-%m-%d") + + result = subprocess.run( + ["git", "log", f"--after={after_str}", "--format=%H %ct", "--topo-order", "HEAD"], + cwd=repo_path, + capture_output=True, + text=True, + timeout=60, + ) + + if result.returncode != 0: + return [] + + all_commits = _parse_commit_log(result.stdout) + + if len(all_commits) < 2: + return all_commits + + # Sample at regular time intervals + interval = timedelta(days=settings.baseline_time_sample_interval_days) + sampled = [all_commits[0]] # Always include newest + last_sampled_time = all_commits[0].timestamp + + for commit in all_commits[1:-1]: + if abs((last_sampled_time - commit.timestamp).total_seconds()) >= interval.total_seconds(): + sampled.append(commit) + last_sampled_time = commit.timestamp + + # Always include oldest + if all_commits[-1].sha != sampled[-1].sha: + sampled.append(all_commits[-1]) + + # Fall back to evenly-spaced if we got too few + min_commits = settings.baseline_time_sample_min_commits + if len(sampled) < min_commits and len(all_commits) >= min_commits: + step = max(1, len(all_commits) // min_commits) + sampled = all_commits[::step] + # Ensure last commit is included + if sampled[-1].sha != all_commits[-1].sha: + sampled.append(all_commits[-1]) + + return sampled[: settings.baseline_max_commits] + def _compute_deltas_parallel( self, repo_path: Path, @@ -242,16 +397,7 @@ def _compute_deltas_parallel( return deltas def _get_commit_token_count(self, repo_path: Path, commit_sha: str, analyzer: ComplexityAnalyzer) -> int | None: - """Get total token count for a specific commit. - - Args: - repo_path: Path to the repository - commit_sha: The commit SHA to analyze - analyzer: ComplexityAnalyzer instance - - Returns: - Total token count or None if analysis fails - """ + """Get total token count for a specific commit.""" git_tracker = GitTracker(repo_path) commit_dir = None diff --git a/src/slopometry/summoner/services/cli_calculator.py b/src/slopometry/summoner/services/cli_calculator.py index 3db8e46..da61613 100644 --- a/src/slopometry/summoner/services/cli_calculator.py +++ b/src/slopometry/summoner/services/cli_calculator.py @@ -5,28 +5,25 @@ - Scale-sensitive: Ratio-based scoring penalizes differently based on target magnitude - Unbounded output: Not suitable for stable RL training -Use QPECalculator from slopometry.summoner.services.qpe_calculator instead. +Use calculate_qpe() from slopometry.summoner.services.qpe_calculator instead. """ import warnings from slopometry.core.models import ExtendedComplexityMetrics, QPEScore -from slopometry.summoner.services.qpe_calculator import QPECalculator +from slopometry.summoner.services.qpe_calculator import calculate_qpe as _calculate_qpe class CLICalculator: """Calculates Completeness Likelihood Improval score. - DEPRECATED: Use QPECalculator instead. See qpe_calculator.py for the + DEPRECATED: Use calculate_qpe() instead. See qpe_calculator.py for the principled replacement that: - Uses MI as sole quality signal (no double-counting) - Normalizes by Halstead Effort for fair comparison - Produces bounded output suitable for GRPO """ - def __init__(self) -> None: - self._qpe_calculator = QPECalculator() - def calculate_qpe(self, metrics: ExtendedComplexityMetrics) -> QPEScore: """Calculate Quality-Per-Effort score (recommended). @@ -38,7 +35,7 @@ def calculate_qpe(self, metrics: ExtendedComplexityMetrics) -> QPEScore: Returns: QPEScore with component breakdown """ - return self._qpe_calculator.calculate_qpe(metrics) + return _calculate_qpe(metrics) def calculate_cli( self, current: ExtendedComplexityMetrics, target: ExtendedComplexityMetrics diff --git a/src/slopometry/summoner/services/current_impact_service.py b/src/slopometry/summoner/services/current_impact_service.py index b99e981..6cca502 100644 --- a/src/slopometry/summoner/services/current_impact_service.py +++ b/src/slopometry/summoner/services/current_impact_service.py @@ -13,12 +13,14 @@ CurrentChangesAnalysis, ExtendedComplexityMetrics, GalenMetrics, + QPEScore, RepoBaseline, + SmellAdvantage, ) from slopometry.core.working_tree_extractor import WorkingTreeExtractor from slopometry.core.working_tree_state import WorkingTreeStateCalculator from slopometry.summoner.services.impact_calculator import ImpactCalculator -from slopometry.summoner.services.qpe_calculator import QPECalculator +from slopometry.summoner.services.qpe_calculator import calculate_qpe, smell_advantage logger = logging.getLogger(__name__) @@ -62,7 +64,7 @@ def analyze_uncommitted_changes( current_metrics = self._get_or_compute_metrics(repo_path, commit_sha, working_tree_hash, extractor, analyzer) - current_delta = self._compute_delta(baseline_metrics, current_metrics) + current_delta, smell_advantages, _, _ = self._compute_delta(baseline_metrics, current_metrics) assessment = self.impact_calculator.calculate_impact(current_delta, baseline) @@ -117,6 +119,7 @@ def get_token_count(path_str: str) -> int: changed_files_tokens=changed_files_tokens, complete_picture_context_size=complete_picture_context_size, galen_metrics=galen_metrics, + smell_advantages=smell_advantages, ) def analyze_previous_commit( @@ -191,7 +194,7 @@ def analyze_previous_commit( return None # Use parent as baseline, HEAD as current - current_delta = self._compute_delta(parent_metrics, head_metrics) + current_delta, smell_advantages, _, _ = self._compute_delta(parent_metrics, head_metrics) assessment = self.impact_calculator.calculate_impact(current_delta, baseline) from slopometry.core.context_coverage_analyzer import ContextCoverageAnalyzer @@ -229,6 +232,7 @@ def analyze_previous_commit( changed_files_tokens=changed_files_tokens, complete_picture_context_size=complete_picture_context_size, galen_metrics=galen_metrics, + smell_advantages=smell_advantages, ) def _calculate_galen_metrics( @@ -319,13 +323,16 @@ def _compute_delta( self, baseline_metrics: ExtendedComplexityMetrics, current_metrics: ExtendedComplexityMetrics, - ) -> ComplexityDelta: - """Compute complexity delta between baseline and current metrics.""" - qpe_calculator = QPECalculator() - baseline_qpe = qpe_calculator.calculate_qpe(baseline_metrics).qpe - current_qpe = qpe_calculator.calculate_qpe(current_metrics).qpe + ) -> tuple[ComplexityDelta, list[SmellAdvantage], QPEScore, QPEScore]: + """Compute complexity delta between baseline and current metrics. - return ComplexityDelta( + Returns: + Tuple of (delta, smell_advantages, baseline_qpe_score, current_qpe_score) + """ + baseline_qpe_score = calculate_qpe(baseline_metrics) + current_qpe_score = calculate_qpe(current_metrics) + + delta = ComplexityDelta( total_complexity_change=(current_metrics.total_complexity - baseline_metrics.total_complexity), avg_complexity_change=(current_metrics.average_complexity - baseline_metrics.average_complexity), total_volume_change=(current_metrics.total_volume - baseline_metrics.total_volume), @@ -336,5 +343,9 @@ def _compute_delta( total_mi_change=current_metrics.total_mi - baseline_metrics.total_mi, avg_mi_change=current_metrics.average_mi - baseline_metrics.average_mi, net_files_change=(current_metrics.total_files_analyzed - baseline_metrics.total_files_analyzed), - qpe_change=current_qpe - baseline_qpe, + qpe_change=current_qpe_score.qpe - baseline_qpe_score.qpe, ) + + advantages = smell_advantage(baseline_qpe_score, current_qpe_score) + + return delta, advantages, baseline_qpe_score, current_qpe_score diff --git a/src/slopometry/summoner/services/implementation_comparator.py b/src/slopometry/summoner/services/implementation_comparator.py new file mode 100644 index 0000000..2d59694 --- /dev/null +++ b/src/slopometry/summoner/services/implementation_comparator.py @@ -0,0 +1,140 @@ +"""Subtree-prefix-aware implementation comparator for GRPO reward signals. + +Compares two code subtrees (e.g., two implementations of the same feature living +side-by-side in the repo) by analyzing each independently with QPE and computing +a bounded advantage signal suitable for GRPO training. +""" + +import logging +import subprocess +import tarfile +import tempfile +from io import BytesIO +from pathlib import Path + +from slopometry.core.complexity_analyzer import ComplexityAnalyzer +from slopometry.core.models import ImplementationComparison +from slopometry.summoner.services.qpe_calculator import ( + calculate_qpe, + grpo_advantage, + smell_advantage, +) + +logger = logging.getLogger(__name__) + +_TIE_DEADBAND = 0.01 + + +class SubtreeExtractionError(Exception): + """Raised when git archive fails to extract a subtree prefix.""" + + +def compare_subtrees( + repo_path: Path, + prefix_a: str, + prefix_b: str, + ref: str = "HEAD", +) -> ImplementationComparison | None: + """Compare two subtree prefixes from the same git ref. + + Extracts Python files under each prefix via git archive, runs + ComplexityAnalyzer on each, computes QPE scores, and returns the + aggregate GRPO advantage with per-smell decomposition. + + Args: + repo_path: Path to the git repository + prefix_a: Subtree path prefix for implementation A + prefix_b: Subtree path prefix for implementation B + ref: Git ref to extract from (default: HEAD) + + Returns: + ImplementationComparison or None if either subtree has no Python files + """ + repo_path = repo_path.resolve() + + with ( + tempfile.TemporaryDirectory(prefix="slopometry_compare_a_") as dir_a_str, + tempfile.TemporaryDirectory(prefix="slopometry_compare_b_") as dir_b_str, + ): + dir_a = Path(dir_a_str) + dir_b = Path(dir_b_str) + + extracted_a = _extract_subtree(repo_path, ref, prefix_a, dir_a) + if not extracted_a: + logger.warning(f"No Python files found under prefix '{prefix_a}' at ref '{ref}'") + return None + + extracted_b = _extract_subtree(repo_path, ref, prefix_b, dir_b) + if not extracted_b: + logger.warning(f"No Python files found under prefix '{prefix_b}' at ref '{ref}'") + return None + + analyzer = ComplexityAnalyzer(working_directory=repo_path) + metrics_a = analyzer.analyze_extended_complexity(dir_a) + metrics_b = analyzer.analyze_extended_complexity(dir_b) + + qpe_a = calculate_qpe(metrics_a) + qpe_b = calculate_qpe(metrics_b) + + aggregate = grpo_advantage(qpe_a, qpe_b) + smell_advantages = smell_advantage(qpe_a, qpe_b) + + if abs(aggregate) < _TIE_DEADBAND: + winner = "tie" + elif aggregate > 0: + winner = prefix_b + else: + winner = prefix_a + + return ImplementationComparison( + prefix_a=prefix_a, + prefix_b=prefix_b, + ref=ref, + qpe_a=qpe_a, + qpe_b=qpe_b, + aggregate_advantage=aggregate, + smell_advantages=smell_advantages, + winner=winner, + ) + + +def _extract_subtree(repo_path: Path, ref: str, prefix: str, dest_dir: Path) -> bool: + """Extract Python files from a subtree prefix via git archive. + + Uses `git archive --format=tar -- ` to extract only + files under the given prefix. + + Args: + repo_path: Path to the git repository + ref: Git ref to extract from + prefix: Subtree path prefix to extract + dest_dir: Destination directory for extracted files + + Returns: + True if Python files were extracted, False otherwise + + Raises: + SubtreeExtractionError: If git archive fails + """ + result = subprocess.run( + ["git", "archive", "--format=tar", ref, "--", prefix], + cwd=repo_path, + capture_output=True, + timeout=60, + ) + + if result.returncode != 0: + stderr = result.stderr.decode().strip() + raise SubtreeExtractionError(f"git archive failed for prefix '{prefix}' at ref '{ref}': {stderr}") + + tar_data = BytesIO(result.stdout) + try: + with tarfile.open(fileobj=tar_data, mode="r") as tar: + python_members = [m for m in tar.getmembers() if m.name.endswith(".py")] + if not python_members: + return False + tar.extractall(path=dest_dir, members=python_members, filter="data") + except tarfile.TarError as e: + raise SubtreeExtractionError(f"Failed to extract tar for prefix '{prefix}': {e}") from e + + return True diff --git a/src/slopometry/summoner/services/qpe_calculator.py b/src/slopometry/summoner/services/qpe_calculator.py index 54d70b6..733b0fa 100644 --- a/src/slopometry/summoner/services/qpe_calculator.py +++ b/src/slopometry/summoner/services/qpe_calculator.py @@ -15,93 +15,91 @@ from slopometry.core.complexity_analyzer import ComplexityAnalyzer from slopometry.core.models import ( + SMELL_REGISTRY, CrossProjectComparison, ExtendedComplexityMetrics, ProjectQPEResult, QPEScore, + SmellAdvantage, ) from slopometry.core.settings import settings -class QPECalculator: - """Quality-Per-Effort calculator for principled comparison.""" +def calculate_qpe(metrics: ExtendedComplexityMetrics) -> QPEScore: + """Calculate quality score. - def calculate_qpe(self, metrics: ExtendedComplexityMetrics) -> QPEScore: - """Calculate quality score. + Formula: + qpe = mi_normalized * (1 - smell_penalty) + bonuses - Formula: - qpe = mi_normalized * (1 - smell_penalty) + bonuses + Where: + mi_normalized = average_mi / 100.0 + smell_penalty = 0.9 * (1 - exp(-smell_penalty_raw * steepness)) + smell_penalty_raw = weighted_smell_sum / effective_files + bonuses = test_bonus + type_bonus + docstring_bonus - Where: - mi_normalized = average_mi / 100.0 - smell_penalty = 0.9 * (1 - exp(-smell_penalty_raw * steepness)) - smell_penalty_raw = weighted_smell_sum / effective_files - bonuses = test_bonus + type_bonus + docstring_bonus + Smell penalty uses: + - Effective files (files with min LOC) to prevent gaming via tiny files + - No effort multiplier: all smells penalize equally + - Sigmoid saturation instead of hard cap - Smell penalty uses: - - Effective files (files with min LOC) to prevent gaming via tiny files - - No effort multiplier: all smells penalize equally - - Sigmoid saturation instead of hard cap + Bonuses (positive signals): + - Test coverage bonus when >= threshold + - Type hint coverage bonus when >= threshold + - Docstring coverage bonus when >= threshold - Bonuses (positive signals): - - Test coverage bonus when >= threshold - - Type hint coverage bonus when >= threshold - - Docstring coverage bonus when >= threshold - - Args: - metrics: Extended complexity metrics for the codebase - - Returns: - QPEScore with component breakdown - """ - mi_normalized = metrics.average_mi / 100.0 - - smell_counts: dict[str, int] = {} - weighted_smell_sum = 0.0 - - for smell in metrics.get_smells(): - smell_counts[smell.name] = smell.count - weighted_smell_sum += smell.count * smell.weight + Args: + metrics: Extended complexity metrics for the codebase - # Use files_by_loc for anti-gaming file filtering, fallback to total_files - if metrics.files_by_loc: - effective_files = sum(1 for loc in metrics.files_by_loc.values() if loc >= settings.qpe_min_loc_per_file) - else: - effective_files = metrics.total_files_analyzed + Returns: + QPEScore with component breakdown + """ + mi_normalized = metrics.average_mi / 100.0 - total_files = max(effective_files, 1) - smell_penalty_raw = weighted_smell_sum / total_files + smell_counts = metrics.get_smell_counts() + weighted_smell_sum = 0.0 - # Sigmoid saturation with configurable steepness (approaches 0.9 asymptotically) - smell_penalty = 0.9 * (1 - math.exp(-smell_penalty_raw * settings.qpe_sigmoid_steepness)) + for smell in metrics.get_smells(): + weighted_smell_sum += smell.count * smell.weight - # Positive bonuses (configurable thresholds and amounts) - test_bonus = ( - settings.qpe_test_coverage_bonus - if (metrics.test_coverage_percent or 0) >= settings.qpe_test_coverage_threshold - else 0.0 - ) - type_bonus = ( - settings.qpe_type_coverage_bonus - if metrics.type_hint_coverage >= settings.qpe_type_coverage_threshold - else 0.0 - ) - docstring_bonus = ( - settings.qpe_docstring_coverage_bonus - if metrics.docstring_coverage >= settings.qpe_docstring_coverage_threshold - else 0.0 - ) - total_bonus = test_bonus + type_bonus + docstring_bonus - - adjusted_quality = mi_normalized * (1 - smell_penalty) + total_bonus - - return QPEScore( - qpe=adjusted_quality, - mi_normalized=mi_normalized, - smell_penalty=smell_penalty, - adjusted_quality=adjusted_quality, - smell_counts=smell_counts, - ) + # Use files_by_loc for anti-gaming file filtering, fallback to total_files + if metrics.files_by_loc: + effective_files = sum(1 for loc in metrics.files_by_loc.values() if loc >= settings.qpe_min_loc_per_file) + else: + effective_files = metrics.total_files_analyzed + + total_files = max(effective_files, 1) + smell_penalty_raw = weighted_smell_sum / total_files + + # Sigmoid saturation with configurable steepness (approaches 0.9 asymptotically) + smell_penalty = 0.9 * (1 - math.exp(-smell_penalty_raw * settings.qpe_sigmoid_steepness)) + + # Positive bonuses (configurable thresholds and amounts) + test_bonus = ( + settings.qpe_test_coverage_bonus + if (metrics.test_coverage_percent or 0) >= settings.qpe_test_coverage_threshold + else 0.0 + ) + type_bonus = ( + settings.qpe_type_coverage_bonus + if metrics.type_hint_coverage >= settings.qpe_type_coverage_threshold + else 0.0 + ) + docstring_bonus = ( + settings.qpe_docstring_coverage_bonus + if metrics.docstring_coverage >= settings.qpe_docstring_coverage_threshold + else 0.0 + ) + total_bonus = test_bonus + type_bonus + docstring_bonus + + adjusted_quality = mi_normalized * (1 - smell_penalty) + total_bonus + + return QPEScore( + qpe=adjusted_quality, + mi_normalized=mi_normalized, + smell_penalty=smell_penalty, + adjusted_quality=adjusted_quality, + smell_counts=smell_counts, + ) def grpo_advantage(baseline: QPEScore, candidate: QPEScore) -> float: @@ -133,78 +131,107 @@ def grpo_advantage(baseline: QPEScore, candidate: QPEScore) -> float: return math.tanh(relative_improvement) -class CrossProjectComparator: - """Compare multiple projects using QPE.""" +def smell_advantage(baseline: QPEScore, candidate: QPEScore) -> list[SmellAdvantage]: + """Decompose the aggregate GRPO advantage into per-smell contributions. + + Uses smell weights from SMELL_REGISTRY to compute weighted deltas for each + smell type. Iterates all registered smells since SmellCounts always has all + fields (defaulting to 0), so there are no asymmetric key sets. + + The primary signal remains aggregate grpo_advantage(); this decomposition + is auxiliary for interpretability and optional per-smell reward shaping. + + Args: + baseline: QPE score of the baseline/reference implementation + candidate: QPE score of the candidate implementation - def __init__(self) -> None: - self.qpe_calculator = QPECalculator() + Returns: + List of SmellAdvantage sorted by absolute weighted_delta (highest impact first) + """ + advantages = [] + for name, defn in SMELL_REGISTRY.items(): + baseline_count = getattr(baseline.smell_counts, name) + candidate_count = getattr(candidate.smell_counts, name) + weighted_delta = (candidate_count - baseline_count) * defn.weight + + advantages.append( + SmellAdvantage( + smell_name=name, + baseline_count=baseline_count, + candidate_count=candidate_count, + weight=defn.weight, + weighted_delta=weighted_delta, + ) + ) - def compare( - self, - project_paths: list[Path], - ) -> CrossProjectComparison: - """Compare projects by QPE, ranked from highest to lowest. + return sorted(advantages, key=lambda a: abs(a.weighted_delta), reverse=True) - Args: - project_paths: List of paths to project directories - Returns: - CrossProjectComparison with flat rankings - """ - results: list[ProjectQPEResult] = [] +def compare_projects( + project_paths: list[Path], +) -> CrossProjectComparison: + """Compare projects by QPE, ranked from highest to lowest. - for project_path in project_paths: - analyzer = ComplexityAnalyzer(working_directory=project_path) - metrics = analyzer.analyze_extended_complexity() - qpe_score = self.qpe_calculator.calculate_qpe(metrics) + Args: + project_paths: List of paths to project directories - results.append( - ProjectQPEResult( - project_path=str(project_path), - project_name=project_path.name, - qpe_score=qpe_score, - metrics=metrics, - ) + Returns: + CrossProjectComparison with flat rankings + """ + results: list[ProjectQPEResult] = [] + + for project_path in project_paths: + analyzer = ComplexityAnalyzer(working_directory=project_path) + metrics = analyzer.analyze_extended_complexity() + qpe_score = calculate_qpe(metrics) + + results.append( + ProjectQPEResult( + project_path=str(project_path), + project_name=project_path.name, + qpe_score=qpe_score, + metrics=metrics, ) + ) - rankings = sorted(results, key=lambda x: x.qpe_score.qpe, reverse=True) + rankings = sorted(results, key=lambda x: x.qpe_score.qpe, reverse=True) - return CrossProjectComparison( - total_projects=len(results), - rankings=rankings, - ) + return CrossProjectComparison( + total_projects=len(results), + rankings=rankings, + ) - def compare_metrics( - self, - metrics_list: list[tuple[str, ExtendedComplexityMetrics]], - ) -> CrossProjectComparison: - """Compare pre-computed metrics by QPE. - Useful when metrics are already available (e.g., from database). +def compare_project_metrics( + metrics_list: list[tuple[str, ExtendedComplexityMetrics]], +) -> CrossProjectComparison: + """Compare pre-computed metrics by QPE. - Args: - metrics_list: List of (project_name, metrics) tuples + Useful when metrics are already available (e.g., from database). + + Args: + metrics_list: List of (project_name, metrics) tuples - Returns: - CrossProjectComparison with flat rankings - """ - results: list[ProjectQPEResult] = [] + Returns: + CrossProjectComparison with flat rankings + """ + results: list[ProjectQPEResult] = [] - for project_name, metrics in metrics_list: - qpe_score = self.qpe_calculator.calculate_qpe(metrics) + for project_name, metrics in metrics_list: + qpe_score = calculate_qpe(metrics) - results.append( - ProjectQPEResult( - project_path="", - project_name=project_name, - qpe_score=qpe_score, - metrics=metrics, - ) + results.append( + ProjectQPEResult( + project_path="", + project_name=project_name, + qpe_score=qpe_score, + metrics=metrics, ) + ) - rankings = sorted(results, key=lambda x: x.qpe_score.qpe, reverse=True) + rankings = sorted(results, key=lambda x: x.qpe_score.qpe, reverse=True) - return CrossProjectComparison( - total_projects=len(results), - rankings=rankings, - ) + return CrossProjectComparison( + total_projects=len(results), + rankings=rankings, + ) diff --git a/tests/test_baseline_service.py b/tests/test_baseline_service.py index cab033a..adb787d 100644 --- a/tests/test_baseline_service.py +++ b/tests/test_baseline_service.py @@ -1,16 +1,24 @@ """Tests for baseline_service.py.""" -from datetime import datetime +from datetime import datetime, timedelta from pathlib import Path from unittest.mock import MagicMock, patch from conftest import make_test_metrics -from slopometry.core.models import ExtendedComplexityMetrics, HistoricalMetricStats, QPEScore, RepoBaseline +from slopometry.core.models import ( + BaselineStrategy, + ExtendedComplexityMetrics, + HistoricalMetricStats, + QPEScore, + RepoBaseline, + ResolvedBaselineStrategy, +) from slopometry.summoner.services.baseline_service import ( BaselineService, CommitInfo, _compute_single_delta_task, + _parse_commit_log, ) @@ -184,6 +192,12 @@ def test_get_or_compute_baseline__returns_cached_when_head_unchanged(self, tmp_p adjusted_quality=0.45, smell_counts={}, ), + strategy=ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.MERGE_ANCHORED, + merge_ratio=0.25, + total_commits_sampled=200, + ), ) mock_db.get_cached_baseline.return_value = cached_baseline @@ -301,7 +315,16 @@ def test_compute_full_baseline__returns_none_with_less_than_2_commits(self, tmp_ mock_db = MagicMock() service = BaselineService(db=mock_db) - with patch.object(service, "_get_all_commits") as mock_get_commits: + with ( + patch.object(service, "_resolve_strategy") as mock_resolve, + patch.object(service, "_get_merge_anchored_commits") as mock_get_commits, + ): + mock_resolve.return_value = ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.MERGE_ANCHORED, + merge_ratio=0.25, + total_commits_sampled=200, + ) mock_get_commits.return_value = [CommitInfo(sha="abc123", timestamp=datetime.now())] result = service.compute_full_baseline(tmp_path) @@ -319,10 +342,17 @@ def test_compute_full_baseline__returns_none_when_no_deltas(self, tmp_path: Path ] with ( - patch.object(service, "_get_all_commits") as mock_get_commits, + patch.object(service, "_resolve_strategy") as mock_resolve, + patch.object(service, "_get_time_sampled_commits") as mock_get_commits, patch.object(service, "_compute_deltas_parallel") as mock_deltas, patch("slopometry.summoner.services.baseline_service.ComplexityAnalyzer") as MockAnalyzer, ): + mock_resolve.return_value = ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.TIME_SAMPLED, + merge_ratio=0.05, + total_commits_sampled=200, + ) mock_get_commits.return_value = commits mock_deltas.return_value = [] # No deltas computed MockAnalyzer.return_value.analyze_extended_complexity.return_value = ExtendedComplexityMetrics( @@ -391,3 +421,256 @@ def test_compute_single_delta_task__computes_delta_correctly(self, tmp_path: Pat assert result.cc_delta == 5 # 15 - 10 assert result.effort_delta == 50.0 # 150 - 100 assert result.mi_delta == -5.0 # 75 - 80 + + +def test_parse_commit_log__parses_valid_output() -> None: + """Test parsing valid git log output.""" + output = "abc123 1700000000\ndef456 1699999000\n" + commits = _parse_commit_log(output) + + assert len(commits) == 2 + assert commits[0].sha == "abc123" + assert commits[1].sha == "def456" + + +def test_parse_commit_log__handles_empty_output() -> None: + """Test parsing empty output.""" + commits = _parse_commit_log("") + assert commits == [] + + +def test_parse_commit_log__skips_blank_lines() -> None: + """Test that blank lines are skipped.""" + output = "abc123 1700000000\n\ndef456 1699999000\n\n" + commits = _parse_commit_log(output) + assert len(commits) == 2 + + +def test_detect_strategy__returns_merge_anchored_above_threshold(tmp_path: Path) -> None: + """Test auto-detection selects MERGE_ANCHORED when merge ratio exceeds threshold.""" + service = BaselineService(db=MagicMock()) + + with patch("slopometry.summoner.services.baseline_service.subprocess.run") as mock_run: + mock_result_total = MagicMock() + mock_result_total.returncode = 0 + mock_result_total.stdout = "100" + + mock_result_merges = MagicMock() + mock_result_merges.returncode = 0 + mock_result_merges.stdout = "25" + + mock_run.side_effect = [mock_result_total, mock_result_merges] + + result = service._detect_strategy(tmp_path) + + assert result.resolved == BaselineStrategy.MERGE_ANCHORED + assert result.requested == BaselineStrategy.AUTO + assert result.merge_ratio == 0.25 + assert result.total_commits_sampled == 100 + + +def test_detect_strategy__returns_time_sampled_below_threshold(tmp_path: Path) -> None: + """Test auto-detection selects TIME_SAMPLED when merge ratio is below threshold.""" + service = BaselineService(db=MagicMock()) + + with patch("slopometry.summoner.services.baseline_service.subprocess.run") as mock_run: + mock_result_total = MagicMock() + mock_result_total.returncode = 0 + mock_result_total.stdout = "100" + + mock_result_merges = MagicMock() + mock_result_merges.returncode = 0 + mock_result_merges.stdout = "5" + + mock_run.side_effect = [mock_result_total, mock_result_merges] + + result = service._detect_strategy(tmp_path) + + assert result.resolved == BaselineStrategy.TIME_SAMPLED + assert result.merge_ratio == 0.05 + + +def test_detect_strategy__falls_back_to_time_sampled_on_zero_commits(tmp_path: Path) -> None: + """Test auto-detection falls back to TIME_SAMPLED when no commits found.""" + service = BaselineService(db=MagicMock()) + + with patch("slopometry.summoner.services.baseline_service.subprocess.run") as mock_run: + mock_result = MagicMock() + mock_result.returncode = 0 + mock_result.stdout = "0" + + mock_run.return_value = mock_result + + result = service._detect_strategy(tmp_path) + + assert result.resolved == BaselineStrategy.TIME_SAMPLED + assert result.merge_ratio == 0.0 + + +def test_resolve_strategy__explicit_merge_anchored_skips_detection(tmp_path: Path) -> None: + """Test explicit MERGE_ANCHORED doesn't run detection.""" + service = BaselineService(db=MagicMock()) + + with ( + patch.object(service, "_detect_strategy") as mock_detect, + patch("slopometry.summoner.services.baseline_service.settings") as mock_settings, + ): + mock_settings.baseline_strategy = "merge_anchored" + + result = service._resolve_strategy(tmp_path) + + mock_detect.assert_not_called() + assert result.resolved == BaselineStrategy.MERGE_ANCHORED + assert result.requested == BaselineStrategy.MERGE_ANCHORED + + +def test_resolve_strategy__auto_runs_detection(tmp_path: Path) -> None: + """Test AUTO strategy runs detection.""" + service = BaselineService(db=MagicMock()) + expected = ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.TIME_SAMPLED, + merge_ratio=0.05, + total_commits_sampled=100, + ) + + with ( + patch.object(service, "_detect_strategy", return_value=expected) as mock_detect, + patch("slopometry.summoner.services.baseline_service.settings") as mock_settings, + ): + mock_settings.baseline_strategy = "auto" + + result = service._resolve_strategy(tmp_path) + + mock_detect.assert_called_once_with(tmp_path) + assert result == expected + + +def test_cache_compatible__legacy_baseline_without_strategy_triggers_recompute() -> None: + """Test that legacy baselines without strategy trigger recomputation.""" + service = BaselineService(db=MagicMock()) + cached = MagicMock() + cached.strategy = None + + with patch("slopometry.summoner.services.baseline_service.settings") as mock_settings: + mock_settings.baseline_strategy = "auto" + assert service._is_cache_strategy_compatible(cached) is False + + +def test_cache_compatible__auto_accepts_any_concrete_strategy() -> None: + """Test that AUTO accepts any concrete resolved strategy from cache.""" + service = BaselineService(db=MagicMock()) + cached = MagicMock() + cached.strategy = ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.MERGE_ANCHORED, + merge_ratio=0.25, + total_commits_sampled=200, + ) + + with patch("slopometry.summoner.services.baseline_service.settings") as mock_settings: + mock_settings.baseline_strategy = "auto" + assert service._is_cache_strategy_compatible(cached) is True + + +def test_cache_compatible__explicit_match_returns_true() -> None: + """Test that explicit strategy matching cached resolved returns True.""" + service = BaselineService(db=MagicMock()) + cached = MagicMock() + cached.strategy = ResolvedBaselineStrategy( + requested=BaselineStrategy.MERGE_ANCHORED, + resolved=BaselineStrategy.MERGE_ANCHORED, + merge_ratio=0.0, + total_commits_sampled=0, + ) + + with patch("slopometry.summoner.services.baseline_service.settings") as mock_settings: + mock_settings.baseline_strategy = "merge_anchored" + assert service._is_cache_strategy_compatible(cached) is True + + +def test_cache_compatible__explicit_mismatch_returns_false() -> None: + """Test that explicit strategy not matching cached resolved returns False.""" + service = BaselineService(db=MagicMock()) + cached = MagicMock() + cached.strategy = ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.MERGE_ANCHORED, + merge_ratio=0.25, + total_commits_sampled=200, + ) + + with patch("slopometry.summoner.services.baseline_service.settings") as mock_settings: + mock_settings.baseline_strategy = "time_sampled" + assert service._is_cache_strategy_compatible(cached) is False + + +def test_get_time_sampled_commits__includes_newest_and_oldest(tmp_path: Path) -> None: + """Test that time-sampled always includes newest and oldest commits.""" + service = BaselineService(db=MagicMock()) + + now = datetime.now() + commits_output = "\n".join(f"sha{i} {int((now - timedelta(days=i * 2)).timestamp())}" for i in range(30)) + + with patch("slopometry.summoner.services.baseline_service.subprocess.run") as mock_run: + mock_result = MagicMock() + mock_result.returncode = 0 + mock_result.stdout = commits_output + mock_run.return_value = mock_result + + result = service._get_time_sampled_commits(tmp_path) + + assert result[0].sha == "sha0" # Newest + assert result[-1].sha == "sha29" # Oldest + + +def test_get_time_sampled_commits__returns_empty_on_git_failure(tmp_path: Path) -> None: + """Test that empty list is returned on git failure.""" + service = BaselineService(db=MagicMock()) + + with patch("slopometry.summoner.services.baseline_service.subprocess.run") as mock_run: + mock_result = MagicMock() + mock_result.returncode = 1 + mock_run.return_value = mock_result + + result = service._get_time_sampled_commits(tmp_path) + + assert result == [] + + +def test_get_merge_anchored_commits__uses_first_parent_flag(tmp_path: Path) -> None: + """Test that --first-parent flag is passed to git log.""" + service = BaselineService(db=MagicMock()) + + with patch("slopometry.summoner.services.baseline_service.subprocess.run") as mock_run: + mock_result = MagicMock() + mock_result.returncode = 0 + mock_result.stdout = "abc123 1700000000\n" + mock_run.return_value = mock_result + + service._get_merge_anchored_commits(tmp_path) + + call_args = mock_run.call_args[0][0] + assert "--first-parent" in call_args + + +def test_get_merge_anchored_commits__respects_max_commits(tmp_path: Path) -> None: + """Test that result is capped by baseline_max_commits.""" + service = BaselineService(db=MagicMock()) + + now = datetime.now() + commits_output = "\n".join(f"sha{i} {int((now - timedelta(hours=i)).timestamp())}" for i in range(200)) + + with ( + patch("slopometry.summoner.services.baseline_service.subprocess.run") as mock_run, + patch("slopometry.summoner.services.baseline_service.settings") as mock_settings, + ): + mock_settings.baseline_max_commits = 50 + mock_result = MagicMock() + mock_result.returncode = 0 + mock_result.stdout = commits_output + mock_run.return_value = mock_result + + result = service._get_merge_anchored_commits(tmp_path) + + assert len(result) == 50 diff --git a/tests/test_database.py b/tests/test_database.py index bc38f34..9f93212 100644 --- a/tests/test_database.py +++ b/tests/test_database.py @@ -38,29 +38,25 @@ def test_user_story_export_functionality() -> None: assert output_path.exists(), "Export file was not created" assert output_path.stat().st_size > 0, "Export file is empty" - try: - import pandas as pd - - df = pd.read_parquet(output_path) - - expected_columns = [ - "id", - "created_at", - "base_commit", - "head_commit", - "diff_content", - "user_stories", - "rating", - "guidelines_for_improving", - "model_used", - "prompt_template", - "repository_path", - ] - assert all(col in df.columns for col in expected_columns) - assert len(df) >= 1 - - except ImportError: - pass + import pandas as pd + + df = pd.read_parquet(output_path) + + expected_columns = [ + "id", + "created_at", + "base_commit", + "head_commit", + "diff_content", + "user_stories", + "rating", + "guidelines_for_improving", + "model_used", + "prompt_template", + "repository_path", + ] + assert all(col in df.columns for col in expected_columns) + assert len(df) >= 1 finally: if output_path.exists(): diff --git a/tests/test_implementation_comparator.py b/tests/test_implementation_comparator.py new file mode 100644 index 0000000..4450a07 --- /dev/null +++ b/tests/test_implementation_comparator.py @@ -0,0 +1,221 @@ +"""Tests for implementation_comparator.py.""" + +import io +import json +import tarfile +from pathlib import Path +from unittest.mock import MagicMock, patch + +import pytest +from conftest import make_test_metrics + +from slopometry.core.models import ExtendedComplexityMetrics, QPEScore +from slopometry.summoner.services.implementation_comparator import ( + SubtreeExtractionError, + _extract_subtree, + compare_subtrees, +) + + +def _make_tar_with_python(name: str = "vendor/lib-a/main.py", content: bytes = b"print('hello')") -> bytes: + """Create a tar archive containing a single Python file.""" + buf = io.BytesIO() + with tarfile.open(fileobj=buf, mode="w") as tar: + info = tarfile.TarInfo(name=name) + info.size = len(content) + tar.addfile(info, io.BytesIO(content)) + return buf.getvalue() + + +def _make_tar_without_python() -> bytes: + """Create a tar archive with no Python files.""" + buf = io.BytesIO() + with tarfile.open(fileobj=buf, mode="w") as tar: + info = tarfile.TarInfo(name="vendor/lib-a/README.md") + info.size = 5 + tar.addfile(info, io.BytesIO(b"hello")) + return buf.getvalue() + + +def test_extract_subtree__returns_false_when_no_python_files(tmp_path: Path) -> None: + """Test that False is returned when no .py files exist in the archive.""" + with patch("slopometry.summoner.services.implementation_comparator.subprocess.run") as mock_run: + mock_result = MagicMock() + mock_result.returncode = 0 + mock_result.stdout = _make_tar_without_python() + mock_run.return_value = mock_result + + result = _extract_subtree(tmp_path, "HEAD", "vendor/lib-a", tmp_path / "dest") + + assert result is False + + +def test_extract_subtree__returns_true_when_python_files_extracted(tmp_path: Path) -> None: + """Test that True is returned when .py files are extracted.""" + dest_dir = tmp_path / "dest" + dest_dir.mkdir() + + with patch("slopometry.summoner.services.implementation_comparator.subprocess.run") as mock_run: + mock_result = MagicMock() + mock_result.returncode = 0 + mock_result.stdout = _make_tar_with_python() + mock_run.return_value = mock_result + + result = _extract_subtree(tmp_path, "HEAD", "vendor/lib-a", dest_dir) + + assert result is True + + +def test_extract_subtree__raises_on_git_failure(tmp_path: Path) -> None: + """Test that SubtreeExtractionError is raised on git archive failure.""" + with patch("slopometry.summoner.services.implementation_comparator.subprocess.run") as mock_run: + mock_result = MagicMock() + mock_result.returncode = 128 + mock_result.stderr = b"fatal: not a valid object name" + mock_run.return_value = mock_result + + with pytest.raises(SubtreeExtractionError, match="git archive failed"): + _extract_subtree(tmp_path, "HEAD", "vendor/nonexistent", tmp_path / "dest") + + +def test_compare_subtrees__returns_none_when_prefix_a_has_no_python(tmp_path: Path) -> None: + """Test returns None when first prefix has no Python files.""" + with patch( + "slopometry.summoner.services.implementation_comparator._extract_subtree", + side_effect=[False, True], + ): + result = compare_subtrees(tmp_path, "vendor/lib-a", "vendor/lib-b") + + assert result is None + + +def test_compare_subtrees__returns_none_when_prefix_b_has_no_python(tmp_path: Path) -> None: + """Test returns None when second prefix has no Python files.""" + with patch( + "slopometry.summoner.services.implementation_comparator._extract_subtree", + side_effect=[True, False], + ): + result = compare_subtrees(tmp_path, "vendor/lib-a", "vendor/lib-b") + + assert result is None + + +def test_compare_subtrees__returns_comparison_with_winner(tmp_path: Path) -> None: + """Test returns valid ImplementationComparison with winner determination.""" + metrics_a = ExtendedComplexityMetrics(**make_test_metrics(average_mi=60.0, total_files_analyzed=5)) + metrics_b = ExtendedComplexityMetrics(**make_test_metrics(average_mi=80.0, total_files_analyzed=5)) + + qpe_a = QPEScore(qpe=0.5, mi_normalized=0.6, smell_penalty=0.1, adjusted_quality=0.5) + qpe_b = QPEScore(qpe=0.7, mi_normalized=0.8, smell_penalty=0.05, adjusted_quality=0.7) + + with ( + patch( + "slopometry.summoner.services.implementation_comparator._extract_subtree", + return_value=True, + ), + patch("slopometry.summoner.services.implementation_comparator.ComplexityAnalyzer") as MockAnalyzer, + patch("slopometry.summoner.services.implementation_comparator.calculate_qpe") as mock_calc_qpe, + ): + MockAnalyzer.return_value.analyze_extended_complexity.side_effect = [metrics_a, metrics_b] + mock_calc_qpe.side_effect = [qpe_a, qpe_b] + + result = compare_subtrees(tmp_path, "vendor/lib-a", "vendor/lib-b", ref="main") + + assert result is not None + assert result.prefix_a == "vendor/lib-a" + assert result.prefix_b == "vendor/lib-b" + assert result.ref == "main" + assert result.aggregate_advantage > 0 # B is better + assert result.winner == "vendor/lib-b" + + +def test_compare_subtrees__returns_tie_within_deadband(tmp_path: Path) -> None: + """Test returns tie when advantage is within deadband.""" + metrics = ExtendedComplexityMetrics(**make_test_metrics(average_mi=70.0, total_files_analyzed=5)) + qpe = QPEScore(qpe=0.65, mi_normalized=0.7, smell_penalty=0.05, adjusted_quality=0.65) + + with ( + patch( + "slopometry.summoner.services.implementation_comparator._extract_subtree", + return_value=True, + ), + patch("slopometry.summoner.services.implementation_comparator.ComplexityAnalyzer") as MockAnalyzer, + patch("slopometry.summoner.services.implementation_comparator.calculate_qpe") as mock_calc_qpe, + ): + MockAnalyzer.return_value.analyze_extended_complexity.return_value = metrics + mock_calc_qpe.return_value = qpe + + result = compare_subtrees(tmp_path, "vendor/lib-a", "vendor/lib-b") + + assert result is not None + assert result.winner == "tie" + assert abs(result.aggregate_advantage) < 0.01 + + +def test_compare_subtrees__includes_smell_advantages(tmp_path: Path) -> None: + """Test that smell_advantages is populated when smells differ.""" + metrics_a = ExtendedComplexityMetrics(**make_test_metrics(average_mi=60.0, total_files_analyzed=5)) + metrics_b = ExtendedComplexityMetrics(**make_test_metrics(average_mi=80.0, total_files_analyzed=5)) + + qpe_a = QPEScore( + qpe=0.5, + mi_normalized=0.6, + smell_penalty=0.2, + adjusted_quality=0.5, + smell_counts={"swallowed_exception": 5}, + ) + qpe_b = QPEScore( + qpe=0.7, + mi_normalized=0.8, + smell_penalty=0.05, + adjusted_quality=0.7, + smell_counts={"swallowed_exception": 1}, + ) + + with ( + patch( + "slopometry.summoner.services.implementation_comparator._extract_subtree", + return_value=True, + ), + patch("slopometry.summoner.services.implementation_comparator.ComplexityAnalyzer") as MockAnalyzer, + patch("slopometry.summoner.services.implementation_comparator.calculate_qpe") as mock_calc_qpe, + ): + MockAnalyzer.return_value.analyze_extended_complexity.side_effect = [metrics_a, metrics_b] + mock_calc_qpe.side_effect = [qpe_a, qpe_b] + + result = compare_subtrees(tmp_path, "vendor/lib-a", "vendor/lib-b") + + assert result is not None + assert len(result.smell_advantages) > 0 + swallowed = next(sa for sa in result.smell_advantages if sa.smell_name == "swallowed_exception") + assert swallowed.baseline_count == 5 + assert swallowed.candidate_count == 1 + assert swallowed.weighted_delta < 0 # B improved on this smell + + +def test_compare_subtrees__json_serialization(tmp_path: Path) -> None: + """Test that result serializes to valid JSON for GRPO pipeline.""" + metrics = ExtendedComplexityMetrics(**make_test_metrics(average_mi=70.0, total_files_analyzed=5)) + + qpe_a = QPEScore(qpe=0.5, mi_normalized=0.6, smell_penalty=0.1, adjusted_quality=0.5) + qpe_b = QPEScore(qpe=0.7, mi_normalized=0.8, smell_penalty=0.05, adjusted_quality=0.7) + + with ( + patch( + "slopometry.summoner.services.implementation_comparator._extract_subtree", + return_value=True, + ), + patch("slopometry.summoner.services.implementation_comparator.ComplexityAnalyzer") as MockAnalyzer, + patch("slopometry.summoner.services.implementation_comparator.calculate_qpe") as mock_calc_qpe, + ): + MockAnalyzer.return_value.analyze_extended_complexity.return_value = metrics + mock_calc_qpe.side_effect = [qpe_a, qpe_b] + + result = compare_subtrees(tmp_path, "vendor/lib-a", "vendor/lib-b") + + assert result is not None + json_str = result.model_dump_json() + parsed = json.loads(json_str) + assert "aggregate_advantage" in parsed + assert "winner" in parsed + assert "smell_advantages" in parsed diff --git a/tests/test_migrations.py b/tests/test_migrations.py index 2c411a5..56d258f 100644 --- a/tests/test_migrations.py +++ b/tests/test_migrations.py @@ -27,7 +27,7 @@ def test_migration_001__adds_transcript_path_column_and_index(self): applied = runner.run_migrations() - assert len(applied) == 8 + assert len(applied) == 10 assert any("001" in migration and "transcript_path" in migration for migration in applied) assert any("002" in migration and "code quality cache" in migration for migration in applied) assert any("003" in migration and "working_tree_hash" in migration for migration in applied) @@ -65,12 +65,12 @@ def test_migration_runner__idempotent_execution(self): applied_first = runner.run_migrations() applied_second = runner.run_migrations() - assert len(applied_first) == 8 + assert len(applied_first) == 10 assert len(applied_second) == 0 status = runner.get_migration_status() - assert status["total"] == 8 - assert len(status["applied"]) == 8 + assert status["total"] == 10 + assert len(status["applied"]) == 10 assert len(status["pending"]) == 0 def test_migration_runner__tracks_migration_status(self): @@ -95,12 +95,12 @@ def test_migration_runner__tracks_migration_status(self): status_after = runner.get_migration_status() - assert status_before["total"] == 8 + assert status_before["total"] == 10 assert len(status_before["applied"]) == 0 - assert len(status_before["pending"]) == 8 + assert len(status_before["pending"]) == 10 - assert status_after["total"] == 8 - assert len(status_after["applied"]) == 8 + assert status_after["total"] == 10 + assert len(status_after["applied"]) == 10 assert len(status_after["pending"]) == 0 migration_001 = next((m for m in status_after["applied"] if m["version"] == "001"), None) @@ -126,7 +126,7 @@ def test_migration_001__handles_existing_column_gracefully(self): applied = runner.run_migrations() - assert len(applied) == 8 + assert len(applied) == 10 with runner._get_db_connection() as conn: cursor = conn.execute("PRAGMA table_info(hook_events)") diff --git a/tests/test_models.py b/tests/test_models.py index ec3ce46..71161b1 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -4,9 +4,14 @@ from pydantic import ValidationError from slopometry.core.models import ( + BaselineStrategy, ContextCoverage, ExtendedComplexityMetrics, FileCoverageStatus, + ImplementationComparison, + QPEScore, + ResolvedBaselineStrategy, + SmellAdvantage, UserStoryDisplayData, UserStoryStatistics, ) @@ -158,3 +163,139 @@ def test_context_coverage_has_gaps__returns_true_when_blind_spots(): ) assert coverage.has_gaps is True + + +def test_resolved_baseline_strategy__rejects_auto_as_resolved() -> None: + """Test that resolved strategy cannot be AUTO.""" + with pytest.raises(ValidationError, match="resolved strategy cannot be AUTO"): + ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.AUTO, + merge_ratio=0.2, + total_commits_sampled=100, + ) + + +def test_resolved_baseline_strategy__accepts_merge_anchored() -> None: + """Test that MERGE_ANCHORED is accepted as resolved strategy.""" + strategy = ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.MERGE_ANCHORED, + merge_ratio=0.25, + total_commits_sampled=200, + ) + assert strategy.resolved == BaselineStrategy.MERGE_ANCHORED + + +def test_resolved_baseline_strategy__accepts_time_sampled() -> None: + """Test that TIME_SAMPLED is accepted as resolved strategy.""" + strategy = ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.TIME_SAMPLED, + merge_ratio=0.05, + total_commits_sampled=200, + ) + assert strategy.resolved == BaselineStrategy.TIME_SAMPLED + + +def test_resolved_baseline_strategy__frozen_rejects_mutation() -> None: + """Test that frozen model rejects field mutation.""" + strategy = ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.MERGE_ANCHORED, + merge_ratio=0.25, + total_commits_sampled=200, + ) + with pytest.raises(ValidationError): + strategy.merge_ratio = 0.5 # pyrefly: ignore[read-only] + + +def test_resolved_baseline_strategy__round_trips_json() -> None: + """Test JSON serialization round-trip.""" + strategy = ResolvedBaselineStrategy( + requested=BaselineStrategy.AUTO, + resolved=BaselineStrategy.MERGE_ANCHORED, + merge_ratio=0.25, + total_commits_sampled=200, + ) + json_str = strategy.model_dump_json() + restored = ResolvedBaselineStrategy.model_validate_json(json_str) + assert restored == strategy + + +def test_smell_advantage__frozen_rejects_mutation() -> None: + """Test that frozen model rejects field mutation.""" + sa = SmellAdvantage( + smell_name="swallowed_exception", + baseline_count=3, + candidate_count=1, + weight=0.15, + weighted_delta=-0.30, + ) + with pytest.raises(ValidationError): + sa.weight = 0.5 # pyrefly: ignore[read-only] + + +def test_smell_advantage__stores_all_fields() -> None: + """Test that all fields are stored correctly.""" + sa = SmellAdvantage( + smell_name="hasattr_getattr", + baseline_count=5, + candidate_count=8, + weight=0.10, + weighted_delta=0.30, + ) + assert sa.smell_name == "hasattr_getattr" + assert sa.baseline_count == 5 + assert sa.candidate_count == 8 + assert sa.weight == 0.10 + assert sa.weighted_delta == 0.30 + + +def test_implementation_comparison__stores_all_fields() -> None: + """Test model creation with all fields.""" + qpe_a = QPEScore(qpe=0.5, mi_normalized=0.6, smell_penalty=0.1, adjusted_quality=0.5) + qpe_b = QPEScore(qpe=0.7, mi_normalized=0.8, smell_penalty=0.05, adjusted_quality=0.7) + + comparison = ImplementationComparison( + prefix_a="vendor/lib-a", + prefix_b="vendor/lib-b", + ref="HEAD", + qpe_a=qpe_a, + qpe_b=qpe_b, + aggregate_advantage=0.35, + smell_advantages=[], + winner="vendor/lib-b", + ) + assert comparison.prefix_a == "vendor/lib-a" + assert comparison.winner == "vendor/lib-b" + assert comparison.aggregate_advantage == 0.35 + + +def test_implementation_comparison__round_trips_json() -> None: + """Test JSON serialization round-trip.""" + qpe_a = QPEScore(qpe=0.5, mi_normalized=0.6, smell_penalty=0.1, adjusted_quality=0.5) + qpe_b = QPEScore(qpe=0.7, mi_normalized=0.8, smell_penalty=0.05, adjusted_quality=0.7) + + comparison = ImplementationComparison( + prefix_a="vendor/lib-a", + prefix_b="vendor/lib-b", + ref="main", + qpe_a=qpe_a, + qpe_b=qpe_b, + aggregate_advantage=0.35, + smell_advantages=[ + SmellAdvantage( + smell_name="swallowed_exception", + baseline_count=3, + candidate_count=1, + weight=0.15, + weighted_delta=-0.30, + ) + ], + winner="vendor/lib-b", + ) + json_str = comparison.model_dump_json() + restored = ImplementationComparison.model_validate_json(json_str) + assert restored.prefix_a == comparison.prefix_a + assert len(restored.smell_advantages) == 1 diff --git a/tests/test_qpe_calculator.py b/tests/test_qpe_calculator.py index a679e7b..308c432 100644 --- a/tests/test_qpe_calculator.py +++ b/tests/test_qpe_calculator.py @@ -9,22 +9,21 @@ from slopometry.core.models import ExtendedComplexityMetrics, QPEScore from slopometry.summoner.services.qpe_calculator import ( - CrossProjectComparator, - QPECalculator, + calculate_qpe, + compare_project_metrics, grpo_advantage, + smell_advantage, ) # Known checkpoint commit for integration tests (Merge PR #29) KNOWN_CHECKPOINT_COMMIT = "0a74cc3" -class TestQPECalculator: - """Test the QPE (Quality-Per-Effort) calculator.""" +class TestCalculateQPE: + """Test the calculate_qpe function.""" def test_calculate_qpe__returns_positive_score_for_quality_codebase(self): """Test that QPE calculation returns positive score for good quality code.""" - calculator = QPECalculator() - metrics = ExtendedComplexityMetrics( **make_test_metrics( total_complexity=100, @@ -47,7 +46,7 @@ def test_calculate_qpe__returns_positive_score_for_quality_codebase(self): ) ) - qpe_score = calculator.calculate_qpe(metrics) + qpe_score = calculate_qpe(metrics) assert qpe_score.qpe > 0 assert qpe_score.mi_normalized == 0.75 @@ -56,8 +55,6 @@ def test_calculate_qpe__returns_positive_score_for_quality_codebase(self): def test_calculate_qpe__smell_penalty_reduces_adjusted_quality(self): """Test that code smells reduce adjusted quality via smell penalty.""" - calculator = QPECalculator() - metrics = ExtendedComplexityMetrics( **make_test_metrics( total_complexity=100, @@ -72,7 +69,7 @@ def test_calculate_qpe__smell_penalty_reduces_adjusted_quality(self): ) ) - qpe_score = calculator.calculate_qpe(metrics) + qpe_score = calculate_qpe(metrics) # Smell penalty should be > 0 assert qpe_score.smell_penalty > 0 @@ -84,8 +81,6 @@ def test_calculate_qpe__smell_penalty_reduces_adjusted_quality(self): def test_calculate_qpe__smell_penalty_saturates_with_sigmoid(self): """Test that smell penalty uses sigmoid saturation (approaches 0.9 asymptotically).""" - calculator = QPECalculator() - metrics = ExtendedComplexityMetrics( **make_test_metrics( total_complexity=100, @@ -102,7 +97,7 @@ def test_calculate_qpe__smell_penalty_saturates_with_sigmoid(self): ) ) - qpe_score = calculator.calculate_qpe(metrics) + qpe_score = calculate_qpe(metrics) # Sigmoid approaches 0.9 asymptotically but never exceeds it assert qpe_score.smell_penalty <= 0.9 @@ -111,7 +106,7 @@ def test_calculate_qpe__smell_penalty_saturates_with_sigmoid(self): def test_calculate_qpe__spreading_smells_does_not_reduce_penalty(self): """Test that spreading smells across files doesn't reduce penalty (anti-gaming fix).""" - calculator = QPECalculator() + # Same smells, 1 file metrics_concentrated = ExtendedComplexityMetrics( @@ -137,16 +132,14 @@ def test_calculate_qpe__spreading_smells_does_not_reduce_penalty(self): ) ) - qpe_concentrated = calculator.calculate_qpe(metrics_concentrated) - qpe_spread = calculator.calculate_qpe(metrics_spread) + qpe_concentrated = calculate_qpe(metrics_concentrated) + qpe_spread = calculate_qpe(metrics_spread) # Both should have the same smell penalty (normalizing by total files, not affected) assert abs(qpe_concentrated.smell_penalty - qpe_spread.smell_penalty) < 0.001 def test_calculate_qpe__qpe_equals_adjusted_quality(self): """Test that qpe equals adjusted_quality.""" - calculator = QPECalculator() - metrics = ExtendedComplexityMetrics( **make_test_metrics( total_effort=50000.0, @@ -155,14 +148,12 @@ def test_calculate_qpe__qpe_equals_adjusted_quality(self): ) ) - qpe_score = calculator.calculate_qpe(metrics) + qpe_score = calculate_qpe(metrics) assert qpe_score.qpe == qpe_score.adjusted_quality def test_calculate_qpe__smell_counts_populated(self): """Test that smell counts are populated for debugging.""" - calculator = QPECalculator() - metrics = ExtendedComplexityMetrics( **make_test_metrics( total_effort=50000.0, @@ -174,11 +165,10 @@ def test_calculate_qpe__smell_counts_populated(self): ) ) - qpe_score = calculator.calculate_qpe(metrics) + qpe_score = calculate_qpe(metrics) - assert "hasattr_getattr" in qpe_score.smell_counts - assert qpe_score.smell_counts["hasattr_getattr"] == 5 - assert qpe_score.smell_counts["type_ignore"] == 3 + assert qpe_score.smell_counts.hasattr_getattr == 5 + assert qpe_score.smell_counts.type_ignore == 3 class TestGRPOAdvantage: @@ -300,13 +290,161 @@ def test_grpo_advantage__handles_zero_baseline(self): assert advantage > 0 -class TestCrossProjectComparator: +def test_smell_advantage__all_zero_deltas_for_equal_counts() -> None: + """Test that equal smell counts produce all-zero weighted deltas.""" + baseline = QPEScore(qpe=0.7, mi_normalized=0.8, smell_penalty=0.0, adjusted_quality=0.7) + candidate = QPEScore(qpe=0.7, mi_normalized=0.8, smell_penalty=0.0, adjusted_quality=0.7) + + result = smell_advantage(baseline, candidate) + assert all(sa.weighted_delta == 0.0 for sa in result) + + +def test_smell_advantage__negative_delta_when_candidate_reduces_smells() -> None: + """Test that candidate reducing smells produces negative weighted_delta.""" + baseline = QPEScore( + qpe=0.5, + mi_normalized=0.6, + smell_penalty=0.2, + adjusted_quality=0.5, + smell_counts={"swallowed_exception": 5}, + ) + candidate = QPEScore( + qpe=0.6, + mi_normalized=0.7, + smell_penalty=0.1, + adjusted_quality=0.6, + smell_counts={"swallowed_exception": 2}, + ) + + result = smell_advantage(baseline, candidate) + non_zero = [sa for sa in result if sa.weighted_delta != 0.0] + assert len(non_zero) == 1 + assert non_zero[0].smell_name == "swallowed_exception" + assert non_zero[0].baseline_count == 5 + assert non_zero[0].candidate_count == 2 + assert non_zero[0].weighted_delta < 0 # Improvement + + +def test_smell_advantage__positive_delta_when_candidate_adds_smells() -> None: + """Test that candidate adding smells produces positive weighted_delta.""" + baseline = QPEScore( + qpe=0.6, + mi_normalized=0.7, + smell_penalty=0.1, + adjusted_quality=0.6, + smell_counts={"hasattr_getattr": 2}, + ) + candidate = QPEScore( + qpe=0.5, + mi_normalized=0.6, + smell_penalty=0.2, + adjusted_quality=0.5, + smell_counts={"hasattr_getattr": 7}, + ) + + result = smell_advantage(baseline, candidate) + non_zero = [sa for sa in result if sa.weighted_delta != 0.0] + assert len(non_zero) == 1 + assert non_zero[0].weighted_delta > 0 # Regression + + +def test_smell_advantage__handles_asymmetric_smell_sets() -> None: + """Test that smells present in only one side are handled correctly.""" + baseline = QPEScore( + qpe=0.5, + mi_normalized=0.6, + smell_penalty=0.2, + adjusted_quality=0.5, + smell_counts={"swallowed_exception": 3}, + ) + candidate = QPEScore( + qpe=0.6, + mi_normalized=0.7, + smell_penalty=0.1, + adjusted_quality=0.6, + smell_counts={"hasattr_getattr": 2}, + ) + + result = smell_advantage(baseline, candidate) + smell_names = {sa.smell_name for sa in result} + assert "swallowed_exception" in smell_names + assert "hasattr_getattr" in smell_names + + swallowed = next(sa for sa in result if sa.smell_name == "swallowed_exception") + assert swallowed.baseline_count == 3 + assert swallowed.candidate_count == 0 + assert swallowed.weighted_delta < 0 + + hasattr_sa = next(sa for sa in result if sa.smell_name == "hasattr_getattr") + assert hasattr_sa.baseline_count == 0 + assert hasattr_sa.candidate_count == 2 + assert hasattr_sa.weighted_delta > 0 + + +def test_smell_advantage__sorted_by_impact_magnitude() -> None: + """Test that results are sorted by absolute weighted_delta descending.""" + baseline = QPEScore( + qpe=0.5, + mi_normalized=0.6, + smell_penalty=0.2, + adjusted_quality=0.5, + smell_counts={"swallowed_exception": 10, "orphan_comment": 5, "hasattr_getattr": 3}, + ) + candidate = QPEScore( + qpe=0.6, + mi_normalized=0.7, + smell_penalty=0.1, + adjusted_quality=0.6, + smell_counts={"swallowed_exception": 2, "orphan_comment": 4, "hasattr_getattr": 3}, + ) + + result = smell_advantage(baseline, candidate) + non_zero = [sa for sa in result if sa.weighted_delta != 0.0] + assert len(non_zero) >= 1 + magnitudes = [abs(sa.weighted_delta) for sa in non_zero] + assert magnitudes == sorted(magnitudes, reverse=True) + + +def test_smell_advantage__uses_correct_weights_from_registry() -> None: + """Test that weights match SMELL_REGISTRY values.""" + baseline = QPEScore( + qpe=0.5, + mi_normalized=0.6, + smell_penalty=0.2, + adjusted_quality=0.5, + smell_counts={"swallowed_exception": 1}, + ) + candidate = QPEScore( + qpe=0.6, + mi_normalized=0.7, + smell_penalty=0.1, + adjusted_quality=0.6, + smell_counts={"swallowed_exception": 2}, + ) + + result = smell_advantage(baseline, candidate) + swallowed = next(sa for sa in result if sa.smell_name == "swallowed_exception") + assert swallowed.weight == 0.15 + assert abs(swallowed.weighted_delta - 0.15) < 0.001 + + +def test_smell_advantage__covers_all_registry_entries() -> None: + """Test that smell_advantage returns entries for all smells in SMELL_REGISTRY.""" + from slopometry.core.models import SMELL_REGISTRY + + baseline = QPEScore(qpe=0.5, mi_normalized=0.6, smell_penalty=0.2, adjusted_quality=0.5) + candidate = QPEScore(qpe=0.6, mi_normalized=0.7, smell_penalty=0.1, adjusted_quality=0.6) + + result = smell_advantage(baseline, candidate) + result_names = {sa.smell_name for sa in result} + assert result_names == set(SMELL_REGISTRY.keys()) + + +class TestCompareProjectMetrics: """Test the cross-project comparison functionality.""" - def test_compare_metrics__returns_flat_rankings(self): + def test_compare_project_metrics__returns_flat_rankings(self): """Test that projects are returned in a flat ranking by QPE.""" - comparator = CrossProjectComparator() - metrics_a = ExtendedComplexityMetrics( **make_test_metrics(total_effort=5000.0, average_effort=1000.0, average_mi=75.0, total_files_analyzed=5) ) @@ -314,7 +452,7 @@ def test_compare_metrics__returns_flat_rankings(self): **make_test_metrics(total_effort=50000.0, average_effort=5000.0, average_mi=70.0, total_files_analyzed=10) ) - result = comparator.compare_metrics( + result = compare_project_metrics( [ ("project-a", metrics_a), ("project-b", metrics_b), @@ -324,11 +462,8 @@ def test_compare_metrics__returns_flat_rankings(self): assert result.total_projects == 2 assert len(result.rankings) == 2 - def test_compare_metrics__ranks_by_qpe_highest_first(self): + def test_compare_project_metrics__ranks_by_qpe_highest_first(self): """Test that projects are ranked by QPE from highest to lowest.""" - comparator = CrossProjectComparator() - - # Create two projects with different quality high_quality = ExtendedComplexityMetrics( **make_test_metrics(total_effort=50000.0, average_effort=5000.0, average_mi=90.0, total_files_analyzed=10) ) @@ -336,7 +471,7 @@ def test_compare_metrics__ranks_by_qpe_highest_first(self): **make_test_metrics(total_effort=55000.0, average_effort=5500.0, average_mi=60.0, total_files_analyzed=10) ) - result = comparator.compare_metrics( + result = compare_project_metrics( [ ("low-quality", low_quality), ("high-quality", high_quality), @@ -348,15 +483,13 @@ def test_compare_metrics__ranks_by_qpe_highest_first(self): assert result.rankings[1].project_name == "low-quality" assert result.rankings[0].qpe_score.qpe > result.rankings[1].qpe_score.qpe - def test_compare_metrics__includes_qpe_details(self): + def test_compare_project_metrics__includes_qpe_details(self): """Test that ranking results include QPE score details.""" - comparator = CrossProjectComparator() - metrics = ExtendedComplexityMetrics( **make_test_metrics(total_effort=50000.0, average_effort=5000.0, average_mi=75.0, total_files_analyzed=10) ) - result = comparator.compare_metrics([("test-project", metrics)]) + result = compare_project_metrics([("test-project", metrics)]) assert result.rankings[0].project_name == "test-project" assert result.rankings[0].qpe_score.qpe > 0 @@ -420,8 +553,8 @@ def test_qpe_calculator__real_codebase_produces_consistent_results(self, repo_pa analyzer = ComplexityAnalyzer(working_directory=repo_path) metrics = analyzer.analyze_extended_complexity() - calculator = QPECalculator() - qpe_score = calculator.calculate_qpe(metrics) + + qpe_score = calculate_qpe(metrics) # QPE should be positive for a working codebase assert qpe_score.qpe > 0 @@ -453,8 +586,8 @@ def test_display_qpe_score__renders_without_error(self, repo_path: Path) -> None analyzer = ComplexityAnalyzer(working_directory=repo_path) metrics = analyzer.analyze_extended_complexity() - calculator = QPECalculator() - qpe_score = calculator.calculate_qpe(metrics) + + qpe_score = calculate_qpe(metrics) # Capture output to verify no errors console_output = StringIO() @@ -482,7 +615,7 @@ def test_qpe_score_model__serializes_to_json(self) -> None: # Verify round-trip restored = QPEScore.model_validate_json(json_output) assert restored.qpe == 0.63 - assert restored.smell_counts["hasattr_getattr"] == 5 + assert restored.smell_counts.hasattr_getattr == 5 def test_qpe_calculator__handles_empty_codebase_gracefully(self, tmp_path: Path) -> None: """Test that QPE calculator handles empty directory without crashing.""" @@ -491,8 +624,8 @@ def test_qpe_calculator__handles_empty_codebase_gracefully(self, tmp_path: Path) analyzer = ComplexityAnalyzer(working_directory=tmp_path) metrics = analyzer.analyze_extended_complexity() - calculator = QPECalculator() - qpe_score = calculator.calculate_qpe(metrics) + + qpe_score = calculate_qpe(metrics) # Should handle gracefully (might return 0 but shouldn't crash) assert qpe_score.qpe >= 0 @@ -508,14 +641,14 @@ def test_qpe_at_known_checkpoint__has_expected_characteristics(self, repo_path: analyzer = ComplexityAnalyzer(working_directory=repo_path) metrics = analyzer.analyze_extended_complexity() - calculator = QPECalculator() - qpe_score = calculator.calculate_qpe(metrics) + + qpe_score = calculate_qpe(metrics) # Documented expectations for slopometry codebase quality # These are loose bounds that should remain stable across minor changes # MI should be in reasonable range for a Python codebase (40-70 typical) - assert 29 <= metrics.average_mi <= 80, f"MI {metrics.average_mi} outside expected range" + assert 28 <= metrics.average_mi <= 80, f"MI {metrics.average_mi} outside expected range" # Should analyze multiple files assert metrics.total_files_analyzed > 10, "Expected to analyze more than 10 Python files" @@ -524,5 +657,5 @@ def test_qpe_at_known_checkpoint__has_expected_characteristics(self, repo_path: assert 0.1 <= qpe_score.qpe <= 1.0, f"QPE {qpe_score.qpe} outside expected range" # Smell counts should be populated - total_smells = sum(qpe_score.smell_counts.values()) + total_smells = sum(qpe_score.smell_counts.model_dump().values()) assert total_smells > 0, "Expected some code smells in a real codebase" diff --git a/tests/test_settings.py b/tests/test_settings.py index 5b0ab25..e999c19 100644 --- a/tests/test_settings.py +++ b/tests/test_settings.py @@ -6,6 +6,9 @@ from pathlib import Path from unittest.mock import patch +import pytest +from pydantic import ValidationError + from slopometry.core.settings import Settings @@ -283,3 +286,71 @@ def test_warn_unknown_prefixed_settings__warns_on_typo_in_dotenv_file(self): slopometry_warnings = [warning for warning in w if "SLOPOMETRY_" in str(warning.message)] assert len(slopometry_warnings) == 1 assert "SLOPOMETRY_FAKE_SETTING" in str(slopometry_warnings[0].message) + + +class TestBaselineStrategyValidator: + """Tests for baseline_strategy field validator.""" + + def test_validate_baseline_strategy__accepts_auto(self): + """Test that 'auto' is accepted.""" + with tempfile.TemporaryDirectory() as temp_dir: + temp_path = Path(temp_dir) + dotenv_file = temp_path / ".env" + dotenv_file.write_text("SLOPOMETRY_BASELINE_STRATEGY=auto\n") + + env_vars_to_clear = [k for k in os.environ.keys() if k.startswith("SLOPOMETRY_")] + with patch.dict(os.environ, {}, clear=False): + for var in env_vars_to_clear: + os.environ.pop(var, None) + + with patch.object(Settings, "model_config", {**Settings.model_config, "env_file": [str(dotenv_file)]}): + s = Settings() + assert s.baseline_strategy == "auto" + + def test_validate_baseline_strategy__accepts_merge_anchored(self): + """Test that 'merge_anchored' is accepted.""" + with tempfile.TemporaryDirectory() as temp_dir: + temp_path = Path(temp_dir) + dotenv_file = temp_path / ".env" + dotenv_file.write_text("SLOPOMETRY_BASELINE_STRATEGY=merge_anchored\n") + + env_vars_to_clear = [k for k in os.environ.keys() if k.startswith("SLOPOMETRY_")] + with patch.dict(os.environ, {}, clear=False): + for var in env_vars_to_clear: + os.environ.pop(var, None) + + with patch.object(Settings, "model_config", {**Settings.model_config, "env_file": [str(dotenv_file)]}): + s = Settings() + assert s.baseline_strategy == "merge_anchored" + + def test_validate_baseline_strategy__accepts_time_sampled(self): + """Test that 'time_sampled' is accepted.""" + with tempfile.TemporaryDirectory() as temp_dir: + temp_path = Path(temp_dir) + dotenv_file = temp_path / ".env" + dotenv_file.write_text("SLOPOMETRY_BASELINE_STRATEGY=time_sampled\n") + + env_vars_to_clear = [k for k in os.environ.keys() if k.startswith("SLOPOMETRY_")] + with patch.dict(os.environ, {}, clear=False): + for var in env_vars_to_clear: + os.environ.pop(var, None) + + with patch.object(Settings, "model_config", {**Settings.model_config, "env_file": [str(dotenv_file)]}): + s = Settings() + assert s.baseline_strategy == "time_sampled" + + def test_validate_baseline_strategy__rejects_invalid_value(self): + """Test that invalid values are rejected.""" + with tempfile.TemporaryDirectory() as temp_dir: + temp_path = Path(temp_dir) + dotenv_file = temp_path / ".env" + dotenv_file.write_text("SLOPOMETRY_BASELINE_STRATEGY=invalid_strategy\n") + + env_vars_to_clear = [k for k in os.environ.keys() if k.startswith("SLOPOMETRY_")] + with patch.dict(os.environ, {}, clear=False): + for var in env_vars_to_clear: + os.environ.pop(var, None) + + with patch.object(Settings, "model_config", {**Settings.model_config, "env_file": [str(dotenv_file)]}): + with pytest.raises(ValidationError, match="baseline_strategy"): + Settings() diff --git a/tests/test_smell_registry.py b/tests/test_smell_registry.py index 6b5e826..b3651cb 100644 --- a/tests/test_smell_registry.py +++ b/tests/test_smell_registry.py @@ -200,15 +200,17 @@ def test_get_smell_files__returns_name_to_files_mapping( assert smell_files["swallowed_exception"] == ["error_handler.py"] assert smell_files["test_skip"] == [] - def test_get_smell_counts__returns_name_to_count_mapping( + def test_get_smell_counts__returns_typed_smell_counts_model( self, metrics_with_smells: ExtendedComplexityMetrics ) -> None: - """Verify get_smell_counts returns dict mapping smell names to counts.""" + """Verify get_smell_counts returns SmellCounts model with correct values.""" + from slopometry.core.models import SmellCounts + smell_counts = metrics_with_smells.get_smell_counts() - assert len(smell_counts) == 14 # 10 original + 3 abstraction smells + sys_path_manipulation - assert smell_counts["orphan_comment"] == 3 - assert smell_counts["swallowed_exception"] == 1 - assert smell_counts["test_skip"] == 0 + assert isinstance(smell_counts, SmellCounts) + assert smell_counts.orphan_comment == 3 + assert smell_counts.swallowed_exception == 1 + assert smell_counts.test_skip == 0 class TestComplexityDeltaSmellChanges: