sourcecode 1.33.14__tar.gz → 1.33.16__tar.gz

{sourcecode-1.33.14 → sourcecode-1.33.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.33.14
+Version: 1.33.16
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm

{sourcecode-1.33.14 → sourcecode-1.33.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.33.14"
+version = "1.33.16"
 description = "Persistent structural context and ultra-fast repeated analysis for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.33.14 → sourcecode-1.33.16}/src/sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.33.14"
+__version__ = "1.33.16"

{sourcecode-1.33.14 → sourcecode-1.33.16}/src/sourcecode/cli.py

@@ -1141,9 +1141,23 @@ def main(
                 capture_output=True, text=True, timeout=3,
             )
             _git_sha = _sha_r.stdout.strip()
-            # Only cache when target IS the git repo root (not a subdir of one),
-            # to avoid polluting sub-project directories used in tests.
-            if _git_sha and (target / ".git").exists():
+
+            # Detect actual git root (may be an ancestor of target for monorepos,
+            # multi-project repos, or SVN-migrated trees where .git is in a parent).
+            # The original "(target / '.git').exists()" check broke these layouts.
+            _git_root_str = ""
+            if _git_sha:
+                try:
+                    _gr_r = _sub.run(
+                        ["git", "-C", str(target), "rev-parse", "--show-toplevel"],
+                        capture_output=True, text=True, timeout=3,
+                    )
+                    if _gr_r.returncode == 0:
+                        _git_root_str = _gr_r.stdout.strip()
+                except Exception:
+                    pass
+
+            if _git_sha and _git_root_str:
                 _excl_key = (
                     ",".join(sorted(e.strip() for e in exclude.split(",") if e.strip()))
                     if exclude else ""
@@ -2241,7 +2255,9 @@ def main(
         _atexit.register(_cache_write_thread.join, 5.0)
 
     # Update RIS with aggregated snapshot data (non-fatal side-effect).
-    if not no_cache and not _pipeline_error and _core_key:
+    # Update RIS whenever git is available, even when L1/L2 cache is skipped
+    # (e.g. target is a subdirectory of the git root — _core_key may be "").
+    if not no_cache and not _pipeline_error and _git_sha:
         try:
             from sourcecode.serializer import core_view as _ris_core_view
             from sourcecode.ris import maybe_update_ris as _ris_update

{sourcecode-1.33.14 → sourcecode-1.33.16}/src/sourcecode/file_classifier.py

@@ -187,16 +187,19 @@ class FileClassifier:
             if java_class is not None:
                 return java_class
 
-        if self._has_any_import(imports, _API_IMPORTS):
-            evidence = self._matched_imports(imports, _API_IMPORTS)
+        # Fix 4: call _matched_imports once per category instead of twice
+        # (_has_any_import was calling _matched_imports and discarding the result,
+        # then the caller invoked it again to get the evidence — halving throughput).
+        evidence = self._matched_imports(imports, _API_IMPORTS)
+        if evidence:
             return FileClassification(norm, "api_layer", "high", 0.82, "imports API/server framework", evidence)
 
-        if self._has_any_import(imports, _DB_IMPORTS):
-            evidence = self._matched_imports(imports, _DB_IMPORTS)
+        evidence = self._matched_imports(imports, _DB_IMPORTS)
+        if evidence:
             return FileClassification(norm, "database_layer", "high", 0.78, "imports database/persistence dependency", evidence)
 
-        if self._has_any_import(imports, _INFRA_IMPORTS):
-            evidence = self._matched_imports(imports, _INFRA_IMPORTS)
+        evidence = self._matched_imports(imports, _INFRA_IMPORTS)
+        if evidence:
             return FileClassification(norm, "infrastructure", "high", 0.72, "imports infrastructure dependency", evidence)
 
         role = self._package_role(norm)

{sourcecode-1.33.14 → sourcecode-1.33.16}/src/sourcecode/mcp/server.py

@@ -650,7 +650,56 @@ def check_freshness(repo_path: str = ".") -> dict:
         _path_err = _check_repo_path(repo_path)
         if _path_err is not None:
             return _path_err
-        return _execute(["cache", "freshness", repo_path, "--json"])
+
+        # Call Python functions directly — avoids CliRunner/subprocess nesting
+        # that caused current_git_head to return "" on Windows parent-git repos.
+        import subprocess as _sp
+        from pathlib import Path as _Path
+        from sourcecode.cache import _get_git_head as _cache_head
+        from sourcecode.ris import load_ris as _load_ris, _has_uncommitted_changes as _huc
+
+        target = _Path(repo_path).resolve()
+        current_head = _cache_head(target)
+        ris = _load_ris(target)
+
+        if ris is None:
+            result: dict = {
+                "fresh": False,
+                "ris_exists": False,
+                "current_git_head": current_head,
+                "ris_git_head": None,
+                "delta_commits": None,
+                "has_uncommitted_changes": _huc(target),
+                "ris_last_updated_at": None,
+            }
+        else:
+            ris_head = ris.git_head
+            head_matches = bool(current_head and ris_head and current_head == ris_head)
+            uncommitted = _huc(target)
+            delta = None
+            if ris_head and current_head and ris_head != current_head:
+                try:
+                    _r = _sp.run(
+                        ["git", "-C", str(target), "rev-list", "--count", f"{ris_head}..HEAD"],
+                        capture_output=True, text=True, timeout=5,
+                    )
+                    if _r.returncode == 0:
+                        delta = int(_r.stdout.strip())
+                except Exception:
+                    pass
+            elif head_matches:
+                delta = 0
+            result = {
+                "fresh": head_matches and not uncommitted,
+                "ris_exists": True,
+                "current_git_head": current_head,
+                "ris_git_head": ris_head,
+                "delta_commits": delta,
+                "has_uncommitted_changes": uncommitted,
+                "ris_last_updated_at": ris.last_updated_at,
+            }
+
+        return _ok(result)
     except Exception as exc:
         return _err(
             f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",

{sourcecode-1.33.14 → sourcecode-1.33.16}/src/sourcecode/prepare_context.py

@@ -1750,8 +1750,14 @@ class TaskContextBuilder:
                 for _cr in _commits_scanned:
                     _msg_lower = (_cr.message or "").lower()
                     if _kw_re.search(_msg_lower):
+                        _rn_prefix = self.root.name + "/"
                         for _cf in (_cr.files_changed or []):
                             _cf_norm = _cf.replace("\\", "/")
+                            # Git reports paths relative to the git root, which may be
+                            # a parent of the analyzed directory (e.g. MSAS/saint-server/).
+                            # Strip the analyzed-dir prefix so paths match all_paths.
+                            if _cf_norm.startswith(_rn_prefix):
+                                _cf_norm = _cf_norm[len(_rn_prefix):]
                             _commit_file_hits[_cf_norm] = _commit_file_hits.get(_cf_norm, 0) + 1
                         _sx_commits.append({
                             "message": (_cr.message or "")[:80],
@@ -1836,6 +1842,15 @@ class TaskContextBuilder:
                 # the candidate pool (e.g. AkitaBaseService containing setLoading).
                 _src_exts = frozenset({".java", ".py", ".ts", ".js", ".kt", ".go"})
                 _frontend_kws = [kw for kw in symptom_keywords if kw in _FRONTEND_SYMPTOM_MAP]
+                # Fix 5: In large repos, skip frontend→backend synonym grep for keywords
+                # that already have direct path matches — those are backend terms (e.g.
+                # "login" in an IAM repo) that don't need UI→service-layer translation.
+                # Prevents "authentication" grep flooding keycloak with SAML adapter files.
+                if _is_large_repo and _frontend_kws:
+                    _frontend_kws = [
+                        kw for kw in _frontend_kws
+                        if not any(kw in p.lower() for p in _sx_direct_path)
+                    ]
                 _backend_terms_set: list[str] = []
                 if _frontend_kws:
                     _bt: list[str] = []
@@ -1923,6 +1938,7 @@ class TaskContextBuilder:
                 _no_scan_candidates = relevant_files[_CONTENT_SCAN_LIMIT:]
 
                 _boosted: list[RelevantFile] = []
+                _raw_signals: dict[str, float] = {}  # uncapped accumulated signal per file
                 _scanned_body: dict[str, str] = {}  # cache for graph expansion (Pass 5)
                 for _rf in _scan_candidates:
                     _extra = 0.0
@@ -1996,7 +2012,9 @@ class TaskContextBuilder:
                     elif _extra_syn > 0:
                         _new_reason = _rf.reason + f", synonym-match backend (+{_extra_syn:.2f})"
 
-                    _final_score = round(min(_rf.score + _total_extra, 1.0), 2)
+                    _raw_signal = _rf.score + _total_extra  # uncapped for ranking
+                    _raw_signals[_rf.path] = _raw_signal
+                    _final_score = round(min(_raw_signal, 1.0), 2)
                     _boosted.append(RelevantFile(
                         path=_rf.path,
                         role=_rf.role,
@@ -2005,21 +2023,14 @@ class TaskContextBuilder:
                         why=_rf.why,
                     ))
 
-                # Use total boost as a secondary sort key so symptom-matched files
-                # that were boosted from a lower base score rank above structural
-                # files that coincidentally reach the same capped score of 1.0.
-                # This prevents budget-trimming from discarding the most relevant files.
-                _boost_totals: dict[str, float] = {}
-                for _rf in _scan_candidates:
-                    pass  # populated below
-                _boost_totals = {}
-                for _idx, _rf in enumerate(_scan_candidates):
-                    _b_rf = _boosted[_idx]
-                    _boost_totals[_b_rf.path] = round(_b_rf.score - _rf.score, 4)
-
+                # Sort by uncapped raw signal so files with more accumulated evidence
+                # (path matches + content hits + commit matches) rank above files that
+                # merely cap at the same display score of 1.0.
+                # _raw_signals holds each file's full sum before the display cap.
+                # Files not content-scanned (_no_scan_candidates) use their base score.
                 relevant_files = sorted(
                     _boosted + _no_scan_candidates,
-                    key=lambda rf: (-rf.score, -_boost_totals.get(rf.path, 0)),
+                    key=lambda rf: -_raw_signals.get(rf.path, rf.score),
                 )
 
                 # Pass 5: reverse graph expansion from high-score seed nodes.
@@ -2118,9 +2129,14 @@ class TaskContextBuilder:
                         if _gx_new:
                             relevant_files = sorted(
                                 relevant_files + _gx_new,
-                                key=lambda rf: (-rf.score, -_boost_totals.get(rf.path, 0)),
+                                key=lambda rf: -_raw_signals.get(rf.path, rf.score),
                             )
 
+                # Fix 2: Cap output for large repos to stay within agent context budgets.
+                # Raw signal sort above ensures highest-signal files survive the cut.
+                if _is_large_repo and len(relevant_files) > 40:
+                    relevant_files = relevant_files[:40]
+
                 # Synonym note (only when synonyms actually fired)
                 if _frontend_kws and _sx_synonyms:
                     symptom_note = (

{sourcecode-1.33.14 → sourcecode-1.33.16}/src/sourcecode/ris.py

@@ -437,6 +437,18 @@ def get_cold_start_context(repo_root: Path) -> dict:
             "endpoints": endpoints,
             "hotspots": ris.git_context_snapshot.get("hotspots", []),
             "validation": _validation,
+            # Fix 3: _cache wrapper for backward compat with CLI schema consumers.
+            # CLI outputs inject _cache via _inject_cache_meta; MCP cold-start path
+            # skips that step, leaving agents that read _cache.cache_source with None.
+            "_cache": {
+                "cache_source": "RIS",
+                "git_head_at_generation": ris.git_head or "",
+                "current_git_head": current_head or "",
+                "is_stale": stale,
+                "has_uncommitted_changes": uncommitted,
+                "generated_at": ris.last_updated_at,
+                "data_scope": "RIS_BOOTSTRAP",
+            },
         }
         if not endpoints and _is_java:
             result["endpoints_hint"] = (