sourcecode 1.30.28__py3-none-any.whl → 1.30.30__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/adaptive_scanner.py

@@ -19,7 +19,7 @@ from typing import Any, Optional, cast
 from pathspec import GitIgnoreSpec
 
 from sourcecode.repo_classifier import RepoTopology
-from sourcecode.scanner import DEFAULT_EXCLUDES, MANIFEST_NAMES
+from sourcecode.scanner import DEFAULT_EXCLUDES, EXCLUDED_FILE_SUFFIXES, MANIFEST_NAMES
 
 
 class AdaptiveScanner:
@@ -88,13 +88,14 @@ class AdaptiveScanner:
 
     def _load_gitignore_spec(self) -> GitIgnoreSpec:
         if self._gitignore_spec is None:
-            gitignore = self.root / ".gitignore"
             lines: list[str] = []
-            if gitignore.exists():
-                try:
-                    lines = gitignore.read_text(encoding="utf-8", errors="replace").splitlines()
-                except OSError:
-                    pass
+            for ignore_file in (".gitignore", ".sourcecodeIgnore"):
+                candidate = self.root / ignore_file
+                if candidate.exists():
+                    try:
+                        lines.extend(candidate.read_text(encoding="utf-8", errors="replace").splitlines())
+                    except OSError:
+                        pass
             self._gitignore_spec = GitIgnoreSpec.from_lines(lines)
         return self._gitignore_spec
 
@@ -202,6 +203,9 @@ class AdaptiveScanner:
                 # Skip flag-shaped names (shell redirect artifacts)
                 if fname.startswith("-"):
                     continue
+                # Skip minified/map files
+                if any(fname.endswith(sfx) for sfx in EXCLUDED_FILE_SUFFIXES):
+                    continue
                 fpath = current / fname
                 if fpath.is_symlink():
                     continue

sourcecode/classifier.py

@@ -25,7 +25,7 @@ _API_FRAMEWORKS = {
     "Ktor",
     "Play",
 }
-_WEB_FRAMEWORKS = {"Next.js", "React", "Vue", "Svelte", "Vite", "Flutter", "Phoenix"}
+_WEB_FRAMEWORKS = {"Next.js", "React", "Vue", "Svelte", "Vite", "Flutter", "Phoenix", "Angular"}
 _CLI_FRAMEWORKS = {"Typer", "Cobra", "Clap"}
 _API_STACKS = {"python", "go", "java", "php", "ruby", "dotnet", "kotlin", "scala"}
 ConfidenceLevel = Literal["high", "medium", "low"]
@@ -105,6 +105,13 @@ class TypeClassifier:
         if "src/lib.rs" in flat_paths and not any(path.endswith("main.rs") for path in flat_paths):
             return "library"
 
+        # Angular SPA: angular.json is the canonical signal; framework detection is secondary
+        if (
+            "angular.json" in flat_paths
+            or "Angular" in framework_names
+        ):
+            return "angular-spa"
+
         if framework_names & _WEB_FRAMEWORKS or any(
             path.startswith(("app/", "pages/", "components/")) for path in flat_paths
         ):

sourcecode/cli.py

@@ -188,6 +188,7 @@ _OPTIONS_WITH_VALUE: frozenset[str] = frozenset({
     "--rank-by",
     "--symbol",
     "--max-importers",
+    "--exclude",
 })
 
 
@@ -592,6 +593,16 @@ def main(
         "-c",
         help="Copy output to system clipboard after a successful run. No-op when --output is used or clipboard is unavailable.",
     ),
+    exclude: Optional[str] = typer.Option(
+        None,
+        "--exclude",
+        help="Additional directories/patterns to exclude, comma-separated (e.g. 'legacy,generated').",
+    ),
+    no_cache: bool = typer.Option(
+        False,
+        "--no-cache",
+        help="Bypass the scan cache and force a fresh analysis.",
+    ),
 ) -> None:
     """Analyze a repository and produce structured context for AI coding agents.
 
@@ -798,10 +809,67 @@ def main(
         no_tree = True  # agents never need the raw file tree
         architecture = True  # agents need full architectural signal (M4)
 
+    # ── GAP-9: Cache check — serve from .sourcecode-cache when git SHA unchanged ──
+    import hashlib as _hashlib
+    import subprocess as _sub
+    _cache_dir = target / ".sourcecode-cache"
+    _cache_hit_content: Optional[str] = None
+    _git_sha = ""
+    _cache_key = ""
+    _cache_file: Optional[Path] = None
+    if not no_cache:
+        try:
+            _sha_r = _sub.run(
+                ["git", "-C", str(target), "rev-parse", "--short", "HEAD"],
+                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():
+                # Include every output-affecting flag so different flag combos never collide
+                _flags_str = (
+                    f"c={compact},ag={agent},fmt={format},full={full},"
+                    f"co={changed_only},dep={dependencies},gm={graph_modules},"
+                    f"docs={docs},fm={full_metrics},sem={semantics},"
+                    f"arch={architecture},gc={git_context},em={env_map},"
+                    f"cn={code_notes},tree={tree},mode={mode}"
+                )
+                _flags_h = _hashlib.md5(_flags_str.encode()).hexdigest()[:8]
+                _cache_key = f"{_git_sha}-{_flags_h}"
+                _cache_file = _cache_dir / f"snapshot-{_cache_key}.json"
+                if _cache_file.exists():
+                    _cache_hit_content = _cache_file.read_text(encoding="utf-8")
+        except Exception:
+            _git_sha = ""
+            _cache_key = ""
+            _cache_file = None
+
+    if _cache_hit_content is not None:
+        from sourcecode.serializer import write_output
+        write_output(_cache_hit_content, output=output)
+        if copy and not output:
+            _copy_to_clipboard(_cache_hit_content)
+        return
+
+    _extra_excludes: Optional[frozenset[str]] = None
+    if exclude:
+        _extra_excludes = frozenset(e.strip() for e in exclude.split(",") if e.strip())
+        # IMP-2: warn if the exclude value looks like it was swallowed as a path
+        # (BUG-2 symptom in older versions: --exclude value consumed as repo path).
+        import sys as _sys_warn
+        if len(_extra_excludes) == 1 and Path(list(_extra_excludes)[0]).is_dir():
+            _sys_warn.stderr.write(
+                f"[sourcecode] Warning: --exclude value '{list(_extra_excludes)[0]}' is a directory path. "
+                "If this was meant as a pattern, use --exclude=pattern or --exclude pattern (both are supported).\n"
+            )
+            _sys_warn.stderr.flush()
+
     _progress = Progress()
     _progress.start("scanning files")
 
-    scanner = AdaptiveScanner(target, topology=_topology, base_depth=effective_depth)
+    scanner = AdaptiveScanner(target, topology=_topology, base_depth=effective_depth,
+                               extra_excludes=_extra_excludes)
     raw_tree = scanner.scan_tree()
 
     # 2. Filter .env and *.secret entries from file tree (SEC-02, all levels)
@@ -1514,9 +1582,10 @@ def main(
         content = json.dumps(data, indent=2, ensure_ascii=False)
     elif compact:
         if changed_only and _allowed_changed_files:
+            # GAP-5: preserve full entry_points for architecture context even in
+            # --changed-only mode. Only filter file_paths and code_notes.
             sm = _replace(sm,
                 file_paths=[p for p in sm.file_paths if p in _allowed_changed_files],
-                entry_points=[ep for ep in sm.entry_points if ep.path in _allowed_changed_files],
                 code_notes=[n for n in sm.code_notes if n.path in _allowed_changed_files],
             )
         data = compact_view(sm, no_tree=no_tree, full=full)
@@ -1585,6 +1654,14 @@ def main(
     _progress.finish()
     write_output(content, output=output)
 
+    # GAP-9: Persist to cache for future identical runs (git SHA unchanged)
+    if not no_cache and _cache_key and _cache_file is not None and not _pipeline_error:
+        try:
+            _cache_dir.mkdir(parents=True, exist_ok=True)
+            _cache_file.write_text(content, encoding="utf-8")
+        except Exception:
+            pass
+
     if _pipeline_error:
         raise typer.Exit(code=2)
 
@@ -1739,6 +1816,11 @@ def prepare_context_cmd(
         "--fast",
         help="Skip deep analysis (content search, test gap discovery, code annotations). Uses manifest/metadata only. Target: < 6 s.",
     ),
+    include_config: bool = typer.Option(
+        False,
+        "--include-config",
+        help="(generate-tests) Include tooling config files (*.conf.js, .eslintrc*, etc.) in test_gaps. Excluded by default.",
+    ),
 ) -> None:
     """Task-specific context for AI coding agents.
 
@@ -1820,7 +1902,7 @@ def prepare_context_cmd(
             _sys.stderr.flush()
     _t0 = _time.perf_counter()
     try:
-        output = builder.build(task, since=since, symptom=symptom, fast=fast)
+        output = builder.build(task, since=since, symptom=symptom, fast=fast, include_config=include_config)
     finally:
         _progress.finish()
     _t_total = (_time.perf_counter() - _t0) * 1000
@@ -2291,8 +2373,23 @@ def repo_ir_cmd(
             err=True,
         )
     else:
-        _sys.stdout.write(output)
-        _sys.stdout.write("\n")
+        try:
+            _sys.stdout.buffer.write(output.encode("utf-8"))
+            _sys.stdout.buffer.write(b"\n")
+            _sys.stdout.buffer.flush()
+        except UnicodeEncodeError as _ue:
+            # IMP-2: emit workaround before re-raising so the user knows what to do.
+            _sys.stderr.write(
+                f"[sourcecode] UnicodeEncodeError on stdout ({_ue.encoding}): "
+                "your console codec cannot encode this output.\n"
+                "Workaround: sourcecode repo-ir --output ir.json\n"
+            )
+            _sys.stderr.flush()
+            raise
+        except AttributeError:
+            # Fallback for wrapped stdout without buffer (e.g. some test harnesses)
+            _sys.stdout.write(output)
+            _sys.stdout.write("\n")
 
 
 # ── version ───────────────────────────────────────────────────────────────────
@@ -2345,5 +2442,13 @@ def main_entry() -> None:
     can consume them as positional arguments (which would prevent subcommand
     routing for tokens like 'version' or 'config').
     """
+    import sys as _sys
+    # Force UTF-8 on stdout so Unicode characters (arrows, etc.) survive on
+    # Windows where the default console codec is cp1252 (BUG-1).
+    if hasattr(_sys.stdout, "reconfigure"):
+        try:
+            _sys.stdout.reconfigure(encoding="utf-8")
+        except Exception:
+            pass
     _preprocess_argv()
     app()

sourcecode/detectors/nodejs.py

@@ -217,6 +217,7 @@ class NodejsDetector(AbstractDetector):
         _INDEX_PATHS = {"src/index.js", "src/index.ts", "index.js", "index.ts"}
         for path in [
             "server.js", "server.ts",
+            "main.ts", "main.js",  # Angular/root-level entry (e.g. Angular CLI projects)
             "src/index.js", "src/index.ts",
             "src/main.js", "src/main.ts", "src/main.tsx",
             "app/page.tsx", "pages/index.js",

sourcecode/prepare_context.py

@@ -604,6 +604,33 @@ _FRONTEND_SYMPTOM_MAP: dict[str, list[str]] = {
 }
 
 
+MAX_FILES_FAST = 2000  # above this threshold --fast uses git-index-only mode
+
+
+def _count_files_bounded(root: "Path", limit: int = MAX_FILES_FAST + 1) -> int:
+    """Count files under root, stopping early once limit reached (O(n) fast exit)."""
+    import os as _os
+    count = 0
+    for _, _, fnames in _os.walk(str(root)):
+        count += len(fnames)
+        if count >= limit:
+            return count
+    return count
+
+
+def _git_changed_files_fast(root: "Path") -> list[str]:
+    """Return files reported by git diff --name-only HEAD (for fast-mode scanning)."""
+    import subprocess as _sp
+    try:
+        r = _sp.run(
+            ["git", "diff", "--name-only", "HEAD"],
+            capture_output=True, text=True, cwd=str(root), timeout=5,
+        )
+        return [f.strip() for f in r.stdout.splitlines() if f.strip()]
+    except Exception:
+        return []
+
+
 def _build_analysis_scope(
     *,
     task_name: str,
@@ -685,7 +712,7 @@ class TaskContextBuilder:
     def __init__(self, root: Path) -> None:
         self.root = root
 
-    def build(self, task_name: str, *, since: Optional[str] = None, symptom: Optional[str] = None, fast: bool = False) -> TaskOutput:
+    def build(self, task_name: str, *, since: Optional[str] = None, symptom: Optional[str] = None, fast: bool = False, include_config: bool = False) -> TaskOutput:
         if task_name not in TASKS:
             raise ValueError(
                 f"Unknown task '{task_name}'. Available: {', '.join(TASKS)}"
@@ -761,6 +788,29 @@ class TaskContextBuilder:
             # for behavioral_impact reverse lookups without scanning the whole repo).
             file_tree: dict = {}
             all_paths = self._expand_scope_for_analysis(_pr_scope_files or [])
+        elif fast and task_name == "onboard":
+            # Onboard fast: always use shallow scan so manifests and entry points
+            # are discoverable — git-changed-only mode would return only dirty files
+            # (e.g. .idea/vcs.xml) which yields no useful entry points (BUG-3).
+            scanner = AdaptiveScanner(self.root, base_depth=2)
+            file_tree = scanner.scan_tree()
+            manifests = scanner.find_manifests()
+            all_paths = [p.replace("\\", "/") for p in flatten_file_tree(file_tree)]
+        elif fast and _count_files_bounded(self.root) > MAX_FILES_FAST:
+            # Fast mode on large repo: git-index-only — only scan git-changed files.
+            # Skips full AdaptiveScanner traversal which takes 35s+ on 7k+ file repos.
+            _git_files = _git_changed_files_fast(self.root)
+            _git_files = [f for f in _git_files if (self.root / f).exists()]
+            if not _git_files:
+                # Fallback: use a shallow scan (depth 2) to get some context
+                scanner = AdaptiveScanner(self.root, base_depth=2)
+                file_tree = scanner.scan_tree()
+                manifests = scanner.find_manifests()
+                all_paths = [p.replace("\\", "/") for p in flatten_file_tree(file_tree)]
+            else:
+                file_tree = {}
+                all_paths = _git_files
+                # Keep manifests from shallow pre-scan
         else:
             _topology = RepoClassifier().classify(self.root)
             _base_depth = 12 if _is_java else 6
@@ -1413,8 +1463,9 @@ class TaskContextBuilder:
                     _existing_paths.add(_p)
                     _sx_direct_path.append(_p)
 
-                # Pass 5+6 combined: single file read per candidate.
-                # Limit content scan to top 80 candidates by current score to bound I/O.
+                # Pass 4b: grep-based injection for frontend→backend synonym terms.
+                # Runs parallel grep for each backend term to find files not yet in
+                # 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]
                 _backend_terms_set: list[str] = []
@@ -1424,6 +1475,40 @@ class TaskContextBuilder:
                         _bt.extend(_FRONTEND_SYMPTOM_MAP[_fkw])
                     _backend_terms_set = list(dict.fromkeys(_bt))
 
+                if _backend_terms_set and not fast:
+                    import subprocess as _sp2
+                    _grepped: set[str] = set()
+                    for _term in _backend_terms_set[:6]:
+                        try:
+                            _gr = _sp2.run(
+                                ["grep", "-r", "-l", "-i", _term,
+                                 "--include=*.ts", "--include=*.java",
+                                 str(self.root)],
+                                capture_output=True, text=True, timeout=4,
+                            )
+                            for _line in _gr.stdout.splitlines():
+                                try:
+                                    _rel = str(Path(_line.strip()).relative_to(self.root)).replace("\\", "/")
+                                    _grepped.add(_rel)
+                                except ValueError:
+                                    pass
+                        except Exception:
+                            pass
+                    _existing_paths_now = {rf.path for rf in relevant_files}
+                    for _gf in sorted(_grepped):
+                        if _gf in _existing_paths_now:
+                            continue
+                        if Path(_gf).suffix.lower() not in _src_exts:
+                            continue
+                        relevant_files.append(RelevantFile(
+                            path=_gf,
+                            role="symptom_match",
+                            score=0.45,
+                            reason="content contains backend symptom term (grep)",
+                            why=f"grep injection: {', '.join(_backend_terms_set[:3])}",
+                        ))
+                        _existing_paths_now.add(_gf)
+
                 # Sort before content scan so top candidates get read first
                 relevant_files = sorted(relevant_files, key=lambda rf: -rf.score)
                 _CONTENT_SCAN_LIMIT = 80
@@ -1575,11 +1660,26 @@ class TaskContextBuilder:
                 # Python/JS: test_foo / foo_test
                 return stem.removeprefix("test_").removesuffix("_test")
 
+            # Patterns excluded from test_gaps by default (IMP-1): tooling config
+            # files have no business logic to test. --include-config overrides.
+            _CONFIG_EXCLUDE_PATTERNS = (
+                ".eslintrc", ".prettierrc", "eslint.config",
+                "karma.conf", "jest.config", "babel.config",
+                "webpack.config", "vite.config", "rollup.config",
+                "tsconfig", "angular.json", ".claude/",
+            )
+
+            def _is_config_file(p: str) -> bool:
+                name = Path(p).name.lower()
+                norm = p.replace("\\", "/")
+                return any(pat in name or pat in norm for pat in _CONFIG_EXCLUDE_PATTERNS)
+
             test_stems = {_normalize_test_stem(Path(p).stem) for p in test_set}
             untested = [
                 p for p in source_set
                 if Path(p).stem not in test_stems
                 and not any(pen in p for pen in spec.ranking_penalties)
+                and (include_config or not _is_config_file(p))
             ]
             untested.sort(key=lambda p: (len(p.split("/")), p))
             test_gaps = untested[:15]

sourcecode/repository_ir.py

@@ -1091,8 +1091,54 @@ def _build_evidence_bundles(
     return bundles
 
 
-def _detect_subsystems(all_fqns: list[str], relations: list[RelationEdge]) -> list[list[str]]:
-    """Connected components of the relation graph (Union-Find, graph-only)."""
+def _common_package_prefix(fqns: list[str]) -> str:
+    """Longest common dot-separated package prefix across a list of FQNs."""
+    if not fqns:
+        return ""
+    # Strip class/method suffix — keep only package parts (lowercase segments)
+    def pkg_parts(fqn: str) -> list[str]:
+        parts = fqn.split(".")
+        # Drop trailing class/method names (PascalCase or after '#')
+        result = []
+        for p in parts:
+            if "#" in p:
+                break
+            if p and p[0].isupper():
+                break
+            result.append(p)
+        return result
+
+    segs = [pkg_parts(f) for f in fqns if pkg_parts(f)]
+    if not segs:
+        return fqns[0].rsplit(".", 1)[0] if "." in fqns[0] else fqns[0]
+    common = segs[0]
+    for s in segs[1:]:
+        new_common = []
+        for a, b in zip(common, s):
+            if a == b:
+                new_common.append(a)
+            else:
+                break
+        common = new_common
+        if not common:
+            break
+    return ".".join(common) if common else fqns[0].rsplit(".", 1)[0]
+
+
+def _subsystem_label(package_prefix: str) -> str:
+    """Derive short human label from package prefix (last meaningful segment)."""
+    parts = [p for p in package_prefix.split(".") if p]
+    # Skip generic top-level segments
+    _SKIP = {"com", "org", "net", "io", "java", "javax"}
+    meaningful = [p for p in parts if p not in _SKIP]
+    return meaningful[-1] if meaningful else (parts[-1] if parts else package_prefix)
+
+
+def _detect_subsystems(all_fqns: list[str], relations: list[RelationEdge]) -> list[dict]:
+    """Connected components of the relation graph (Union-Find, graph-only).
+
+    Returns labeled subsystem objects instead of raw FQN arrays.
+    """
     fqn_set = set(all_fqns)
     parent: dict[str, str] = {fqn: fqn for fqn in all_fqns}
 
@@ -1117,7 +1163,23 @@ def _detect_subsystems(all_fqns: list[str], relations: list[RelationEdge]) -> li
         root = find(fqn)
         components.setdefault(root, []).append(fqn)
 
-    return [sorted(v) for v in sorted(components.values())]
+    result: list[dict] = []
+    for members in sorted(components.values()):
+        members = sorted(members)
+        pkg_prefix = _common_package_prefix(members)
+        label = _subsystem_label(pkg_prefix)
+        # Summary: first 3 short class names + total count
+        short_names = [m.split(".")[-1].split("#")[0] for m in members[:3]]
+        summary = ", ".join(short_names)
+        if len(members) > 3:
+            summary += f" ... ({len(members)} total)"
+        result.append({
+            "label": label,
+            "package_prefix": pkg_prefix,
+            "member_count": len(members),
+            "summary": summary,
+        })
+    return result
 
 
 _EDGE_REASON_TEMPLATES: dict[str, str] = {
@@ -1287,6 +1349,7 @@ def _assemble(
 
     # Score per node: ir_weight × graph_centrality × diff_intensity × evidence_strength
     # Unchanged nodes: diff_intensity=0 → score=0 (no diff signal)
+    has_diff = bool(sorted_changed)
     node_scores: dict[str, float] = {}
     for sym in sorted_syms:
         fqn = sym.symbol
@@ -1299,6 +1362,28 @@ def _assemble(
         es = bundles[fqn].evidence_strength if fqn in bundles else 0.0
         node_scores[fqn] = round(w * c * di * es, 4) if di > 0 else 0.0
 
+    # No diff signal (no --since): fall back to call-graph centrality scores.
+    # Avoids emitting all-zero scores which mislead agents into thinking the tool is broken.
+    score_basis: str
+    impact_note: Optional[str]
+    if not has_diff and sorted_syms:
+        for sym in sorted_syms:
+            fqn = sym.symbol
+            role = spring_role_map.get(fqn, "other")
+            w = _IR_WEIGHTS.get(role, _IR_WEIGHT_DEFAULT)
+            raw_c = in_deg.get(fqn, 0) + out_deg.get(fqn, 0) + bfs_reach.get(fqn, 0) * 0.1
+            c = min(1.0, raw_c / max_raw)
+            node_scores[fqn] = round(w * c, 4)
+        score_basis = "call_graph_centrality"
+        impact_note = "impact scores based on call-graph centrality (no --since provided)"
+    elif has_diff:
+        score_basis = "diff_impact"
+        impact_note = None
+    else:
+        # No symbols at all — omit scores entirely rather than emit zeros
+        score_basis = "none"
+        impact_note = None
+
     # --- Analysis: classify changed symbols ---
     dropped_fields: list[dict] = []
     changed_entities_out: list[dict] = []
@@ -1435,6 +1520,8 @@ def _assemble(
         },
         "impact": {
             "global_score": global_score,
+            "score_basis": score_basis,
+            **({"impact_note": impact_note} if impact_note else {}),
             "ranked_nodes": ranked_nodes,
         },
         "subsystems": subsystems,

sourcecode/scanner.py

@@ -27,6 +27,22 @@ DEFAULT_EXCLUDES: frozenset[str] = frozenset({
     "dist",
     "build",
     "target",
+    # Additional generated/IDE/tool dirs
+    ".gradle",
+    ".planning",
+    ".idea",
+    "coverage",
+    ".sourcecode-cache",
+    ".mvn",
+    "generated",
+    "generated-sources",
+})
+
+# File suffixes excluded by default (minified/map files add noise, not signal)
+EXCLUDED_FILE_SUFFIXES: frozenset[str] = frozenset({
+    ".min.js",
+    ".min.css",
+    ".map",
 })
 
 # Nombres de ficheros de manifiesto conocidos (para find_manifests)
@@ -120,13 +136,13 @@ class FileScanner:
         self._gitignore_spec: Optional[GitIgnoreSpec] = None
 
     def _load_gitignore_spec(self) -> GitIgnoreSpec:
-        """Carga .gitignore del proyecto como GitIgnoreSpec (SCAN-01)."""
+        """Carga .gitignore y .sourcecodeIgnore como GitIgnoreSpec (SCAN-01)."""
         if self._gitignore_spec is None:
-            gitignore = self.root / ".gitignore"
-            if gitignore.exists():
-                lines = gitignore.read_text(encoding="utf-8", errors="replace").splitlines()
-            else:
-                lines = []
+            lines: list[str] = []
+            for ignore_file in (".gitignore", ".sourcecodeIgnore"):
+                candidate = self.root / ignore_file
+                if candidate.exists():
+                    lines.extend(candidate.read_text(encoding="utf-8", errors="replace").splitlines())
             self._gitignore_spec = GitIgnoreSpec.from_lines(lines)
         return self._gitignore_spec
 
@@ -183,6 +199,9 @@ class FileScanner:
                 # No legitimate source file starts with "-".
                 if fname.startswith("-"):
                     continue
+                # Skip minified/map files — no signal value
+                if any(fname.endswith(sfx) for sfx in EXCLUDED_FILE_SUFFIXES):
+                    continue
                 fpath = current / fname
                 # SCAN-03: no incluir symlinks de fichero
                 if fpath.is_symlink():

sourcecode/serializer.py

@@ -563,6 +563,10 @@ def _bootstrap_structured(eps: list) -> "Optional[dict[str, Any]]":
     if security:
         result["security"] = security
     if controllers:
+        # Count unique files (classes) vs total entries (methods/endpoints)
+        controller_classes = len({c["path"] for c in controllers})
+        controller_methods = len(controllers)
+
         # Extract all DDD module names from controller paths and group by domain area.
         # Path pattern: .../ddd/{module}/infrastructure/rest/*Controller.java
         _DDD_LAYERS = {"application", "domain", "infrastructure"}
@@ -582,6 +586,10 @@ def _bootstrap_structured(eps: list) -> "Optional[dict[str, Any]]":
                 seen_modules.add(module)
                 module_names.append(module)
 
+        _ctrl_note = (
+            f"{controller_methods} @RequestMapping methods across "
+            f"{controller_classes} controller classes"
+        )
         if len(module_names) > 30:
             # Group by first path segment under ddd/ (inferred domain area)
             domain_groups: dict[str, list[str]] = {}
@@ -600,12 +608,16 @@ def _bootstrap_structured(eps: list) -> "Optional[dict[str, Any]]":
                     if module not in domain_groups[domain_prefix or "other"]:
                         domain_groups[domain_prefix or "other"].append(module)
             result["controllers"] = {
-                "count": len(controllers),
+                "classes": controller_classes,
+                "methods": controller_methods,
+                "note": _ctrl_note,
                 "modules": {k: sorted(v) for k, v in sorted(domain_groups.items())},
             }
         else:
             result["controllers"] = {
-                "count": len(controllers),
+                "classes": controller_classes,
+                "methods": controller_methods,
+                "note": _ctrl_note,
                 "modules": sorted(module_names),
             }
     return result
@@ -1315,6 +1327,13 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False, full: bool = False) ->
         result["transactional_boundaries"] = _transactional
     if _git_ctx:
         result["git_context"] = _git_ctx
+    # Angular structural analysis (GAP-10)
+    if sm.project_type in ("angular-spa", "webapp") or any(
+        any(f.name == "Angular" for f in s.frameworks) for s in sm.stacks
+    ):
+        _ang = _angular_analysis(sm)
+        if _ang and (_ang.get("component_count", 0) > 0 or _ang.get("angular_version")):
+            result["angular_analysis"] = _ang
     if _spring_profiles:
         result["spring_profiles"] = _spring_profiles
     _always_include = {"project_type", "project_summary", "architecture_summary", "dependency_summary"}
@@ -1599,6 +1618,110 @@ def validate_cross_analyzer_consistency(
     return findings
 
 
+def _angular_analysis(sm: "SourceMap") -> "Optional[dict[str, Any]]":
+    """Extract Angular structural metrics for TypeScript/Angular projects (GAP-10)."""
+    import json as _json
+    import re as _re
+
+    ts_files = [p for p in sm.file_paths if p.endswith(".ts") and not p.endswith(".d.ts")]
+    if not ts_files:
+        return None
+
+    root = Path(sm.metadata.analyzed_path) if sm.metadata.analyzed_path else Path(".")
+
+    component_count = 0
+    service_count = 0
+    lazy_routes_count = 0
+    akita_stores = 0
+    standalone_components = False
+    route_paths: list[str] = []
+
+    for rel in ts_files:
+        try:
+            content = (root / rel).read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        component_count += content.count("@Component(")
+        service_count += content.count("@Injectable(")
+        # Count lazy route patterns: `loadChildren:` (property syntax used in route
+        # configs) and `loadComponent:` (standalone component lazy loading). The old
+        # `loadChildren(` form counted zero because Angular uses property syntax, not
+        # a function call (BUG-5).
+        fname_lower = rel.replace("\\", "/").split("/")[-1].lower()
+        _is_routing_file = (
+            "routing" in fname_lower
+            or fname_lower in ("app.routes.ts", "app-routing.module.ts")
+            or fname_lower.endswith(".routes.ts")
+        )
+        lazy_routes_count += content.count("loadChildren:")
+        lazy_routes_count += content.count("loadComponent:")
+        if _is_routing_file:
+            # Also count standalone dynamic imports that aren't already caught above
+            _lc_imports = content.count("import(") - content.count("loadChildren:") - content.count("loadComponent:")
+            if _lc_imports > 0:
+                lazy_routes_count += _lc_imports
+        akita_stores += content.count("@StoreConfig(")
+        if not standalone_components and "bootstrapApplication(" in content:
+            standalone_components = True
+        # Route tree: parse path: '...' in routing files
+        fname = rel.replace("\\", "/").split("/")[-1]
+        if "routing" in fname or fname in ("app.routes.ts",):
+            for m in _re.finditer(r"path\s*:\s*['\"]([^'\"]*)['\"]", content):
+                val = m.group(1)
+                if val and val not in route_paths:
+                    route_paths.append(val)
+
+    # Angular version from package.json
+    angular_version: Optional[str] = None
+    pkg_json = root / "package.json"
+    if pkg_json.exists():
+        try:
+            pkg = _json.loads(pkg_json.read_text(encoding="utf-8", errors="replace"))
+            # Use `or {}` so explicit `null` values in package.json don't
+            # raise TypeError when unpacking (BUG-4).
+            deps = {
+                **(pkg.get("dependencies") or {}),
+                **(pkg.get("devDependencies") or {}),
+                **(pkg.get("peerDependencies") or {}),
+            }
+            av = deps.get("@angular/core")
+            if av:
+                angular_version = av.lstrip("^~>=")
+        except Exception:
+            pass
+
+    # Also check angular.json for entry point
+    entry_point: Optional[str] = None
+    angular_json = root / "angular.json"
+    if angular_json.exists():
+        try:
+            aj = _json.loads(angular_json.read_text(encoding="utf-8", errors="replace"))
+            projects = aj.get("projects") or {}
+            for proj in projects.values():
+                main = (
+                    (proj.get("architect") or {})
+                    .get("build", {})
+                    .get("options", {})
+                    .get("main")
+                )
+                if main:
+                    entry_point = main
+                    break
+        except Exception:
+            pass
+
+    return {
+        "angular_version": angular_version,
+        "standalone_components": standalone_components,
+        "lazy_routes_count": lazy_routes_count,
+        "akita_stores": akita_stores,
+        "route_tree": route_paths[:20],
+        "component_count": component_count,
+        "service_count": service_count,
+        **({"entry_point": entry_point} if entry_point else {}),
+    }
+
+
 def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
     """Opinionated output for AI agents — structured, noise-free, gap-aware.
 
@@ -1823,6 +1946,14 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
     if signals:
         result["signals"] = signals
 
+    # ── 8b. Angular structural analysis (GAP-10) ──────────────────────────────
+    if sm.project_type in ("angular-spa", "webapp") or any(
+        any(f.name == "Angular" for f in s.frameworks) for s in sm.stacks
+    ):
+        _ang = _angular_analysis(sm)
+        if _ang and (_ang.get("component_count", 0) > 0 or _ang.get("angular_version")):
+            result["angular_analysis"] = _ang
+
     # ── 9. Git context — lightweight (top-5 hotspots, branch, uncommitted count)
     _gc = _compact_git_context(sm)
     if _gc:

{sourcecode-1.30.28.dist-info → sourcecode-1.30.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.30.28
+Version: 1.30.30
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -221,7 +221,7 @@ Description-Content-Type: text/markdown
 
 **Deterministic, behavior-aware codebase context for AI agents and PR review.**
 
-![Version](https://img.shields.io/badge/version-1.30.28-blue)
+![Version](https://img.shields.io/badge/version-1.30.30-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -257,7 +257,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.30.28
+# sourcecode 1.30.30
 ```
 
 ---

{sourcecode-1.30.28.dist-info → sourcecode-1.30.30.dist-info}/RECORD

@@ -1,10 +1,10 @@
-sourcecode/__init__.py,sha256=q-bCo7uGXns3U7O05C-GiuHhFOyvaN-90_kC3JSQMn0,104
-sourcecode/adaptive_scanner.py,sha256=RTNExwWPXzjgLaRueT7UuxkPj5ZEToWjGbx1j0LSZ9E,10250
+sourcecode/__init__.py,sha256=ANLn7vd3QuDTWulbelwm9eIp93h5ZEZKi-nKm911_so,104
+sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/architecture_analyzer.py,sha256=MyBa0Hf5HmkudZQDLKrjcWDKETXETXl0mQX1swtTwAA,39091
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
 sourcecode/ast_extractor.py,sha256=XgrZg2DcWcUm9r87cRG3KGO7IK2TIL_N-CvhSbUmmh4,49901
-sourcecode/classifier.py,sha256=pYve2J1LqtYssU3lYLMDz18PT-CjN5c18QYE7R_IG1Q,7507
-sourcecode/cli.py,sha256=NbVyJAEQ4Q0ngkgW_lXyvlDJcD8TTrxZEXY6RIVkBAI,95261
+sourcecode/classifier.py,sha256=-0t0HLc9L9UleMLfclfLM3AXhBjUb_AYyBPDbvgWtac,7755
+sourcecode/cli.py,sha256=_WsbkJWvI_xv4aSh3mdPvTbh-eKGV5DZbPj2ZFuA2GI,100189
 sourcecode/code_notes_analyzer.py,sha256=y1MJBnPZHYp4i6cQCXUb9ATIyifS_qMQWjw_8lPkpsU,9215
 sourcecode/confidence_analyzer.py,sha256=H9VHYRzZhqMFlSCZffjtsMUGYLnDvrq1g5FjzyQ1hxE,16381
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
@@ -22,18 +22,18 @@ sourcecode/git_analyzer.py,sha256=0Gyj-vMpIIN4nfriKXVRouNYBeJ59s6pQDX2Xu9Pq-U,13
 sourcecode/graph_analyzer.py,sha256=iUK-7pSV-cvGqqD2hENdYmhnm0wcXFEyK-xnu5ul8OU,62515
 sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
 sourcecode/pr_comment_renderer.py,sha256=smHslxiG14lrytCkq5nFrFu-qTHgA-t-LFYfdrfjz2o,14423
-sourcecode/prepare_context.py,sha256=O3gpZIJLzCH2-9zr91zOP0D4gwHND2BbgBOCplwQXj8,168540
+sourcecode/prepare_context.py,sha256=QNCl8uKk9PQpgXxPHBNSDXXkc1s2wTZwU6H0REC5Qms,173487
 sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
 sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
 sourcecode/relevance_scorer.py,sha256=MYF4FFkveAQps9SmTeTlh6ODiBz2F--_hWNeHMLtUHQ,8405
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
-sourcecode/repository_ir.py,sha256=e9TzNbfo_2Cyh3aASFZBq--rPjBMIYMuw5smIWJ5hx8,61099
+sourcecode/repository_ir.py,sha256=KH5EehbjOh8ZwwTHcbzrAHiKDoquO49wgSvCX4bVq5k,64391
 sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBGPjQ,14792
-sourcecode/scanner.py,sha256=aM3h9-DCQ3xKpeHpHYdo2vX6T5P95HA_YwZbkAVNwmo,8288
+sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
 sourcecode/schema.py,sha256=fj3BZ3IcnNV4j21BFIEvz8Qnw_vZoqIbzzRg-qQ-nd0,24530
 sourcecode/semantic_analyzer.py,sha256=12TwXYkYbDcBdu0heX_EmfPM2EkO8a_r5osf0SaeQbs,88956
-sourcecode/serializer.py,sha256=svaLLYyAeAd3ZWsgh0YBwu7RKm00JaKuyz3bQbLipHA,106064
+sourcecode/serializer.py,sha256=FM4xklb9Ywg9KNdNpo8QXR50izuml5FkbeQgL2uS1HY,111611
 sourcecode/summarizer.py,sha256=lPlKhMh28nueXkPo2xKeD3DUFYVGRlJMIdY-8TSM-ls,17486
 sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/workspace.py,sha256=X_6NmNnitvT3_38V-JDChydo_sR68s249hLFlrQskU0,8271
@@ -48,7 +48,7 @@ sourcecode/detectors/heuristic.py,sha256=bCqqgbHavl4Sse3dqT8mwmo1wAdgeJr7VyXOmfC
 sourcecode/detectors/hybrid.py,sha256=IGFRUVsAZ1ooRlFdznCeJAV6vy1yVDx-VyghvLtddXc,9101
 sourcecode/detectors/java.py,sha256=ldvaDZJADAKslOpS5qJ0bxexgeY6h_4Yx4NCtHio7J8,24203
 sourcecode/detectors/jvm_ext.py,sha256=EgHJ5W8EE-ZTN9V607mVzohyKgZE8Mc2jCi-DF8RAZU,2616
-sourcecode/detectors/nodejs.py,sha256=7fsyAmrGkkguX6U80HUQpIe9MRaYyi_A7zbaRtmFmGc,13097
+sourcecode/detectors/nodejs.py,sha256=Hg3Gmr7yIMJFiLoDwOTk2wtu00wxIs6kZf-oQujTFUA,13187
 sourcecode/detectors/parsers.py,sha256=ugPg8yNUf0Ai1gA7Fnn6wAkYGFjTxRodSP3IeViYJJ4,2290
 sourcecode/detectors/php.py,sha256=W_AQD0WMVDdWHa9h_ilX6W8XSpz0X4ctpMK2WXfXf1I,1887
 sourcecode/detectors/project.py,sha256=ghWWOlqg2_uywzeZX573CCkFWQPlc8bBGvvX1BfIDYI,8315
@@ -64,8 +64,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=KJeIPCPWMdmbCP3ySGs2iUlia34U6vWne2dZsUezesw,1560
-sourcecode-1.30.28.dist-info/METADATA,sha256=cL4bkJZO4jc-T5k1GtC5OXS99NZLU4bZSl6WxVbo70w,28956
-sourcecode-1.30.28.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.30.28.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.30.28.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.30.28.dist-info/RECORD,,
+sourcecode-1.30.30.dist-info/METADATA,sha256=TRgm7Qpvohc3ofAWDRDEfmcF2lCQ3b-dqvEAn-Rd6qw,28956
+sourcecode-1.30.30.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.30.30.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.30.30.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.30.30.dist-info/RECORD,,