sourcecode 1.2.0__tar.gz → 1.3.0__tar.gz

{sourcecode-1.2.0 → sourcecode-1.3.0}/PKG-INFO

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

{sourcecode-1.2.0 → sourcecode-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.2.0"
+version = "1.3.0"
 description = "Deterministic codebase context for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.2.0 → sourcecode-1.3.0}/src/sourcecode/__init__.py

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

{sourcecode-1.2.0 → sourcecode-1.3.0}/src/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,92 @@ def _extract_python(path: str, source: str) -> FileContract:
     )
 
 
+# ---------------------------------------------------------------------------
+# Minimal Java extraction (regex-based, no AST)
+# ---------------------------------------------------------------------------
+
+_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_METHOD_SIG_RE = re.compile(
+    r'^\s{0,12}public\s+[^\{]+\(',
+    re.MULTILINE,
+)
+_JAVA_IMPORT_RE = re.compile(r'^import\s+(?:static\s+)?([^;\s]+)\s*;', re.MULTILINE)
+
+
+def _extract_java(path: str, source: str) -> FileContract:
+    exports: list[ExportRecord] = []
+    types: list[TypeDefinition] = []
+    functions: list[FunctionSignature] = []
+    imports: list[ImportRecord] = []
+
+    # 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)
+    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:
+            continue
+        mname = name_match.group(1)
+        if mname in class_names or mname in seen_methods or mname in {"if", "for", "while", "switch"}:
+            continue
+        seen_methods.add(mname)
+        functions.append(FunctionSignature(
+            name=mname,
+            signature=sig_text,
+            async_=False,
+            exported=True,
+            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])
+        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],
+        extraction_method="heuristic",
+    )
+
+
 # ---------------------------------------------------------------------------
 # Role detection
 # ---------------------------------------------------------------------------
@@ -1048,6 +1135,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-1.2.0 → sourcecode-1.3.0}/src/sourcecode/cli.py

@@ -1270,10 +1270,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 +1295,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,6 +1398,7 @@ 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
@@ -1408,6 +1423,7 @@ def main(
             )
         except Exception as _exc:
             typer.echo(f"[error] contract pipeline failed: {_exc}", err=True)
+            _pipeline_error = True
             _contracts = []
             _contract_summary = _ContractSummary(
                 mode=mode,
@@ -1518,6 +1534,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-1.2.0 → sourcecode-1.3.0}/src/sourcecode/contract_pipeline.py

@@ -370,7 +370,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 +585,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-1.2.0 → sourcecode-1.3.0}/src/sourcecode/dependency_analyzer.py

@@ -127,6 +127,22 @@ def _infer_role(name: str, ecosystem: str, scope: str) -> str:
             return "infra"
         return "runtime"
 
+    if ecosystem == "java":
+        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"
 
 

{sourcecode-1.2.0 → sourcecode-1.3.0}/src/sourcecode/doc_analyzer.py

@@ -174,6 +174,14 @@ class DocAnalyzer:
                 limitations.extend(file_limitations)
                 if file_records:
                     languages.add(lang)
+            elif suffix == ".java":
+                file_records, file_limitations = self._analyze_java_file(
+                    norm_path, content, depth, workspace, entry_points
+                )
+                records.extend(file_records)
+                limitations.extend(file_limitations)
+                if file_records:
+                    languages.add("java")
             else:
                 # Unsupported language — D-04: no emitir DocRecord, solo registrar limitation
                 limitations.append(f"docs_unavailable:{norm_path}:language={lang}")
@@ -182,7 +190,7 @@ class DocAnalyzer:
                 # NO records.append() here
 
         # Build language_coverage: explicit per-language support status
-        _SUPPORTED_LANGS = {"python", "javascript", "typescript"}
+        _SUPPORTED_LANGS = {"python", "javascript", "typescript", "java"}
         lang_coverage: dict[str, str] = {}
         for lang in languages:
             if lang in _SUPPORTED_LANGS:
@@ -225,6 +233,73 @@ class DocAnalyzer:
         )
         return records, summary
 
+    # Javadoc: /** ... */ block followed by class/method declaration
+    _JAVADOC_RE = re.compile(r'/\*\*(.*?)\*/', re.DOTALL)
+    _JAVA_CLASS_AFTER_RE = re.compile(
+        r'(?:public\s+)?(?:abstract\s+)?(?:final\s+)?(?:class|interface|enum)\s+(\w+)',
+    )
+    _JAVA_METHOD_AFTER_RE = re.compile(
+        r'public\s+[\w<>\[\],\s]+?\s+(\w+)\s*\(',
+    )
+
+    def _clean_javadoc(self, raw: str) -> str:
+        lines = raw.strip().splitlines()
+        cleaned: list[str] = []
+        for line in lines:
+            line = re.sub(r'^\s*\*\s?', '', line).strip()
+            if line.startswith('@'):
+                continue
+            if line:
+                cleaned.append(line)
+        result = ' '.join(cleaned)
+        if len(result) > self._DOCSTRING_MAX_CHARS:
+            result = result[:self._DOCSTRING_MAX_CHARS] + self._TRUNCATION_SUFFIX
+        return result
+
+    def _analyze_java_file(
+        self,
+        path: str,
+        content: str,
+        depth: "DocsDepth",
+        workspace: "str | None",
+        entry_points: "list[str] | None",
+    ) -> "tuple[list[DocRecord], list[str]]":
+        records: list[DocRecord] = []
+        for jd_match in self._JAVADOC_RE.finditer(content):
+            lookahead = content[jd_match.end():jd_match.end() + 400].lstrip()
+            # Class-level Javadoc
+            class_m = self._JAVA_CLASS_AFTER_RE.match(lookahead)
+            if class_m:
+                name = class_m.group(1)
+                doc_text = self._clean_javadoc(jd_match.group(1))
+                records.append(DocRecord(
+                    path=path,
+                    workspace=workspace,
+                    kind="class",
+                    name=name,
+                    doc_text=doc_text,
+                    importance=self._infer_importance(path, "class", entry_points),
+                ))
+                continue
+            # Method-level Javadoc (only when depth != "module")
+            if depth == "module":
+                continue
+            method_m = self._JAVA_METHOD_AFTER_RE.match(lookahead)
+            if method_m:
+                name = method_m.group(1)
+                if name in {"if", "for", "while", "switch", "return", "new"}:
+                    continue
+                doc_text = self._clean_javadoc(jd_match.group(1))
+                records.append(DocRecord(
+                    path=path,
+                    workspace=workspace,
+                    kind="function",
+                    name=name,
+                    doc_text=doc_text,
+                    importance=self._infer_importance(path, "function", entry_points),
+                ))
+        return records, []
+
     def merge_summaries(self, summaries: Iterable[DocSummary]) -> DocSummary:
         """Agrega multiples DocSummary en uno.
 

{sourcecode-1.2.0 → sourcecode-1.3.0}/src/sourcecode/entrypoint_classifier.py

@@ -67,6 +67,9 @@ def runtime_relevance(ep: EntryPoint, classification: Classification | None = No
     classification = classification or classify_entry_point(ep)
     if classification != "production":
         return "low"
+    # Annotation-detected HTTP controllers are the primary runtime surface
+    if ep.source == "annotation" and ep.kind in {"rest_controller", "mvc_controller"}:
+        return "high"
     reason = (ep.reason or "").lower()
     if ep.source == "package.json#bin" or reason == "bin" or reason in _PRODUCTION_SCRIPT_REASONS:
         return "high"

{sourcecode-1.2.0 → sourcecode-1.3.0}/src/sourcecode/graph_analyzer.py

@@ -76,7 +76,7 @@ class GraphAnalyzer:
     def __init__(
         self,
         *,
-        max_files: int = 200,
+        max_files: int = 2000,
         max_file_size: int = 200_000,
         max_nodes: int = 1_000,
         max_edges: int = 2_000,

{sourcecode-1.2.0 → sourcecode-1.3.0}/src/sourcecode/metrics_analyzer.py

@@ -137,7 +137,7 @@ def _mccabe(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> int:
 class MetricsAnalyzer:
     """Analiza metricas de calidad de codigo: LOC, simbolos y complejidad ciclomatica."""
 
-    _MAX_FILES = 500
+    _MAX_FILES = 2000
     _MAX_FILE_SIZE = 500_000  # bytes
 
     # ---------------------------------------------------------------------------
@@ -159,6 +159,21 @@ class MetricsAnalyzer:
         # Keep only paths that are actual files (not directories)
         file_paths = [p for p in all_paths if (root / p).is_file()]
 
+        # Sort: JVM source first, then other source, then config, then dotfiles
+        # Prevents the 500-file cap from cutting all Java files when dotfiles sort first.
+        def _sort_key(p: str) -> tuple[int, str]:
+            if Path(p).suffix.lower() in {".java", ".kt", ".scala"}:
+                return (0, p)
+            if Path(p).suffix.lower() in {".py", ".go", ".rs", ".ts", ".js", ".tsx", ".jsx"}:
+                return (1, p)
+            if Path(p).suffix.lower() in {".xml", ".yaml", ".yml", ".json", ".toml", ".properties"}:
+                return (2, p)
+            if Path(p).name.startswith("."):
+                return (4, p)
+            return (3, p)
+
+        file_paths.sort(key=_sort_key)
+
         limitations: list[str] = []
 
         # Guard: max files

{sourcecode-1.2.0 → sourcecode-1.3.0}/src/sourcecode/prepare_context.py

@@ -760,6 +760,33 @@ class TaskContextBuilder:
             elif self._is_source(path) and not content_reasons:
                 content_boost += 0.5
 
+            # Task-specific boosts for differentiated file weighting
+            path_lower = path.lower()
+            if task_name == "fix-bug":
+                if any(x in path_lower for x in ("exception", "error", "handler", "advice")):
+                    content_boost += 1.5
+                    content_reasons.append("exception handler — high risk area")
+            elif task_name == "generate-tests":
+                stem = Path(path).stem.lower()
+                has_test = any(
+                    stem in Path(tp).stem.lower() or Path(tp).stem.lower() in stem
+                    for tp in test_set
+                )
+                if not has_test and self._is_source(path):
+                    content_boost += 1.0
+                    content_reasons.append("no test pair found")
+            elif task_name == "onboard":
+                if path in runtime_entry_set:
+                    content_boost += 2.0
+                    content_reasons.append("runtime entry point")
+                if any(x in path_lower for x in ("config", "application.yml", "application.properties", "settings", "bootstrap")):
+                    content_boost += 1.0
+                    content_reasons.append("configuration class")
+            elif task_name == "explain":
+                if "controller" in path_lower and path in runtime_entry_set:
+                    content_boost += 1.5
+                    content_reasons.append("DDD module controller")
+
             total = fs.score + content_boost
             if total <= 0:
                 continue

{sourcecode-1.2.0 → sourcecode-1.3.0}/src/sourcecode/serializer.py

@@ -35,7 +35,7 @@ _FILE_RELEVANCE_MIN_COMBINED = 0.40  # minimum combined score — must earn incl
 _PROD_DEPS_CAP = 10          # max production dependencies shown
 _SECONDARY_DEPS_CAP = 5      # max per dev/test/build dependency group
 _MONOREPO_PKGS_CAP = 8       # max workspace/runtime packages shown
-_KEY_DEPS_CAP = 10           # max key dependencies shown
+_KEY_DEPS_CAP = 50           # max key dependencies shown
 _CODE_NOTES_CAP = 15         # max code notes in default output
 _ENV_MAP_CAP = 15            # max env var entries in default output
 
@@ -223,6 +223,11 @@ def _file_relevance(sm: SourceMap, *, limit: int = _FILE_RELEVANCE_LIMIT) -> lis
                 semantic_hub_scores[p] = h.get("importance_score", 0.0) / max_importance
 
     entry_paths = {ep.path for ep in sm.entry_points}
+    # REST/MVC controllers are HTTP surface — surface before @Transactional services
+    _rest_ctrl_paths = {
+        ep.path for ep in sm.entry_points
+        if getattr(ep, "kind", "") in {"rest_controller", "mvc_controller"}
+    }
     scored: list[tuple[float, dict[str, Any]]] = []
 
     for path in sm.file_paths:
@@ -241,6 +246,9 @@ def _file_relevance(sm: SourceMap, *, limit: int = _FILE_RELEVANCE_LIMIT) -> lis
         # Semantic hub bonus: normalised call-graph centrality adds up to +0.30
         sem_hub = semantic_hub_scores.get(path, 0.0) * 0.30
         combined = fs.score + content_rel + sem_hub
+        # REST controller boost: surface above @Transactional service files
+        if path in _rest_ctrl_paths:
+            combined += 2.0
 
         # Visibility threshold: require meaningful combined signal.
         # Exception: high/medium-confidence files with strong content relevance
@@ -1586,8 +1594,8 @@ def write_output(content: str, output: Optional[Path]) -> None:
         output: Destination file path. None = stdout.
     """
     if output is None:
-        sys.stdout.write(content)
+        sys.stdout.buffer.write(content.encode("utf-8"))
         if not content.endswith("\n"):
-            sys.stdout.write("\n")
+            sys.stdout.buffer.write(b"\n")
     else:
         output.write_text(content, encoding="utf-8")