sourcecode 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/ast_extractor.py

@@ -79,6 +79,7 @@ _LANGUAGE_MAP: dict[str, str] = {
     ".jsx": "jsx",
     ".mjs": "javascript",
     ".cjs": "javascript",
+    ".java": "java",
 }
 
 _REACT_HOOKS: frozenset[str] = frozenset({
@@ -938,6 +939,175 @@ def _extract_python(path: str, source: str) -> FileContract:
     )
 
 
+# ---------------------------------------------------------------------------
+# ---------------------------------------------------------------------------
+# Enhanced Java extraction (regex-based, annotation-aware)
+# ---------------------------------------------------------------------------
+
+_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*[\{<])'
+)
+# 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,
+)
+# @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:
+    exports: list[ExportRecord] = []
+    types: list[TypeDefinition] = []
+    functions: list[FunctionSignature] = []
+    imports: list[ImportRecord] = []
+    autowired_fields: list[dict] = []
+
+    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()
+    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
+
+        # 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,
+            async_=False,
+            exported=True,
+            return_type=None,
+        ))
+
+    # External deps: top-2 package segments, skip java.* / javax.*
+    deps = sorted({
+        ".".join(imp.source.split(".")[:2])
+        for imp in imports
+        if not imp.source.startswith("java.") and not imp.source.startswith("javax.")
+        and len(imp.source.split(".")) >= 2
+    })
+
+    return FileContract(
+        path=path,
+        language="java",
+        exports=exports,
+        imports=sorted(imports, key=lambda i: i.source)[:30],
+        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",
+    )
+
+
 # ---------------------------------------------------------------------------
 # Role detection
 # ---------------------------------------------------------------------------
@@ -1048,6 +1218,8 @@ class AstExtractor:
 
         if language == "python":
             contract = _extract_python(rel_path, source)
+        elif language == "java":
+            contract = _extract_java(rel_path, source)
         else:
             if self._ensure_ts():
                 lang_obj = _get_ts_lang(language)

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:
@@ -1270,10 +1279,24 @@ def main(
             and d.scope not in {"dev"}
         ]
 
-        def _dep_sort_key(d: Any) -> tuple[int, int, str]:
+        _JAVA_SEMANTIC_PRIORITY: dict[str, int] = {
+            "spring-boot": 0, "spring-security": 1, "mybatis": 2,
+            "poi": 3, "pdfbox": 4, "jackson": 5, "jjwt": 6,
+        }
+
+        def _java_priority(d: Any) -> int:
+            if d.ecosystem != "java":
+                return 99
+            art = (d.name.split(":")[-1] if ":" in d.name else d.name).lower()
+            for key, pri in _JAVA_SEMANTIC_PRIORITY.items():
+                if key in art:
+                    return pri
+            return 50
+
+        def _dep_sort_key(d: Any) -> tuple[int, int, int, str]:
             role_order = _ROLE_PRIORITY.get(d.role or "runtime", 5)
             eco_order = 0 if d.ecosystem == primary_ecosystem else 1
-            return (role_order, eco_order, d.name.lower())
+            return (role_order, eco_order, _java_priority(d), d.name.lower())
 
         _seen_dep_names: set[str] = set()
         _deduped_deps: list[Any] = []
@@ -1281,7 +1304,7 @@ def main(
             if d.name not in _seen_dep_names:
                 _seen_dep_names.add(d.name)
                 _deduped_deps.append(d)
-        sm.key_dependencies = _deduped_deps[:15]
+        sm.key_dependencies = _deduped_deps  # no cap — all direct deps included
 
     # LQN-02: deterministic NL summary
     sm.project_summary = ProjectSummarizer(target).generate(sm)
@@ -1384,10 +1407,20 @@ def main(
 
     # Contract pipeline — runs for mode=contract|standard|deep|hybrid (skip for raw)
     _is_contract_mode = mode in ("contract", "standard")
+    _pipeline_error = False
     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,
@@ -1405,9 +1438,11 @@ 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)
+            _pipeline_error = True
             _contracts = []
             _contract_summary = _ContractSummary(
                 mode=mode,
@@ -1446,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
@@ -1518,6 +1568,9 @@ def main(
     # 6. Write output (CLI-04)
     write_output(content, output=output)
 
+    if _pipeline_error:
+        raise typer.Exit(code=2)
+
     # 7. Clipboard copy (--copy / -c)
     if copy and output is None:
         _trimmed = content.strip()

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.
 
@@ -317,11 +318,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:
@@ -370,7 +377,15 @@ class ContractPipeline:
         """
         candidates = _find_symbol_files(root, symbol, known_paths, engine)
         if not candidates:
-            return []
+            return [], {
+                "symbol": symbol,
+                "definers_found": 0,
+                "importers_found": 0,
+                "importers_returned": 0,
+                "references_found": 0,
+                "total_returned": 0,
+                "truncated": False,
+            }
 
         extra: list[FileContract] = []
         for rel_path in candidates[:300]:  # cap to prevent excessive extraction
@@ -577,7 +592,7 @@ def _find_symbol_files(
                 "grep", "-rl",
                 "--include=*.ts", "--include=*.tsx",
                 "--include=*.js", "--include=*.jsx",
-                "--include=*.py",
+                "--include=*.py", "--include=*.java",
                 symbol, ".",
             ],
             cwd=str(root),

sourcecode/dependency_analyzer.py

@@ -127,6 +127,24 @@ def _infer_role(name: str, ecosystem: str, scope: str) -> str:
             return "infra"
         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"
+        if any(x in artifact for x in ("spring-web", "spring-mvc", "spring-core", "spring-context")):
+            return "runtime"
+        if any(x in artifact for x in ("mybatis", "hibernate", "jpa", "druid", "datasource")):
+            return "infra"
+        if any(x in artifact for x in ("jackson", "gson", "fastjson")):
+            return "serialization"
+        if any(x in artifact for x in ("poi", "pdfbox", "itext", "openpdf")):
+            return "parsing"
+        if any(x in artifact for x in ("jjwt", "nimbus-jose")):
+            return "runtime"
+        return "devtool" if is_dev else "runtime"
+
     return "devtool" if is_dev else "runtime"
 
 
@@ -1104,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:
@@ -1118,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",
                 )

sourcecode/detectors/java.py

@@ -14,6 +14,8 @@ 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
@@ -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: