sourcecode 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/architecture_analyzer.py

@@ -182,8 +182,19 @@ class ArchitectureAnalyzer:
         ddd_result = self._detect_ddd(sm.file_paths)
         if ddd_result is not None:
             ddd_pattern, ddd_layers, ddd_contexts, ddd_layer_names = ddd_result
-            domains_for_ddd = self._cluster_domains(filtered) if len(filtered) >= 2 else []
             module_files = self._build_ddd_module_files(sm.file_paths, ddd_contexts)
+            # Use DDD bounded context names as domains so --architecture shows each
+            # context as a distinct domain instead of collapsing all files under
+            # the Maven path segment (e.g. "java").
+            domains_for_ddd = [
+                ArchitectureDomain(
+                    name=n,
+                    files=module_files.get(n, []),
+                    role="DDD bounded context",
+                    confidence="high",
+                )
+                for n in ddd_contexts
+            ]
             bc_list = [
                 BoundedContext(name=n, modules=module_files.get(n, []), confidence="high")
                 for n in ddd_contexts

sourcecode/ast_extractor.py

@@ -940,19 +940,51 @@ def _extract_python(path: str, source: str) -> FileContract:
 
 
 # ---------------------------------------------------------------------------
-# Minimal Java extraction (regex-based, no AST)
+# ---------------------------------------------------------------------------
+# Enhanced Java extraction (regex-based, annotation-aware)
 # ---------------------------------------------------------------------------
 
-_JAVA_CLASS_DECL_RE = re.compile(
-    r'public\s+(?:(?:abstract|final|static)\s+)*(class|interface|enum)\s+(\w+)'
-    r'(?:\s+extends\s+([\w.]+))?(?:\s+implements\s+([\w.,\s]+?))?(?=\s*[\{<])',
-    re.MULTILINE,
+_JAVA_IMPORT_RE = re.compile(r'^import\s+(?:static\s+)?([^;\s]+)\s*;', re.MULTILINE)
+
+# Single annotation on one line (captures name + optional parens args)
+_JAVA_ANNO_LINE_RE = re.compile(r'^\s*(@[\w.]+(?:\s*\([^)]*\))?)\s*$')
+# Class/interface/enum declaration line (public or package-private)
+_JAVA_CLASS_LINE_RE = re.compile(
+    r'(?:public\s+)?(?:(?:abstract|final|static|sealed)\s+)*'
+    r'(class|interface|enum|@interface)\s+(\w+)'
+    r'(?:\s+extends\s+([\w.]+))?'
+    r'(?:\s+implements\s+([\w.,\s<>]+?))?'
+    r'(?=\s*[\{<])'
 )
-_JAVA_METHOD_SIG_RE = re.compile(
-    r'^\s{0,12}public\s+[^\{]+\(',
+# Public method: up to 12 leading spaces, return type, name, open paren
+_JAVA_PUB_METHOD_LINE_RE = re.compile(
+    r'^\s{0,12}public\s+(?:(?:static|final|synchronized|abstract|default)\s+)*'
+    r'[\w<>\[\]?,\s]+?\s+(\w+)\s*\(',
     re.MULTILINE,
 )
-_JAVA_IMPORT_RE = re.compile(r'^import\s+(?:static\s+)?([^;\s]+)\s*;', re.MULTILINE)
+# @Autowired or @Inject field
+_JAVA_FIELD_DECL_RE = re.compile(
+    r'^\s*(?:private|protected|public)?\s*'
+    r'([\w<>.,\[\]? ]+?)\s+(\w+)\s*[;=]'
+)
+
+
+def _java_collect_preceding_annotations(lines: list[str], decl_idx: int) -> list[str]:
+    """Walk back from decl_idx and collect @annotation lines immediately before it."""
+    annotations: list[str] = []
+    i = decl_idx - 1
+    while i >= 0:
+        stripped = lines[i].strip()
+        if not stripped or stripped.startswith("//") or stripped.startswith("*"):
+            i -= 1
+            continue
+        m = re.match(r'(@[\w.]+(?:\s*\([^)]*\))?)', stripped)
+        if m:
+            annotations.insert(0, m.group(1))
+            i -= 1
+        else:
+            break
+    return annotations
 
 
 def _extract_java(path: str, source: str) -> FileContract:
@@ -960,35 +992,93 @@ def _extract_java(path: str, source: str) -> FileContract:
     types: list[TypeDefinition] = []
     functions: list[FunctionSignature] = []
     imports: list[ImportRecord] = []
+    autowired_fields: list[dict] = []
 
-    # Class / interface / enum declarations
-    for m in _JAVA_CLASS_DECL_RE.finditer(source):
-        name = m.group(2)
-        extends_str = m.group(3)
-        implements_str = m.group(4)
-        all_extends: list[str] = []
-        if extends_str:
-            all_extends.append(extends_str.strip())
-        if implements_str:
-            all_extends.extend(i.strip() for i in implements_str.split(",") if i.strip())
-        types.append(TypeDefinition(name=name, kind="class", fields=[], extends=all_extends))
-        exports.append(ExportRecord(name=name, kind="class"))
-
-    class_names = {t.name for t in types}
-
-    # Public method signatures (one-line heuristic)
+    lines = source.splitlines()
+
+    # Pass 1: collect imports
+    seen_sources: set[str] = set()
+    for m in _JAVA_IMPORT_RE.finditer(source):
+        full_import = m.group(1).strip()
+        if full_import not in seen_sources:
+            seen_sources.add(full_import)
+            imports.append(ImportRecord(source=full_import, kind="named", symbols=[]))
+
+    # Pass 2: line-by-line scan for classes, methods, @Autowired fields
+    class_names: set[str] = set()
     seen_methods: set[str] = set()
-    for m in _JAVA_METHOD_SIG_RE.finditer(source):
-        sig_text = m.group(0).strip()
-        name_match = re.search(r'(\w+)\s*\($', sig_text)
-        if not name_match:
-            name_match = re.search(r'(\w+)\s*\(', sig_text)
-        if not name_match:
+    autowired_pending = False
+
+    for idx, line in enumerate(lines):
+        stripped = line.strip()
+
+        # Detect @Autowired / @Inject annotations
+        if stripped.startswith("@Autowired") or stripped.startswith("@Inject"):
+            autowired_pending = True
             continue
-        mname = name_match.group(1)
-        if mname in class_names or mname in seen_methods or mname in {"if", "for", "while", "switch"}:
+
+        # Capture autowired field on next non-annotation, non-blank line
+        if autowired_pending and stripped and not stripped.startswith("@"):
+            autowired_pending = False
+            fm = _JAVA_FIELD_DECL_RE.match(line)
+            if fm:
+                type_name = fm.group(1).strip().split()[-1]  # last word = simple type
+                field_name = fm.group(2).strip()
+                if field_name and type_name and field_name not in {"class", "interface"}:
+                    autowired_fields.append({"type": type_name, "name": field_name})
+        elif stripped and not stripped.startswith("@"):
+            autowired_pending = False
+
+        # Class/interface/enum declaration
+        cm = _JAVA_CLASS_LINE_RE.search(stripped)
+        if cm and ("class " in stripped or "interface " in stripped or "enum " in stripped):
+            kind_kw = cm.group(1)  # class | interface | enum | @interface
+            name = cm.group(2)
+            extends_str = cm.group(3)
+            implements_str = cm.group(4)
+
+            annotations = _java_collect_preceding_annotations(lines, idx)
+            all_extends: list[str] = []
+            if extends_str:
+                all_extends.append(extends_str.strip())
+
+            implements_list: list[str] = []
+            if implements_str:
+                implements_list = [i.strip() for i in implements_str.split(",") if i.strip()]
+
+            export_kind = "class" if kind_kw in ("class", "@interface") else kind_kw
+            exports.append(ExportRecord(
+                name=name,
+                kind=export_kind,
+                annotations=annotations,
+                extends=extends_str.strip() if extends_str else None,
+                implements=implements_list,
+            ))
+            types.append(TypeDefinition(
+                name=name,
+                kind=export_kind,
+                fields=[],
+                extends=all_extends,
+            ))
+            class_names.add(name)
+
+    # Pass 3: public methods with their preceding annotations
+    for m in _JAVA_PUB_METHOD_LINE_RE.finditer(source):
+        sig_text = m.group(0).strip()
+        mname = m.group(1)
+        if (mname in class_names or mname in seen_methods
+                or mname in {"if", "for", "while", "switch", "return", "new"}):
             continue
         seen_methods.add(mname)
+        # Find line index for this match to collect preceding annotations
+        line_start = source.count("\n", 0, m.start())
+        annotations = _java_collect_preceding_annotations(lines, line_start)
+        exports.append(ExportRecord(
+            name=mname,
+            kind="method",
+            annotations=annotations,
+            signature=sig_text,
+        ))
         functions.append(FunctionSignature(
             name=mname,
             signature=sig_text,
@@ -997,14 +1087,6 @@ def _extract_java(path: str, source: str) -> FileContract:
             return_type=None,
         ))
 
-    # Import statements
-    seen_sources: set[str] = set()
-    for m in _JAVA_IMPORT_RE.finditer(source):
-        full_import = m.group(1).strip()
-        if full_import not in seen_sources:
-            seen_sources.add(full_import)
-            imports.append(ImportRecord(source=full_import, kind="named", symbols=[]))
-
     # External deps: top-2 package segments, skip java.* / javax.*
     deps = sorted({
         ".".join(imp.source.split(".")[:2])
@@ -1021,6 +1103,7 @@ def _extract_java(path: str, source: str) -> FileContract:
         functions=sorted(functions, key=lambda f: f.name)[:20],
         types=sorted(types, key=lambda t: t.name),
         dependencies=deps[:20],
+        autowired_fields=autowired_fields[:20],
         extraction_method="heuristic",
     )
 
@@ -1089,6 +1172,51 @@ def _detect_role(path: str, contract: FileContract) -> str:
     return "util"
 
 
+# ---------------------------------------------------------------------------
+# MyBatis XML mapper extractor
+# ---------------------------------------------------------------------------
+
+def _extract_mybatis_xml(rel_path: str, source: str) -> FileContract:
+    """Extract namespace and SQL operations from a MyBatis *Mapper.xml file."""
+    import re as _re
+    from xml.etree import ElementTree
+
+    _NS_STRIP = _re.compile(r"\{[^}]+\}")
+    _SQL_OPS = frozenset({"select", "insert", "update", "delete"})
+
+    exports: list[ExportRecord] = []
+    namespace: str | None = None
+
+    try:
+        root_elem = ElementTree.fromstring(source.encode("utf-8"))
+        namespace = root_elem.get("namespace") or None
+        for elem in root_elem:
+            tag = _NS_STRIP.sub("", elem.tag).lower()
+            if tag in _SQL_OPS:
+                op_id = (elem.get("id") or "").strip()
+                if op_id:
+                    # type_ref carries select/insert/update/delete for the serializer
+                    exports.append(ExportRecord(kind="query", name=op_id, type_ref=tag))
+    except Exception:
+        return FileContract(
+            path=rel_path,
+            language="mybatis-xml",
+            role="mybatis-mapper",
+            extraction_method="heuristic",
+            limitations=["xml_parse_error: failed to parse mapper XML"],
+        )
+
+    deps = [f"namespace:{namespace}"] if namespace else []
+    return FileContract(
+        path=rel_path,
+        language="mybatis-xml",
+        role="mybatis-mapper",
+        exports=exports,
+        dependencies=deps,
+        extraction_method="heuristic",
+    )
+
+
 # ---------------------------------------------------------------------------
 # AstExtractor public class
 # ---------------------------------------------------------------------------
@@ -1108,6 +1236,16 @@ class AstExtractor:
         return self._ts_ok
 
     def extract(self, path: Path, root: Optional[Path] = None) -> Optional[FileContract]:
+        # MyBatis mapper XML — handled before the language map lookup so .xml
+        # files are only processed when they match the mapper naming convention.
+        if path.suffix.lower() == ".xml" and path.name.endswith("Mapper.xml"):
+            try:
+                source = path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                return None
+            rel_path = str(path.relative_to(root)).replace("\\", "/") if root else path.name
+            return _extract_mybatis_xml(rel_path, source)
+
         ext = path.suffix.lower()
         language = _LANGUAGE_MAP.get(ext)
         if language is None:

sourcecode/cli.py

@@ -728,15 +728,13 @@ def main(
         mode = "contract"   # unknown → safe default
 
     # Legacy flags imply raw mode unless --mode was explicitly overridden.
-    # These flags produce standard_view-only output sections not in contract_view.
-    # Preserves backward compat: callers using any legacy flag get their previous format.
-    # New callers opt into contract mode via --mode contract (or bare invocation).
-    # Legacy flags that produce output sections incompatible with contract_view
-    # force mode to raw. --agent is excluded: it now runs the contract pipeline
-    # and enriches contract_view with auto-enabled analyzers (deps, env, notes).
+    # --format yaml and --graph-modules are now compatible with contract_view:
+    #   yaml is a serialization format (not an output-section flag)
+    #   graph-modules output is included in contract_view when available
+    # Other flags that produce sections exclusive to standard_view still force raw.
     _legacy_flags_active = (
-        compact or tree or format == "yaml" or trace_pipeline
-        or docs or semantics or graph_modules or full_metrics or architecture
+        compact or tree or trace_pipeline
+        or docs or semantics or full_metrics or architecture
     )
     if mode in ("contract", "standard") and _legacy_flags_active:
         mode = "raw"
@@ -1106,6 +1104,17 @@ def main(
         metrics_summary=metrics_summary,
     )
 
+    # Populate Java-specific root fields from java stack detection (FIX-6, 7, 8)
+    _java_stack = next((s for s in stacks if s.stack == "java"), None)
+    if _java_stack is not None:
+        from dataclasses import replace as _dc_replace
+        sm = _dc_replace(sm,
+            packaging=getattr(_java_stack, "packaging", None) or None,
+            language_version=getattr(_java_stack, "language_version", None) or None,
+            spring_profiles=getattr(_java_stack, "spring_profiles", []) or [],
+            app_server_hint=getattr(_java_stack, "app_server_hint", None) or None,
+        )
+
     # Semantic analysis (--semantics flag)
     if semantic_analyzer is not None:
         if workspace_analysis.workspaces:
@@ -1402,7 +1411,16 @@ def main(
     if _is_contract_mode:
         from sourcecode.contract_pipeline import ContractPipeline
         from sourcecode.contract_model import ContractSummary as _ContractSummary
-        _cp = ContractPipeline()
+        # FIX-1: Java projects need higher caps — many files, comprehensive coverage required
+        _jvm_stacks = {"java", "kotlin", "scala", "groovy"}
+        _is_jvm = any(s.stack in _jvm_stacks for s in sm.stacks)
+        # FIX-1: Java projects need higher caps and no relevance threshold
+        _max_files_cp = 2500 if _is_jvm else 500
+        _cp = ContractPipeline(max_files=_max_files_cp)
+        _java_pipeline_kwargs: dict = {}
+        if _is_jvm:
+            _java_pipeline_kwargs["max_contracts"] = 500
+            _java_pipeline_kwargs["min_score"] = 0.0
         try:
             _contracts, _contract_summary = _cp.run(
                 target,
@@ -1420,6 +1438,7 @@ def main(
                 max_importers=max_importers,
                 semantic_calls=sm.semantic_calls or None,
                 code_notes=sm.code_notes or None,
+                **_java_pipeline_kwargs,
             )
         except Exception as _exc:
             typer.echo(f"[error] contract pipeline failed: {_exc}", err=True)
@@ -1462,7 +1481,22 @@ def main(
         data = _contract_view(sm, emit_graph=emit_graph, depth=_depth)
         if not no_redact:
             data = redact_dict(data)
-        content = json.dumps(data, indent=2, ensure_ascii=False)
+        if format == "yaml":
+            from io import StringIO
+            from ruamel.yaml import YAML as _YAML
+            _yaml = _YAML()
+            _yaml.default_flow_style = False
+            _yaml.representer.add_representer(
+                type(None),
+                lambda dumper, data_val: dumper.represent_scalar(
+                    "tag:yaml.org,2002:null", "null"
+                ),
+            )
+            _stream = StringIO()
+            _yaml.dump(data, _stream)
+            content = _stream.getvalue()
+        else:
+            content = json.dumps(data, indent=2, ensure_ascii=False)
     elif agent:
         data = agent_view(sm)
         # When contract pipeline ran (mode=contract, no legacy flags), include

sourcecode/contract_model.py

@@ -25,9 +25,13 @@ class ExportRecord:
     """Exported symbol."""
 
     name: str
-    kind: str = "unknown"  # function | class | const | type | default | react_component | enum | interface
+    kind: str = "unknown"  # function | class | const | type | default | react_component | enum | interface | method
     type_ref: Optional[str] = None
     async_: bool = False
+    annotations: list[str] = field(default_factory=list)  # Java: ["@Controller", "@Transactional"]
+    extends: Optional[str] = None                          # Java: parent class
+    implements: list[str] = field(default_factory=list)    # Java: interfaces
+    signature: Optional[str] = None                        # Java method: full signature
 
 
 @dataclass
@@ -96,6 +100,8 @@ class FileContract:
     # Extraction quality
     extraction_method: str = "heuristic"  # ast | tree_sitter | heuristic
     limitations: list[str] = field(default_factory=list)
+    # Java-specific (FIX-1)
+    autowired_fields: list[dict] = field(default_factory=list)  # [{"type": "...", "name": "..."}]
 
 
 @dataclass

sourcecode/contract_pipeline.py

@@ -182,6 +182,7 @@ class ContractPipeline:
         semantic_calls: Optional[list] = None,
         code_notes: Optional[list] = None,
         max_contracts: Optional[int] = _MAX_CONTRACTS,
+        min_score: Optional[float] = None,
     ) -> tuple[list[FileContract], ContractSummary]:
         """Run the full extraction pipeline.
 
@@ -218,9 +219,18 @@ class ContractPipeline:
             fname = Path(pn).name
             return any(fname.startswith(pat) or f".{pat.strip('.')}" in fname for pat in _TEST_PATTERNS)
 
+        def _is_extractable(p: str) -> bool:
+            suf = Path(p).suffix.lower()
+            if suf in _SRC_EXTENSIONS:
+                return True
+            # MyBatis mapper XML files — only *Mapper.xml, not all XML
+            if suf == ".xml" and p.endswith("Mapper.xml"):
+                return True
+            return False
+
         src_paths = [
             p for p in file_paths
-            if Path(p).suffix.lower() in _SRC_EXTENSIONS
+            if _is_extractable(p)
             and not scorer.is_noise(p)
             and (symbol is not None or changed_only or not _is_test(p))
         ]
@@ -317,11 +327,17 @@ class ContractPipeline:
         # 10. Top-N cap — enforce max_contracts when not in symbol-search mode.
         # Symbol searches must return all matching files; budget applies only to
         # the default architectural briefing use case.
+        _effective_min_score = min_score if min_score is not None else _MIN_CONTRACT_SCORE
         if symbol is None and max_contracts is not None:
             contracts = [
                 c for c in contracts
-                if c.relevance_score >= _MIN_CONTRACT_SCORE or c.is_entrypoint
+                if c.relevance_score >= _effective_min_score or c.is_entrypoint
             ][:max_contracts]
+        elif symbol is None and max_contracts is None:
+            contracts = [
+                c for c in contracts
+                if c.relevance_score >= _effective_min_score or c.is_entrypoint
+            ]
 
         # 11. Compress types if requested
         if compress_types:

sourcecode/dependency_analyzer.py

@@ -128,6 +128,8 @@ def _infer_role(name: str, ecosystem: str, scope: str) -> str:
         return "runtime"
 
     if ecosystem == "java":
+        if scope == "provided":
+            return "provided"
         artifact = n.split(":")[-1] if ":" in n else n
         if any(x in artifact for x in ("spring-boot", "spring-security")):
             return "runtime"
@@ -1120,6 +1122,23 @@ class DependencyAnalyzer:
         properties = self._parse_maven_properties(root_elem, ns)
         dm_versions = self._parse_dependency_management(root_elem, ns, properties)
 
+        # FIX-9: extract parent version for BOM resolution
+        parent_elem = root_elem.find(f"{ns}parent")
+        parent_version: Optional[str] = None
+        parent_group: str = ""
+        if parent_elem is not None:
+            parent_version = (parent_elem.findtext(f"{ns}version") or "").strip() or None
+            parent_group = (parent_elem.findtext(f"{ns}groupId") or "").strip()
+            parent_artifact = (parent_elem.findtext(f"{ns}artifactId") or "").strip()
+            # Propagate parent version into properties for ${project.parent.version}
+            if parent_version:
+                properties.setdefault("project.parent.version", parent_version)
+                properties.setdefault("revision", parent_version)
+
+        # Infer packaging for FIX-6 (used by scope hint for provided)
+        packaging_elem = root_elem.find(f"{ns}packaging")
+        is_war = packaging_elem is not None and (packaging_elem.text or "").strip().lower() == "war"
+
         records: list[DependencyRecord] = []
         deps_elem = root_elem.find(f"{ns}dependencies")
         if deps_elem is None:
@@ -1134,14 +1153,36 @@ class DependencyAnalyzer:
             declared = self._resolve_maven_version(version_raw, properties)
             if declared is None:
                 declared = dm_versions.get(f"{group_id}:{artifact_id}")
+
+            # FIX-4: proper maven scope mapping
             scope_text = (dep.findtext(f"{ns}scope") or "compile").strip().lower()
-            scope = "dev" if scope_text == "test" else "direct"
+            if scope_text == "test":
+                scope = "dev"
+            elif scope_text == "provided":
+                scope = "provided"
+            else:
+                scope = "direct"  # compile, runtime, system, import
+
+            # FIX-4: infer provided for embedded tomcat in WAR projects
+            if (is_war and scope == "direct"
+                    and artifact_id in ("spring-boot-starter-tomcat", "tomcat-embed-core")):
+                scope = "provided"
+
+            # FIX-9: resolve BOM version for Spring Boot / Spring Security starters
+            resolved_version: Optional[str] = None
+            if declared is None and parent_version:
+                if group_id == "org.springframework.boot":
+                    resolved_version = parent_version
+                elif group_id == "org.springframework.security" and "spring-security.version" in properties:
+                    resolved_version = properties["spring-security.version"]
+
             records.append(
                 DependencyRecord(
                     name=f"{group_id}:{artifact_id}",
                     ecosystem="java",
                     scope=scope,
                     declared_version=declared,
+                    resolved_version=resolved_version,
                     source="manifest",
                     manifest_path="pom.xml",
                 )
@@ -1150,6 +1191,18 @@ class DependencyAnalyzer:
         limitations: list[str] = []
         if not records:
             limitations.append("java: pom.xml sin dependencias parseables (puede usar BOM o propiedades)")
+
+        # Warn when Spring Boot BOM manages transitive deps — they can't be resolved statically.
+        parent_artifact_local = (
+            root_elem.findtext(f"{ns}parent/{ns}artifactId") or ""
+        ).strip() if parent_elem is not None else ""
+        if parent_artifact_local == "spring-boot-starter-parent" and parent_version:
+            limitations.append(
+                f"spring_boot_bom_detected: transitive deps managed by Spring Boot BOM "
+                f"v{parent_version}, not resolved statically. "
+                "Run 'mvn dependency:tree' for the full transitive tree."
+            )
+
         return records, limitations
 
     def _analyze_gradle(self, root: Path) -> tuple[list[DependencyRecord], list[str]]:

sourcecode/detectors/java.py

@@ -14,9 +14,11 @@ from sourcecode.detectors.parsers import read_text_lines, unique_strings
 from sourcecode.schema import FrameworkDetection
 from sourcecode.tree_utils import flatten_file_tree
 
+_NS_TAG_RE = re.compile(r"\{[^}]+\}")
+
 _MAX_FILE_SIZE = 256 * 1024  # 256 KB
 _MAX_JAVA_ENTRY_SCAN = 1000
-_MAX_ANNOTATION_ENTRY_POINTS = 500
+_MAX_ANNOTATION_ENTRY_POINTS = 1000
 
 _REST_CONTROLLER_RE = re.compile(r'@RestController\b')
 _MVC_CONTROLLER_RE = re.compile(r'@Controller\b')
@@ -50,14 +52,34 @@ class JavaDetector(AbstractDetector):
     def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
         frameworks: list[FrameworkDetection] = []
         manifests: list[str] = []
+        language_version: str | None = None
+        packaging: str | None = None
+        app_server_hint: str | None = None
+        spring_profiles: list[str] = []
 
         if "pom.xml" in context.manifests:
             manifests.append("pom.xml")
-            frameworks.extend(self._frameworks_from_pom(context.root / "pom.xml"))
+            pom_path = context.root / "pom.xml"
+            frameworks.extend(self._frameworks_from_pom(pom_path))
+            meta = self._parse_pom_metadata(pom_path)
+            if meta.get("language_version"):
+                language_version = meta["language_version"]
+            if meta.get("packaging"):
+                packaging = meta["packaging"]
         if "build.gradle" in context.manifests:
             manifests.append("build.gradle")
             frameworks.extend(self._frameworks_from_gradle(context.root / "build.gradle"))
 
+        # Detect app server from descriptor files
+        all_paths = flatten_file_tree(context.file_tree)
+        if any("weblogic.xml" in p or "weblogic-ejb-jar.xml" in p for p in all_paths):
+            app_server_hint = "weblogic"
+        elif any("wildfly" in p.lower() or "jboss" in p.lower() for p in all_paths):
+            app_server_hint = "wildfly"
+
+        # Spring profiles — check src/main/options/, src/main/resources/
+        spring_profiles = self._detect_spring_profiles(context.root, all_paths)
+
         entry_points = self._collect_entry_points(context)
         stack = StackDetection(
             stack="java",
@@ -65,27 +87,124 @@ class JavaDetector(AbstractDetector):
             confidence="high",
             frameworks=self._dedupe_frameworks(frameworks),
             manifests=manifests,
+            language_version=language_version,
+            packaging=packaging,
+            app_server_hint=app_server_hint,
+            spring_profiles=spring_profiles,
         )
         return [stack], entry_points
 
+    def _parse_pom_metadata(self, path: Path) -> dict:
+        """Extract packaging, java version from pom.xml properties/parent."""
+        result: dict = {}
+        try:
+            tree = ElementTree.parse(path)
+        except (OSError, ElementTree.ParseError):
+            return result
+        root = tree.getroot()
+        ns_match = _NS_TAG_RE.match(root.tag)
+        ns = ns_match.group(0) if ns_match else ""
+
+        # Packaging (FIX-6)
+        packaging_elem = root.find(f"{ns}packaging")
+        if packaging_elem is not None and packaging_elem.text:
+            result["packaging"] = packaging_elem.text.strip().lower()
+
+        # Properties
+        props_elem = root.find(f"{ns}properties")
+        props: dict[str, str] = {}
+        if props_elem is not None:
+            for prop in props_elem:
+                tag = prop.tag.replace(ns, "") if ns else prop.tag
+                if prop.text:
+                    props[tag] = prop.text.strip()
+
+        # Java version (FIX-7) — check properties first, then compiler plugin
+        for key in ("maven.compiler.source", "java.version", "maven.compiler.release"):
+            if key in props:
+                result["language_version"] = props[key]
+                break
+        if "language_version" not in result:
+            # Check maven-compiler-plugin configuration
+            for plugin in root.findall(f".//{ns}plugin"):
+                artifact = (plugin.findtext(f"{ns}artifactId") or "").strip()
+                if artifact == "maven-compiler-plugin":
+                    config = plugin.find(f"{ns}configuration")
+                    if config is not None:
+                        for tag in ("source", "release"):
+                            val = config.findtext(f"{ns}{tag}")
+                            if val:
+                                result["language_version"] = val.strip()
+                                break
+                    break
+
+        return result
+
+    def _detect_spring_profiles(self, root: Path, all_paths: list[str]) -> list[str]:
+        """Detect Spring profiles from option/resource directories and application-{profile}.yml."""
+        profiles: list[str] = []
+        seen: set[str] = set()
+
+        # Pattern 1: src/main/options/{profile}/ directories
+        _PROFILE_DIRS = ("src/main/options/", "src/main/resources/")
+        for path in all_paths:
+            for prefix in _PROFILE_DIRS:
+                if path.startswith(prefix):
+                    remainder = path[len(prefix):]
+                    parts = remainder.split("/")
+                    if len(parts) >= 1 and parts[0] and not parts[0].startswith("."):
+                        candidate = parts[0]
+                        # Only if it's a directory (has sub-paths) with application.yml
+                        if candidate not in seen and not candidate.endswith(".yml") and not candidate.endswith(".yaml") and not candidate.endswith(".properties"):
+                            seen.add(candidate)
+                            profiles.append(candidate)
+                break
+
+        # Pattern 2: application-{profile}.yml files
+        _APP_PROFILE_RE = re.compile(r"application-([A-Za-z0-9_-]+)\.ya?ml$")
+        for path in all_paths:
+            m = _APP_PROFILE_RE.search(path)
+            if m:
+                profile = m.group(1)
+                if profile not in seen:
+                    seen.add(profile)
+                    profiles.append(profile)
+
+        # Filter out generic names that aren't profiles
+        _SKIP = frozenset({"test", "it", "integration"})
+        return [p for p in profiles if p.lower() not in _SKIP]
+
     def _frameworks_from_pom(self, path: Path) -> list[FrameworkDetection]:
         try:
             tree = ElementTree.parse(path)
         except (OSError, ElementTree.ParseError):
             return []
-        text = ElementTree.tostring(tree.getroot(), encoding="unicode").lower()
-        return self._detect_jvm_frameworks(text, "pom.xml")
+        root_elem = tree.getroot()
+        ns_match = _NS_TAG_RE.match(root_elem.tag)
+        ns = ns_match.group(0) if ns_match else ""
+
+        # Extract Spring Boot version from <parent> (FIX-3)
+        sb_version: str | None = None
+        parent_elem = root_elem.find(f"{ns}parent")
+        if parent_elem is not None:
+            parent_artifact = (parent_elem.findtext(f"{ns}artifactId") or "").strip()
+            if parent_artifact == "spring-boot-starter-parent":
+                sb_version = (parent_elem.findtext(f"{ns}version") or "").strip() or None
+
+        text = ElementTree.tostring(root_elem, encoding="unicode").lower()
+        frameworks = self._detect_jvm_frameworks(text, "pom.xml", sb_version=sb_version)
+        return frameworks
 
     def _frameworks_from_gradle(self, path: Path) -> list[FrameworkDetection]:
         content = "\n".join(read_text_lines(path)).lower()
         return self._detect_jvm_frameworks(content, "build.gradle")
 
-    def _detect_jvm_frameworks(self, text: str, source: str) -> list[FrameworkDetection]:
+    def _detect_jvm_frameworks(self, text: str, source: str, *, sb_version: str | None = None) -> list[FrameworkDetection]:
         frameworks: list[FrameworkDetection] = []
         if "com.android.application" in text or "com.android.library" in text:
             frameworks.append(FrameworkDetection(name="Android", source=source))
         if "spring-boot" in text:
-            frameworks.append(FrameworkDetection(name="Spring Boot", source=source))
+            frameworks.append(FrameworkDetection(name="Spring Boot", source=source, version=sb_version))
         if "spring-webmvc" in text or "spring-web" in text:
             frameworks.append(FrameworkDetection(name="Spring MVC", source=source))
         if "spring-webflux" in text:
@@ -117,10 +236,12 @@ class JavaDetector(AbstractDetector):
         ]
 
         # 2. Annotation-based scan: @RestController, @WebFilter, FilterRegistrationBean
-        scan_candidates = [
-            p for p in all_java
-            if "/test/" not in p and "/tests/" not in p
-        ][:_MAX_JAVA_ENTRY_SCAN]
+        # Prioritize Controller-named files so all REST controllers are detected
+        # even in large codebases where total files > _MAX_JAVA_ENTRY_SCAN.
+        _non_test = [p for p in all_java if "/test/" not in p and "/tests/" not in p]
+        _ctrl_files = [p for p in _non_test if "Controller" in p]
+        _other_files = [p for p in _non_test if "Controller" not in p]
+        scan_candidates = _ctrl_files + _other_files[:max(0, _MAX_JAVA_ENTRY_SCAN - len(_ctrl_files))]
 
         annotation_eps: list[EntryPoint] = []
         for rel_path in scan_candidates:

sourcecode/detectors/project.py

@@ -100,7 +100,13 @@ class ProjectDetector:
             detection_method=stack.detection_method,
             confidence=stack.confidence,
             frameworks=[
-                FrameworkDetection(name=framework.name, source=framework.source)
+                FrameworkDetection(
+                    name=framework.name,
+                    source=framework.source,
+                    confidence=framework.confidence,
+                    detected_via=list(framework.detected_via),
+                    version=framework.version,
+                )
                 for framework in stack.frameworks
             ],
             package_manager=stack.package_manager,
@@ -110,6 +116,11 @@ class ProjectDetector:
             workspace=stack.workspace,
             signals=list(stack.signals),
             produced_by=stack.produced_by,
+            # Java-specific fields
+            language_version=stack.language_version,
+            packaging=stack.packaging,
+            app_server_hint=stack.app_server_hint,
+            spring_profiles=list(stack.spring_profiles),
         )
 
     def _merge_stack(self, current: StackDetection, incoming: StackDetection) -> StackDetection:
@@ -124,6 +135,15 @@ class ProjectDetector:
         elif self._confidence_rank(incoming.confidence) == self._confidence_rank(current.confidence):
             if current.detection_method == "heuristic" and incoming.detection_method != "heuristic":
                 current.detection_method = incoming.detection_method
+        # Java-specific: propagate from incoming if not already set
+        if incoming.language_version and not current.language_version:
+            current.language_version = incoming.language_version
+        if incoming.packaging and not current.packaging:
+            current.packaging = incoming.packaging
+        if incoming.app_server_hint and not current.app_server_hint:
+            current.app_server_hint = incoming.app_server_hint
+        if incoming.spring_profiles and not current.spring_profiles:
+            current.spring_profiles = list(incoming.spring_profiles)
         return current
 
     def _merge_frameworks(
@@ -133,10 +153,18 @@ class ProjectDetector:
     ) -> list[FrameworkDetection]:
         merged: dict[str, FrameworkDetection] = {}
         for framework in list(current) + list(incoming):
-            merged.setdefault(
-                framework.name,
-                FrameworkDetection(name=framework.name, source=framework.source),
-            )
+            if framework.name not in merged:
+                merged[framework.name] = FrameworkDetection(
+                    name=framework.name,
+                    source=framework.source,
+                    confidence=framework.confidence,
+                    detected_via=list(framework.detected_via),
+                    version=framework.version,
+                )
+            elif framework.version and not merged[framework.name].version:
+                # Preserve version from whichever source has it
+                from dataclasses import replace as _fr_replace
+                merged[framework.name] = _fr_replace(merged[framework.name], version=framework.version)
         return list(merged.values())
 
     def _merge_manifests(self, current: Iterable[str], incoming: Iterable[str]) -> list[str]:

sourcecode/detectors/tooling.py

@@ -47,6 +47,11 @@ def infer_package_manager(stack: str, file_tree: dict[str, object]) -> str | Non
         return "composer"
     if stack == "ruby" and "Gemfile.lock" in flat_paths:
         return "bundler"
+    if stack == "java":
+        if "pom.xml" in flat_paths:
+            return "maven"
+        if any(p == "build.gradle" or p == "build.gradle.kts" for p in flat_paths):
+            return "gradle"
     if stack == "terraform" and any(path.endswith(".tf") for path in flat_paths):
         return "terraform"
     return None

sourcecode/graph_analyzer.py

@@ -1016,82 +1016,35 @@ class GraphAnalyzer:
         type_map: dict[str, tuple[str, str]],
         workspace: str | None,
     ) -> tuple[list[GraphNode], list[GraphEdge], list[str]]:
+        """Extract module-to-module import edges for JVM files.
+
+        Class/function nodes are intentionally skipped: for large Java codebases
+        (2000+ files) creating one node per class exhausts the node budget before
+        most import edges are processed, resulting in almost no graph edges.
+        Skipping class nodes keeps one module node per file and allows the full
+        import graph to be built within the budget.
+        """
         module_node_id = f"module:{relative_path}"
-        language = self._language_for_suffix(Path(relative_path).suffix)
         nodes: list[GraphNode] = []
         edges: list[GraphEdge] = []
         limitations: list[str] = []
-        imported_type_map = {
-            imported.split(".")[-1]: imported
-            for imported in re.findall(r"(?m)^\s*import\s+([A-Za-z0-9_.]+)", content)
-        }
 
-        class_pattern = re.compile(
-            r"(?m)^\s*(?:public\s+|private\s+|protected\s+|internal\s+)?"
-            r"(?:class|interface|object|trait)\s+([A-Za-z_][A-Za-z0-9_]*)"
-            r"(?:\s+extends\s+([A-Za-z_][A-Za-z0-9_.]*))?"
-        )
-        local_class_ids: dict[str, str] = {}
-        for match in class_pattern.finditer(content):
-            name = match.group(1)
-            base = match.group(2)
-            node_id = f"class:{relative_path}:{name}"
-            local_class_ids[name] = node_id
-            nodes.append(
-                GraphNode(
-                    id=node_id,
-                    kind="class",
-                    language=language,
-                    path=relative_path,
-                    symbol=name,
-                    display_name=name,
-                    workspace=workspace,
-                )
-            )
-            edges.append(
-                GraphEdge(
-                    source=module_node_id,
-                    target=node_id,
-                    kind="contains",
-                    confidence="medium",
-                    method="heuristic",
-                )
-            )
-            if base:
-                base_short = base.split(".")[-1]
-                if base_short in local_class_ids:
-                    edges.append(
-                        GraphEdge(
-                            source=node_id,
-                            target=local_class_ids[base_short],
-                            kind="extends",
-                            confidence="low",
-                            method="heuristic",
-                        )
-                    )
-                else:
-                    imported_base = imported_type_map.get(base_short)
-                    fqcn = imported_base or base
-                    mapping = type_map.get(fqcn)
-                    if mapping is None:
-                        continue
-                    base_path, _base_name = mapping
-                    edges.append(
-                        GraphEdge(
-                            source=node_id,
-                            target=f"class:{base_path}:{base_short}",
-                            kind="extends",
-                            confidence="low",
-                            method="heuristic",
-                        )
-                    )
+        # Extract imports, skipping static imports and wildcard imports
+        # Pattern includes optional 'static' keyword; \w at end excludes wildcards
+        _import_re = re.compile(r"(?m)^\s*import\s+(?:static\s+)?([A-Za-z][A-Za-z0-9_.]*\w)\s*;")
+        imported_fqcns: set[str] = set()
+        for m in _import_re.finditer(content):
+            imported_fqcns.add(m.group(1))
 
-        for imported in imported_type_map.values():
-            mapping = type_map.get(imported)
+        seen_targets: set[str] = set()
+        for fqcn in imported_fqcns:
+            mapping = type_map.get(fqcn)
             if mapping is None:
-                limitations.append(f"jvm_unresolved:{relative_path}:{imported}")
                 continue
             target_path, _symbol = mapping
+            if target_path == relative_path or target_path in seen_targets:
+                continue
+            seen_targets.add(target_path)
             edges.append(
                 GraphEdge(
                     source=module_node_id,

sourcecode/schema.py

@@ -45,6 +45,7 @@ class FrameworkDetection:
     source: str = "manifest"
     confidence: Literal["high", "medium", "low"] = "high"
     detected_via: list[str] = field(default_factory=list)
+    version: Optional[str] = None  # e.g. "2.7.18" for Spring Boot
 
 
 @dataclass
@@ -62,6 +63,11 @@ class StackDetection:
     workspace: Optional[str] = None
     signals: list[str] = field(default_factory=list)
     produced_by: Optional[str] = None  # which detector emitted this
+    # Java-specific fields (FIX-6, FIX-7)
+    language_version: Optional[str] = None   # e.g. "1.8" from maven.compiler.source
+    packaging: Optional[str] = None          # e.g. "war" | "jar"
+    app_server_hint: Optional[str] = None    # e.g. "weblogic" | "wildfly"
+    spring_profiles: list[str] = field(default_factory=list)  # detected Spring profiles
 
 
 @dataclass
@@ -656,3 +662,8 @@ class SourceMap:
     # AST contract mode (v0.33.0) — populated when --mode contract|hybrid
     file_contracts: list[Any] = field(default_factory=list)   # list[FileContract]
     contract_summary: Optional[Any] = None                    # ContractSummary
+    # Java-specific root fields (v1.3.0) — additive, null/empty for non-Java projects
+    packaging: Optional[str] = None           # "war" | "jar"
+    language_version: Optional[str] = None    # "1.8" | "11" | "17"
+    spring_profiles: list[str] = field(default_factory=list)
+    app_server_hint: Optional[str] = None     # "weblogic" | "wildfly" | "tomcat"

sourcecode/serializer.py

@@ -1056,6 +1056,16 @@ def standard_view(sm: SourceMap, *, include_tree: bool = False) -> dict[str, Any
     if ep_groups["auxiliary"]:
         result["auxiliary_entry_points"] = ep_groups["auxiliary"][:_EP_DEV_CAP]
 
+    # Java-specific root fields (FIX-6, FIX-7, FIX-8)
+    if getattr(sm, "packaging", None):
+        result["packaging"] = sm.packaging
+    if getattr(sm, "language_version", None):
+        result["language_version"] = sm.language_version
+    if getattr(sm, "spring_profiles", None):
+        result["spring_profiles"] = sm.spring_profiles
+    if getattr(sm, "app_server_hint", None):
+        result["app_server_hint"] = sm.app_server_hint
+
     # Layer B — signals (only when the corresponding analyzer ran)
     if sm.dependency_summary is not None and sm.dependency_summary.requested:
         dep_dict = asdict(sm.dependency_summary)
@@ -1196,6 +1206,20 @@ def _contract_view_minimal(
         "project": project,
     }
 
+    # Full stacks list (needed for version checks in smoke tests)
+    if sm.stacks:
+        result["stacks"] = [asdict(s) for s in sm.stacks]
+
+    # Java-specific root fields
+    if getattr(sm, "packaging", None):
+        result["packaging"] = sm.packaging
+    if getattr(sm, "language_version", None):
+        result["language_version"] = sm.language_version
+    if getattr(sm, "spring_profiles", None):
+        result["spring_profiles"] = sm.spring_profiles
+    if getattr(sm, "app_server_hint", None):
+        result["app_server_hint"] = sm.app_server_hint
+
     # Per-file contracts
     if contracts:
         serialized: list[dict[str, Any]] = []
@@ -1295,6 +1319,15 @@ def _contract_view_minimal(
     if sm.analysis_gaps:
         result["analysis_gaps"] = [asdict(g) for g in sm.analysis_gaps]
 
+    # Module graph — included when --graph-modules was requested
+    if sm.module_graph is not None and sm.module_graph_summary is not None and sm.module_graph_summary.requested:
+        result["module_graph"] = {
+            "nodes": [asdict(n) for n in sm.module_graph.nodes],
+            "edges": [asdict(e) for e in sm.module_graph.edges],
+            "summary": asdict(sm.module_graph_summary),
+        }
+        result["module_graph_summary"] = asdict(sm.module_graph_summary)
+
     return result
 
 
@@ -1377,8 +1410,60 @@ _MAX_FN_PER_CONTRACT = 5   # max function signatures per contract (token budget)
 _MAX_SIG_LEN = 60          # max chars per compressed signature
 
 
+def _serialize_contract_java(c: Any) -> dict[str, Any]:
+    """Java-specific contract serializer with full field names and annotations."""
+    item: dict[str, Any] = {"path": c.path, "language": "java"}
+
+    exports_out: list[dict] = []
+    for e in c.exports:
+        entry: dict = {"kind": e.kind, "name": e.name}
+        if getattr(e, "annotations", None):
+            entry["annotations"] = e.annotations
+        if getattr(e, "extends", None):
+            entry["extends"] = e.extends
+        if getattr(e, "implements", None) and e.implements:
+            entry["implements"] = e.implements
+        if getattr(e, "signature", None):
+            entry["signature"] = e.signature
+        exports_out.append(entry)
+    if exports_out:
+        item["exports"] = exports_out
+
+    if c.imports:
+        item["imports"] = [imp.source for imp in c.imports[:20]]
+
+    autowired = getattr(c, "autowired_fields", [])
+    if autowired:
+        item["autowired_fields"] = autowired
+
+    return item
+
+
+def _serialize_contract_mybatis_xml(c: Any) -> dict[str, Any]:
+    """Serialize a MyBatis *Mapper.xml contract."""
+    item: dict[str, Any] = {"path": c.path, "language": "mybatis-xml"}
+    # Extract namespace stored as "namespace:<fqn>" in dependencies
+    for dep in (c.dependencies or []):
+        if dep.startswith("namespace:"):
+            item["namespace"] = dep[len("namespace:"):]
+            break
+    exports_out: list[dict] = []
+    for e in c.exports:
+        entry: dict = {"kind": e.kind, "name": e.name}
+        if getattr(e, "type_ref", None):
+            entry["type"] = e.type_ref
+        exports_out.append(entry)
+    if exports_out:
+        item["exports"] = exports_out
+    return item
+
+
 def _serialize_contract_minimal(c: Any) -> dict[str, Any]:
     """Serialize one FileContract to minimal format."""
+    if getattr(c, "language", None) == "java":
+        return _serialize_contract_java(c)
+    if getattr(c, "language", None) == "mybatis-xml":
+        return _serialize_contract_mybatis_xml(c)
     item: dict[str, Any] = {"path": c.path, "role": c.role}
 
     if c.is_changed:
@@ -1496,6 +1581,11 @@ def _contract_view_standard(
     if contracts:
         serialized: list[dict[str, Any]] = []
         for c in contracts:
+            if getattr(c, "language", None) == "mybatis-xml":
+                item = _serialize_contract_mybatis_xml(c)
+                item["relevance_score"] = round(c.relevance_score, 3)
+                serialized.append(item)
+                continue
             item: dict[str, Any] = {
                 "path": c.path,
                 "language": c.language,
@@ -1545,7 +1635,7 @@ def _contract_view_standard(
                     item["ranking_reasons"] = non_trivial
             item["method"] = c.extraction_method
             serialized.append(item)
-        result["file_contracts"] = serialized
+        result["contracts"] = serialized
 
     # Optional analysis sections (deep mode or when analyzers ran)
     if include_optional:

{sourcecode-1.3.0.dist-info → sourcecode-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.3.0
+Version: 1.5.0
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004

{sourcecode-1.3.0.dist-info → sourcecode-1.5.0.dist-info}/RECORD

@@ -1,24 +1,24 @@
-sourcecode/__init__.py,sha256=OFSkiae_6W3SLXW8WqBF-PGOUxC4FhKuxuKQDTuCuvc,102
+sourcecode/__init__.py,sha256=81eXvIk2uxc6dFJg9ND6pJ-xePSGbA0ZUJgr1h_bZ48,102
 sourcecode/adaptive_scanner.py,sha256=6dh34C2qZXyRbw-8xBhbEwDdXanM6CRFRWayVoYITnA,10190
-sourcecode/architecture_analyzer.py,sha256=qzDW3_lQv__czQ-qs6AqEEoMvTfhfp7M7kNslPuQy7A,32128
+sourcecode/architecture_analyzer.py,sha256=oPmGPf9_p6y8Z7SIGHEu57nVYwxycIovDzBvlHl-l5k,32557
 sourcecode/architecture_summary.py,sha256=J9yoLgh8wXwIRrT6q6JooB6PekivbOEYpJz4BUXdalk,20545
-sourcecode/ast_extractor.py,sha256=zvHeO-w0evdS8EAJhwlK7hhrWMGN-lnHm6XFdZlaST8,44389
+sourcecode/ast_extractor.py,sha256=XgrZg2DcWcUm9r87cRG3KGO7IK2TIL_N-CvhSbUmmh4,49901
 sourcecode/classifier.py,sha256=GKTMN8qKZX7ponSwDJfN08RrasI4CVpq1_gFBgEopps,7093
-sourcecode/cli.py,sha256=0g7U2s1pyoTqFc7ne62Z305bErRKuHuKGyN0VrlsSOk,72971
+sourcecode/cli.py,sha256=_oYoP4_AAFGw0gg-FBGn_DKh7y49xmwuL6D_Bafl2w4,74497
 sourcecode/code_notes_analyzer.py,sha256=rRd8bFYV0krjlxxQV0wenwE9K7pVpUQSR7KvSvUQKw4,9226
 sourcecode/confidence_analyzer.py,sha256=HcaewB2pZaZ_hfKrZWtr_yPMY2-CxS1zzTUD7c4argc,13188
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
 sourcecode/context_summarizer.py,sha256=CiQrfBEzun949bWvmLabWoj2HhPn6Lw62ofqnsy0FlQ,6503
-sourcecode/contract_model.py,sha256=gCf9-Kj0G7l0lvRTAcRfFAfMgs1Rpizv4mKovQLYUkw,3434
-sourcecode/contract_pipeline.py,sha256=lDa0MgalW-WPXwbWKX2NB6HWxt_15P6GZNXgAoJeDAE,25985
+sourcecode/contract_model.py,sha256=nRxJKPMs1VHwFTa8AVXhGmaLjti3Lr2sjHDpWgv1bfE,3917
+sourcecode/contract_pipeline.py,sha256=_mZn0GD7UjjJ7E79DmmYjF0sVkuOLBZEgZHqgXVyTrs,26648
 sourcecode/coverage_parser.py,sha256=q0LeZJaX1bnntLu-ImksdBsMlpsVmk_iUfSaB4eaJGo,19702
-sourcecode/dependency_analyzer.py,sha256=EZyBI1-VkYCmPrcIIIpa7WAp888FF9Ct4nY2ronowUg,53555
+sourcecode/dependency_analyzer.py,sha256=p4ljXhkcGBbFlhaZuPrsjOVjDXaKLTg0Gor2p4qFPP0,56208
 sourcecode/doc_analyzer.py,sha256=a1CIClCNmfYM3ku4bdgwHQpmb6Js4wdJZ1V5EYLo04I,24345
 sourcecode/entrypoint_classifier.py,sha256=gvKgl0f5T8ol1r4JMmkeqGHuZTfZJiOwFOWdc7EYwYw,4061
 sourcecode/env_analyzer.py,sha256=GxCidahAAIptTdDFIlVB6URd4HBnBlIX_SqUov3MBRQ,22076
 sourcecode/file_classifier.py,sha256=48ly5Z6exkzBy8lNy1AkdP4-oJqIA1zT3LZfffuTyDo,11572
 sourcecode/git_analyzer.py,sha256=PD3eNWydznQ6KLNpxGzBqizIHoPIKevfwz9Xyf_pDt4,11600
-sourcecode/graph_analyzer.py,sha256=Ko3nJp_wx92jic6AuFbdkOstDjzl-O62g1zazYJjm9w,64157
+sourcecode/graph_analyzer.py,sha256=iUK-7pSV-cvGqqD2hENdYmhnm0wcXFEyK-xnu5ul8OU,62515
 sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
 sourcecode/prepare_context.py,sha256=LsFDp7HnHdvtwVa46YUD60uMBfwXaVs4suMfBvc8tyI,37357
 sourcecode/ranking_engine.py,sha256=virVglafZufioHpZpwktjMvUiL0TZELWQCQnQNV8dFo,9360
@@ -27,9 +27,9 @@ sourcecode/relevance_scorer.py,sha256=MYF4FFkveAQps9SmTeTlh6ODiBz2F--_hWNeHMLtUH
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
 sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBGPjQ,14792
 sourcecode/scanner.py,sha256=aM3h9-DCQ3xKpeHpHYdo2vX6T5P95HA_YwZbkAVNwmo,8288
-sourcecode/schema.py,sha256=M0aA3sIIm8QHDIAducZUm5mGpgJ7oXfqtyvoMkLGMac,23270
+sourcecode/schema.py,sha256=rNxpDUgOfvJDzz6DKitL-5_0UAh0YomNwTsSSe8PafY,24066
 sourcecode/semantic_analyzer.py,sha256=12TwXYkYbDcBdu0heX_EmfPM2EkO8a_r5osf0SaeQbs,88956
-sourcecode/serializer.py,sha256=-OFruU8NHsmHR_IKOb11VVl3-WOBXKPhyCtM8NZZtb0,65832
+sourcecode/serializer.py,sha256=2ztWD4FCebPD0D5tY-kNgLlsATaQsPrSQY6rLQeemRI,69467
 sourcecode/summarizer.py,sha256=ZuzIdm3t8A-d5MuQL0TSNLrd-L0IQIuguIxeNXMNJf8,16070
 sourcecode/tree_utils.py,sha256=Fj9OIuUksBvgibNd3feog0sMDjVypJzPexp5lvMoYWI,1424
 sourcecode/workspace.py,sha256=X_6NmNnitvT3_38V-JDChydo_sR68s249hLFlrQskU0,8271
@@ -42,26 +42,26 @@ sourcecode/detectors/elixir.py,sha256=jCpvt5Yi6jvplc80ovRtWh17q-11ZGo9qX7o8b57TJ
 sourcecode/detectors/go.py,sha256=2r66uRQfeTWsqxr4HDhT6vExZErby0t46QXLHVBRv9w,2782
 sourcecode/detectors/heuristic.py,sha256=bCqqgbHavl4Sse3dqT8mwmo1wAdgeJr7VyXOmfClLKo,3387
 sourcecode/detectors/hybrid.py,sha256=IGFRUVsAZ1ooRlFdznCeJAV6vy1yVDx-VyghvLtddXc,9101
-sourcecode/detectors/java.py,sha256=Lv-a1YeXezJYZCJduWfeeLMTUgyPz4lyiYu9Edi8-7E,10821
+sourcecode/detectors/java.py,sha256=0NKsy1uls5wvQSK7DJP_fM-v5_uuMEr_an47caelLHE,16612
 sourcecode/detectors/jvm_ext.py,sha256=EgHJ5W8EE-ZTN9V607mVzohyKgZE8Mc2jCi-DF8RAZU,2616
 sourcecode/detectors/nodejs.py,sha256=7fsyAmrGkkguX6U80HUQpIe9MRaYyi_A7zbaRtmFmGc,13097
 sourcecode/detectors/parsers.py,sha256=ugPg8yNUf0Ai1gA7Fnn6wAkYGFjTxRodSP3IeViYJJ4,2290
 sourcecode/detectors/php.py,sha256=W_AQD0WMVDdWHa9h_ilX6W8XSpz0X4ctpMK2WXfXf1I,1887
-sourcecode/detectors/project.py,sha256=egFUnHC93xFfb-ikGCIOSkRdyP52qytDx9W7pGkX0MY,6525
+sourcecode/detectors/project.py,sha256=hy2Mjifl3by2YcAZ8OY2g_1ptlaVQu9sfchHhNJQ4WM,8084
 sourcecode/detectors/python.py,sha256=i2_Wtk_p0BJx5R8gBQ8NaQByzJ8zEfZkw9NNpKlvOYM,10486
 sourcecode/detectors/ruby.py,sha256=Q4B5ePAw6-T4DLfanKJiuLHLqUigTPVrzylcXJMei3M,1591
 sourcecode/detectors/rust.py,sha256=Tij1vz8BFZ332GEvVkL6vyMli2OMHJfHyDAppWfe66c,3557
 sourcecode/detectors/systems.py,sha256=nYaKbGDFu0EOXFcd_1doWFT3tTUdkbxc2DjHUF5TcqQ,1627
 sourcecode/detectors/terraform.py,sha256=cxORPR_zVLOJpHlh4e9JnFpkQsn_UnqMMom5yG65hZ4,1693
-sourcecode/detectors/tooling.py,sha256=hIvop80No22pqyGVJ32NKliSdjkHRePQkIRroqG01bY,1875
+sourcecode/detectors/tooling.py,sha256=8CKbtxwQoABP-WyBRNmdAmHDOvAH57AR1cF4UKuWEdQ,2074
 sourcecode/telemetry/__init__.py,sha256=M0eQZFNkmJiLbI_oNP4QEXwVju1dQ2d4P-E1-Bw8PxE,3116
 sourcecode/telemetry/config.py,sha256=Pir0WHp4z-9Qclnn2NDZ3vwitqsMkOAJckmwjUSxrk4,1795
 sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWnII,2237
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=KJeIPCPWMdmbCP3ySGs2iUlia34U6vWne2dZsUezesw,1560
-sourcecode-1.3.0.dist-info/METADATA,sha256=5tHuzUw0xpsY6eeCd81OI_pL_vl-3qaMCU78kExd6WI,20411
-sourcecode-1.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.3.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.3.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.3.0.dist-info/RECORD,,
+sourcecode-1.5.0.dist-info/METADATA,sha256=kdZtCFuIhrWj6KDM4nZ-tMqWzuwiY2hXt4C8hP6PETc,20411
+sourcecode-1.5.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.5.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.5.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.5.0.dist-info/RECORD,,