sourcecode 1.35.25__py3-none-any.whl → 1.35.27__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/cli.py

@@ -242,6 +242,10 @@ _SUBCOMMANDS: frozenset[str] = frozenset(
         "explain",
         # Spring Boot 2→3 migration readiness
         "migrate-check",
+        # Native file rename (BLOCKER-A)
+        "rename-class",
+        # Large file semantic chunking (BLOCKER-B)
+        "chunk-file",
     }
 )
 
@@ -5009,6 +5013,240 @@ def modernize_cmd(
         _copy_to_clipboard(output)
 
 
+# ── rename-class ──────────────────────────────────────────────────────────────
+
+@app.command("rename-class")
+def rename_class_cmd(
+    path: Path = typer.Argument(
+        Path("."),
+        help="Repository root to operate on (default: current directory)",
+    ),
+    old_name: str = typer.Option(
+        ..., "--from", "-f",
+        help="Current class name (PascalCase, e.g. ServiceA)",
+    ),
+    new_name: str = typer.Option(
+        ..., "--to", "-t",
+        help="New class name (PascalCase, e.g. ServiceB)",
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run",
+        help="Compute changes but do not write any files or rename on disk.",
+    ),
+    no_tests: bool = typer.Option(
+        False, "--no-tests",
+        help="Exclude test files from the rename (src/main only).",
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None, "--output", "-o",
+        help="Write change audit JSON to a file instead of stdout.",
+    ),
+    copy: bool = typer.Option(
+        False, "--copy", "-c",
+        help="Copy output to clipboard after a successful run.",
+    ),
+    format: str = typer.Option(
+        "json", "--format",
+        help="Output format: json (default) or yaml.",
+    ),
+) -> None:
+    """Rename a Java class throughout the repository (BLOCKER-A fix).
+
+    \b
+    Renames a Java class safely:
+      - Updates class/interface/enum declaration
+      - Updates constructor name
+      - Updates all import statements
+      - Updates all type references (fields, params, return types)
+      - Updates extends / implements
+      - Updates generics, casts, Spring @Qualifier names
+      - Renames the physical .java file
+      - Emits a structured change audit trail (BLOCKER-C)
+
+    \b
+    Examples:
+      sourcecode rename-class . --from ServiceA --to ServiceB
+      sourcecode rename-class /path/to/repo --from OrderManager --to OrderService
+      sourcecode rename-class . --from OldName --to NewName --dry-run
+      sourcecode rename-class . --from OldName --to NewName --output rename-audit.json
+    """
+    import json as _json
+    from sourcecode.rename_refactor import rename_class
+
+    root = path.resolve()
+    if not root.is_dir():
+        _emit_error_json(
+            INVALID_INPUT_CODE,
+            f"'{root}' is not a valid directory.",
+            path=str(root),
+            hint="Pass an existing repository directory.",
+            expected="A directory path.",
+        )
+        raise typer.Exit(1)
+
+    result = rename_class(
+        root,
+        old_name,
+        new_name,
+        dry_run=dry_run,
+        include_tests=not no_tests,
+    )
+
+    if result.errors:
+        _emit_error_json(
+            "RENAME_ERROR",
+            result.errors[0],
+            errors=result.errors,
+            old_name=old_name,
+            new_name=new_name,
+        )
+        raise typer.Exit(1)
+
+    result_dict = result.to_dict()
+
+    if format == "yaml":
+        from sourcecode.serializer import to_yaml as _to_yaml
+        output = _to_yaml(result_dict)
+    else:
+        output = _json.dumps(result_dict, indent=2, ensure_ascii=False)
+
+    if output_path:
+        output_path.write_text(output, encoding="utf-8")
+        action = "dry-run simulated" if dry_run else "applied"
+        typer.echo(
+            f"[rename-class] {action}: {old_name} → {new_name} "
+            f"({result.files_modified} file(s) changed). "
+            f"Audit written to {output_path}",
+            err=True,
+        )
+    else:
+        try:
+            sys.stdout.buffer.write(output.encode("utf-8"))
+            sys.stdout.buffer.write(b"\n")
+            sys.stdout.buffer.flush()
+        except AttributeError:
+            sys.stdout.write(output + "\n")
+
+    if copy:
+        _copy_to_clipboard(output)
+
+    if not dry_run and not output_path:
+        action = "Renamed"
+        typer.echo(
+            f"[rename-class] {action}: {old_name} → {new_name} "
+            f"({result.files_modified} file(s) updated, file renamed to {result.new_file})",
+            err=True,
+        )
+
+
+# ── chunk-file ────────────────────────────────────────────────────────────────
+
+@app.command("chunk-file")
+def chunk_file_cmd(
+    file: Path = typer.Argument(
+        ...,
+        help="Java file to chunk (absolute or relative path)",
+    ),
+    max_lines: int = typer.Option(
+        500, "--max-lines", "-n",
+        help="Target max lines per chunk (default: 500). Methods > max_lines emit size_warning.",
+    ),
+    chunk_id: Optional[int] = typer.Option(
+        None, "--chunk", "-c",
+        help="Return only this chunk by ID (1-based). Omit to return all chunks.",
+    ),
+    metadata_only: bool = typer.Option(
+        False, "--metadata-only",
+        help="Return chunk boundaries and metadata without file content.",
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None, "--output", "-o",
+        help="Write output to a file instead of stdout.",
+    ),
+    format: str = typer.Option(
+        "json", "--format",
+        help="Output format: json (default) or yaml.",
+    ),
+    copy: bool = typer.Option(
+        False, "--copy",
+        help="Copy output to clipboard after a successful run.",
+    ),
+) -> None:
+    """Split a large Java file into semantic chunks for AI agent consumption (BLOCKER-B fix).
+
+    \b
+    Splits a Java file at method/class boundaries so AI agents can read
+    large files (10K–25K+ lines) in context-sized pieces without timeout
+    or fragmented analysis.
+
+    Each chunk includes:
+      - chunk_id, start_line, end_line, chunk_type, symbol name
+      - context_header: package + class + imports summary
+      - content: source lines for that chunk
+      - size_warning: True if chunk > max_lines (cannot split mid-method)
+
+    \b
+    Examples:
+      sourcecode chunk-file NominasCalculoService.java
+      sourcecode chunk-file BigService.java --max-lines 300
+      sourcecode chunk-file BigService.java --chunk 5        # read chunk 5 only
+      sourcecode chunk-file BigService.java --metadata-only  # sizes/boundaries only
+    """
+    import json as _json
+    from sourcecode.file_chunker import chunk_java_file
+
+    abs_file = file.resolve()
+    if not abs_file.is_file():
+        _emit_error_json(
+            INVALID_INPUT_CODE,
+            f"'{abs_file}' is not a valid file.",
+            path=str(abs_file),
+            hint="Pass an existing Java source file.",
+            expected="A .java file path.",
+        )
+        raise typer.Exit(1)
+
+    result = chunk_java_file(abs_file, max_lines=max_lines, include_content=not metadata_only)
+
+    if chunk_id is not None:
+        # Return single chunk
+        matching = [c for c in result.chunks if c.chunk_id == chunk_id]
+        if not matching:
+            _emit_error_json(
+                INVALID_INPUT_CODE,
+                f"Chunk {chunk_id} not found. File has {result.total_chunks} chunks.",
+                chunk_id=chunk_id,
+                total_chunks=result.total_chunks,
+            )
+            raise typer.Exit(1)
+        result_dict = matching[0].to_dict()
+    else:
+        result_dict = result.to_dict()
+
+    if format == "yaml":
+        from sourcecode.serializer import to_yaml as _to_yaml
+        output = _to_yaml(result_dict)
+    else:
+        output = _json.dumps(result_dict, indent=2, ensure_ascii=False)
+
+    if output_path:
+        output_path.write_text(output, encoding="utf-8")
+        typer.echo(
+            f"[chunk-file] {result.total_chunks} chunks written to {output_path}",
+            err=True,
+        )
+    else:
+        try:
+            sys.stdout.buffer.write(output.encode("utf-8"))
+            sys.stdout.buffer.write(b"\n")
+            sys.stdout.buffer.flush()
+        except AttributeError:
+            sys.stdout.write(output + "\n")
+
+    if copy:
+        _copy_to_clipboard(output)
+
+
 # ── version ───────────────────────────────────────────────────────────────────
 
 @app.command("activate")

sourcecode/file_chunker.py

@@ -0,0 +1,397 @@
+"""file_chunker.py — Semantic chunking of large Java files for AI agent consumption.
+
+Splits a Java source file into context-aware chunks at method/class boundaries.
+Each chunk includes a context header so an AI agent can understand it without
+reading prior chunks. Handles files of any size without timeout.
+
+Usage:
+    chunks = chunk_java_file(path, max_lines=500)
+    # Each chunk: ChunkRecord with id, type, symbol, start_line, end_line, content
+
+Design:
+  - Primary split at method/constructor boundaries (brace depth == class depth + 1)
+  - Secondary: class-level fields grouped together in a preamble chunk
+  - Context header: package + class name + imports summary prepended to each chunk
+  - Chunks never split mid-method: a method > max_lines is emitted as a single chunk
+    with a size warning in metadata
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Data classes
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ChunkRecord:
+    """A semantic chunk of a Java source file."""
+    chunk_id: int               # 1-based sequential index
+    chunk_type: str             # "class_header" | "method" | "constructor" | "field_block" | "class_footer"
+    symbol: str                 # e.g. "MyService#processOrder" or "MyService" for class_header
+    start_line: int             # 1-based inclusive
+    end_line: int               # 1-based inclusive
+    content: str                # source lines for this chunk
+    context_header: str         # package + class context prepended for AI consumption
+    size_warning: bool = False  # True if chunk exceeds max_lines (cannot split further)
+
+    @property
+    def total_lines(self) -> int:
+        return self.end_line - self.start_line + 1
+
+    def to_dict(self) -> dict:
+        return {
+            "chunk_id": self.chunk_id,
+            "chunk_type": self.chunk_type,
+            "symbol": self.symbol,
+            "start_line": self.start_line,
+            "end_line": self.end_line,
+            "total_lines": self.total_lines,
+            "context_header": self.context_header,
+            "content": self.content,
+            "size_warning": self.size_warning,
+        }
+
+
+@dataclass
+class ChunkResult:
+    """Result of chunking a Java file."""
+    file: str                   # relative or absolute path
+    total_lines: int
+    total_chunks: int
+    class_name: str
+    package: str
+    chunk_count_by_type: dict[str, int] = field(default_factory=dict)
+    chunks: list[ChunkRecord] = field(default_factory=list)
+    limitations: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "file": self.file,
+            "total_lines": self.total_lines,
+            "total_chunks": self.total_chunks,
+            "class_name": self.class_name,
+            "package": self.package,
+            "chunk_count_by_type": self.chunk_count_by_type,
+            "limitations": self.limitations,
+            "chunks": [c.to_dict() for c in self.chunks],
+        }
+
+
+# ---------------------------------------------------------------------------
+# Regexes
+# ---------------------------------------------------------------------------
+
+_PKG_RE = re.compile(r'^\s*package\s+([\w.]+)\s*;')
+_IMPORT_RE = re.compile(r'^\s*import\s+(?:static\s+)?([\w.*]+)\s*;')
+_CLASS_RE = re.compile(
+    r'^\s*(?:(?:public|protected|private|abstract|final|sealed|non-sealed)\s+)*'
+    r'(?:class|interface|enum|@interface)\s+(\w+)'
+)
+_METHOD_RE = re.compile(
+    r'^\s*(?:(?:public|protected|private|static|final|synchronized|abstract|native|default|override)\s+)*'
+    r'(?:<[^>]+>\s+)?'                  # optional generic return type
+    r'(?:[\w<>\[\],?\s]+\s+)?'         # return type (optional for constructors)
+    r'(\w+)\s*\('                        # method/constructor name + opening paren
+)
+_FIELD_RE = re.compile(
+    r'^\s*(?:(?:public|protected|private|static|final|volatile|transient)\s+)+'
+    r'[\w<>\[\].,? ]+\s+\w+\s*(?:=|;)'
+)
+_ANN_RE = re.compile(r'^\s*@')
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _count_braces(line: str) -> tuple[int, int]:
+    """Return (open_count, close_count) for non-string/comment braces in line."""
+    open_c = 0
+    close_c = 0
+    in_str = False
+    in_char = False
+    escape = False
+    i = 0
+    while i < len(line):
+        ch = line[i]
+        if escape:
+            escape = False
+        elif ch == '\\':
+            escape = True
+        elif ch == '"' and not in_char:
+            in_str = not in_str
+        elif ch == "'" and not in_str:
+            in_char = not in_char
+        elif not in_str and not in_char:
+            if ch == '{':
+                open_c += 1
+            elif ch == '}':
+                close_c += 1
+            elif ch == '/' and i + 1 < len(line) and line[i+1] == '/':
+                break  # rest is line comment
+        i += 1
+    return open_c, close_c
+
+
+def _build_context_header(
+    package: str,
+    class_name: str,
+    import_lines: list[str],
+    max_imports: int = 10,
+) -> str:
+    """Build a context header showing package + class + condensed imports."""
+    lines = []
+    if package:
+        lines.append(f"// File context: package {package};")
+    lines.append(f"// Enclosing class: {class_name}")
+    if import_lines:
+        shown = import_lines[:max_imports]
+        lines.extend(shown)
+        if len(import_lines) > max_imports:
+            lines.append(f"// ... ({len(import_lines) - max_imports} more imports omitted)")
+    lines.append("")  # blank separator
+    return "\n".join(lines)
+
+
+def _is_method_or_constructor_start(
+    stripped: str,
+    class_name: str,
+    depth: int,
+    class_depth: int,
+) -> tuple[bool, str, str]:
+    """Return (is_method, method_name, chunk_type) if line starts a method/constructor."""
+    if depth != class_depth + 1:
+        return False, "", ""
+
+    # Skip annotations
+    if stripped.startswith("@"):
+        return False, "", ""
+    # Skip field declarations (end with ; or = before ;)
+    if _FIELD_RE.match(stripped) and "{" not in stripped:
+        return False, "", ""
+    # Skip class/interface/enum declarations
+    if _CLASS_RE.match(stripped):
+        return False, "", ""
+
+    m = _METHOD_RE.match(stripped)
+    if not m:
+        return False, "", ""
+    name = m.group(1)
+    # Distinguish constructor: name matches class name
+    chunk_type = "constructor" if name == class_name else "method"
+    return True, name, chunk_type
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def chunk_java_file(
+    path: Path,
+    *,
+    max_lines: int = 500,
+    include_content: bool = True,
+) -> ChunkResult:
+    """Split a Java file into semantic chunks at method/class boundaries.
+
+    Args:
+        path:            Path to the Java file.
+        max_lines:       Target max lines per chunk. Methods exceeding this
+                         are emitted as a single chunk with size_warning=True.
+        include_content: If False, content field is omitted (metadata-only mode).
+
+    Returns:
+        ChunkResult with ordered list of ChunkRecord entries.
+    """
+    try:
+        source = path.read_text(encoding="utf-8", errors="replace")
+    except OSError as e:
+        return ChunkResult(
+            file=str(path),
+            total_lines=0,
+            total_chunks=0,
+            class_name="",
+            package="",
+            limitations=[f"Could not read file: {e}"],
+        )
+
+    all_lines = source.splitlines()
+    total_lines = len(all_lines)
+
+    # ── Pass 1: extract package, class name, imports ──────────────────────
+    package = ""
+    class_name = ""
+    import_lines: list[str] = []
+    for raw_line in all_lines:
+        stripped = raw_line.strip()
+        if not package:
+            pm = _PKG_RE.match(raw_line)
+            if pm:
+                package = pm.group(1)
+        im = _IMPORT_RE.match(raw_line)
+        if im:
+            import_lines.append(raw_line.rstrip())
+        if not class_name:
+            cm = _CLASS_RE.match(raw_line)
+            if cm:
+                class_name = cm.group(1)
+
+    context_header = _build_context_header(package, class_name, import_lines)
+
+    # ── Pass 2: track brace depth, identify method/class boundaries ───────
+    depth = 0
+    class_depth = -1   # depth at which the primary class body starts
+    chunks: list[ChunkRecord] = []
+    chunk_id = 0
+    limitations: list[str] = []
+
+    # "pending" block: lines accumulated for current chunk
+    pending_start: int = 1
+    pending_lines: list[str] = []
+    pending_type: str = "class_header"
+    pending_symbol: str = class_name or "unknown"
+
+    # Annotation buffer for upcoming method/constructor
+    ann_buffer: list[tuple[int, str]] = []  # (line_no 1-based, raw_line)
+
+    def _flush_chunk(end_line: int) -> None:
+        nonlocal chunk_id, pending_start, pending_lines, pending_type, pending_symbol
+        if not pending_lines:
+            return
+        chunk_id += 1
+        content = "\n".join(pending_lines) if include_content else ""
+        size_warn = len(pending_lines) > max_lines
+        if size_warn:
+            limitations.append(
+                f"Chunk {chunk_id} ({pending_symbol}) has {len(pending_lines)} lines "
+                f"(exceeds max_lines={max_lines}) — cannot split mid-method."
+            )
+        chunks.append(ChunkRecord(
+            chunk_id=chunk_id,
+            chunk_type=pending_type,
+            symbol=pending_symbol,
+            start_line=pending_start,
+            end_line=end_line,
+            content=content,
+            context_header=context_header,
+            size_warning=size_warn,
+        ))
+        pending_lines = []
+        pending_start = end_line + 1
+
+    in_block_comment = False
+    current_method_name = ""
+    current_method_type = ""
+    method_brace_start_depth = -1
+
+    for line_no_0, raw_line in enumerate(all_lines):
+        line_no = line_no_0 + 1  # 1-based
+        stripped = raw_line.strip()
+
+        # Block comment tracking
+        if in_block_comment:
+            pending_lines.append(raw_line)
+            if "*/" in stripped:
+                in_block_comment = False
+            continue
+        if "/*" in stripped and "*/" not in stripped:
+            in_block_comment = True
+            pending_lines.append(raw_line)
+            continue
+
+        # Track brace depth
+        opens, closes = _count_braces(raw_line)
+
+        # Detect class body start (first '{' after class declaration)
+        if class_depth < 0 and class_name and _CLASS_RE.match(raw_line):
+            class_depth = depth  # depth BEFORE the '{' on this line
+            if opens > 0:
+                class_depth = depth  # class body starts after this line
+
+        # Check if this line starts a method/constructor AT class_depth+1
+        if class_depth >= 0 and depth == class_depth + 1 and not current_method_name:
+            is_method, mname, mtype = _is_method_or_constructor_start(
+                stripped, class_name, depth, class_depth
+            )
+            if is_method and "{" in raw_line:
+                # Flush anything accumulated as field_block / class_header
+                # Include annotation lines in the new method chunk
+                if pending_lines:
+                    # Check if last N pending lines are annotations for this method
+                    # Flush everything up to ann_buffer start
+                    if ann_buffer:
+                        ann_start_line = ann_buffer[0][0]
+                        pre_ann_lines = pending_lines[:ann_start_line - pending_start]
+                        if pre_ann_lines:
+                            _flush_chunk(ann_start_line - 1)
+                        # Move ann_buffer lines into the new method chunk
+                        pending_start = ann_start_line
+                        pending_lines = [al for _, al in ann_buffer]
+                        ann_buffer = []
+                    else:
+                        _flush_chunk(line_no - 1)
+                        pending_start = line_no
+                        pending_lines = []
+
+                current_method_name = mname
+                current_method_type = mtype
+                method_brace_start_depth = depth + opens - 1  # depth entering method body
+                pending_type = mtype
+                pending_symbol = f"{class_name}#{mname}" if class_name else mname
+                pending_lines.append(raw_line)
+                depth += opens - closes
+                ann_buffer = []
+                continue
+
+        # Update depth
+        depth += opens - closes
+
+        # After depth update: check if current method closed
+        if current_method_name and depth <= class_depth + 1:
+            # Method body closed
+            pending_lines.append(raw_line)
+            _flush_chunk(line_no)
+            current_method_name = ""
+            current_method_type = ""
+            # Next chunk is field_block until next method
+            pending_type = "field_block"
+            pending_symbol = class_name or "unknown"
+            pending_start = line_no + 1
+            ann_buffer = []
+            continue
+
+        # Track annotations at class level (buffered to attach to next method)
+        if (class_depth >= 0 and depth == class_depth + 1
+                and not current_method_name and stripped.startswith("@")):
+            ann_buffer.append((line_no, raw_line))
+        elif not stripped.startswith("@"):
+            # Non-annotation line: clear annotation buffer if we're not entering a method
+            if ann_buffer and not (class_depth >= 0 and depth == class_depth + 1):
+                ann_buffer = []
+
+        pending_lines.append(raw_line)
+
+    # Flush remaining lines as class_footer
+    if pending_lines:
+        pending_type = "class_footer" if depth <= (class_depth if class_depth >= 0 else 0) else pending_type
+        _flush_chunk(total_lines)
+
+    chunk_count_by_type: dict[str, int] = {}
+    for c in chunks:
+        chunk_count_by_type[c.chunk_type] = chunk_count_by_type.get(c.chunk_type, 0) + 1
+
+    return ChunkResult(
+        file=str(path),
+        total_lines=total_lines,
+        total_chunks=len(chunks),
+        class_name=class_name,
+        package=package,
+        chunk_count_by_type=chunk_count_by_type,
+        chunks=chunks,
+        limitations=limitations,
+    )

sourcecode/migrate_check.py

@@ -868,9 +868,34 @@ def _find_build_files(root: Path) -> list[tuple[Path, str]]:
     return results
 
 
+def _resolve_maven_properties(text: str) -> str:
+    """Substitute ${prop} references with values from the <properties> block.
+
+    Handles single-level property references that appear in the same pom.xml.
+    Multi-level references (${a} where a=${b}) are resolved up to 3 passes.
+    """
+    props: dict[str, str] = {}
+    for m in re.finditer(r'<([A-Za-z][\w.\-]*)>\s*([^<${}]+?)\s*</\1>', text):
+        props[m.group(1)] = m.group(2).strip()
+    if not props:
+        return text
+
+    resolved = text
+    for _ in range(3):
+        def _sub(m: re.Match) -> str:  # noqa: E306
+            return props.get(m.group(1), m.group(0))
+        resolved_new = re.sub(r'\$\{([\w.\-]+)\}', _sub, resolved)
+        if resolved_new == resolved:
+            break
+        resolved = resolved_new
+    return resolved
+
+
 def _scan_dep_file(text: str, rel_path: str) -> list["MigrationFinding"]:
     """Apply dependency rules to a build file. Returns one finding per matched rule."""
     is_gradle = rel_path.endswith((".gradle", ".gradle.kts"))
+    if not is_gradle and rel_path.endswith(".xml"):
+        text = _resolve_maven_properties(text)
     findings: list[MigrationFinding] = []
     for rule in _DEP_RULES:
         if rule.quick_filter is not None and rule.quick_filter not in text:
@@ -1198,6 +1223,7 @@ def run_migrate_check(
         limitations.append(f"{xml_read_errors} XML file(s) could not be read and were skipped.")
 
     dep_read_errors = 0
+    raw_dep_findings: list[MigrationFinding] = []
     for abs_path, rel_path in build_files:
         try:
             text = abs_path.read_text(encoding="utf-8", errors="replace")
@@ -1206,7 +1232,20 @@ def run_migrate_check(
             continue
         dep_findings = _scan_dep_file(text, rel_path)
         filtered = [f for f in dep_findings if SEVERITY_ORDER.get(f.severity, 3) <= min_order]
-        all_findings.extend(filtered)
+        raw_dep_findings.extend(filtered)
+
+    # Deduplicate dep findings by rule_id: same dependency in parent + child poms
+    # is one logical finding. Keep the first occurrence (root pom sorts first).
+    _seen_dep_rules: dict[str, int] = {}  # rule_id → count
+    for f in raw_dep_findings:
+        _seen_dep_rules[f.rule_id] = _seen_dep_rules.get(f.rule_id, 0) + 1
+    _dedup_dep: list[MigrationFinding] = []
+    _emitted: set[str] = set()
+    for f in raw_dep_findings:
+        if f.rule_id not in _emitted:
+            _dedup_dep.append(f)
+            _emitted.add(f.rule_id)
+    all_findings.extend(_dedup_dep)
 
     if dep_read_errors:
         limitations.append(f"{dep_read_errors} build file(s) could not be read and were skipped.")

sourcecode/rename_refactor.py

@@ -0,0 +1,299 @@
+"""rename_refactor.py — Safe Java class rename with full reference update.
+
+Performs a deterministic rename of a Java class/interface/enum:
+  1. Locates the source file (OldName.java or by scanning class declarations)
+  2. Updates class declaration, constructor name, all imports, all references
+  3. Renames the physical file on disk
+  4. Returns a structured ChangeAudit report (BLOCKER-C)
+
+Covers:
+  - Class/interface/enum declaration
+  - Constructor declarations
+  - Import statements
+  - Field type declarations
+  - Method parameter and return types
+  - Variable declarations and instantiations
+  - extends / implements
+  - Generic type parameters
+  - Spring @Qualifier and @Bean names (camelCase)
+  - Test files (optional via include_tests)
+
+Does NOT require compilation. Works on any Java source tree via
+regex-based text transformations with word-boundary guards.
+"""
+from __future__ import annotations
+
+import difflib
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Data classes (BLOCKER-C: structured change audit trail)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class FileChange:
+    """A mutation applied to a single file."""
+    file: str               # relative path from repo root
+    intent: str             # human-readable description of what changed
+    diff: str               # unified diff (--- before / +++ after)
+    before_lines: list[str] = field(default_factory=list)
+    after_lines: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "file": self.file,
+            "intent": self.intent,
+            "diff": self.diff,
+            "before_lines": self.before_lines,
+            "after_lines": self.after_lines,
+        }
+
+
+@dataclass
+class RenameResult:
+    """Full result of a rename-class operation."""
+    old_name: str
+    new_name: str
+    old_file: str           # relative path before rename (empty if not found)
+    new_file: str           # relative path after rename (empty if not found)
+    changes: list[FileChange] = field(default_factory=list)
+    files_scanned: int = 0
+    files_modified: int = 0
+    dry_run: bool = False
+    errors: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "old_name": self.old_name,
+            "new_name": self.new_name,
+            "old_file": self.old_file,
+            "new_file": self.new_file,
+            "files_scanned": self.files_scanned,
+            "files_modified": self.files_modified,
+            "dry_run": self.dry_run,
+            "errors": self.errors,
+            "changes": [c.to_dict() for c in self.changes],
+        }
+
+
+# ---------------------------------------------------------------------------
+# Core rename logic
+# ---------------------------------------------------------------------------
+
+_VENDOR_DIRS = frozenset({
+    "vendor", "node_modules", "dist", "target", "build",
+    ".gradle", ".mvn", "generated", "generated-sources",
+})
+
+
+def _to_camel(name: str) -> str:
+    """PascalCase → camelCase: ServiceA → serviceA."""
+    if not name or len(name) < 2:
+        return name.lower() if name else name
+    return name[0].lower() + name[1:]
+
+
+def _collect_java_files(root: Path, *, include_tests: bool = True) -> list[Path]:
+    """All .java files under root, excluding vendor/build dirs."""
+    results: list[Path] = []
+    for p in sorted(root.rglob("*.java")):
+        rel = str(p.relative_to(root)).replace("\\", "/")
+        parts = rel.split("/")
+        if any(part in _VENDOR_DIRS for part in parts[:-1]):
+            continue
+        if not include_tests:
+            if "/test/" in rel or "/tests/" in rel or rel.startswith("test/"):
+                continue
+        results.append(p)
+    return results
+
+
+def _find_class_file(
+    java_files: list[Path],
+    class_name: str,
+    root: Path,
+) -> Optional[Path]:
+    """Find the file that declares `class_name` (by filename first, then scan)."""
+    # Prefer exact filename match
+    candidates = [f for f in java_files if f.stem == class_name]
+    if len(candidates) == 1:
+        return candidates[0]
+    if len(candidates) > 1:
+        # Multiple files with same stem — pick the one that has the class declaration
+        decl_re = re.compile(
+            r'\b(?:public\s+)?(?:abstract\s+)?(?:class|interface|enum)\s+' + re.escape(class_name) + r'\b'
+        )
+        for c in candidates:
+            try:
+                if decl_re.search(c.read_text(encoding="utf-8", errors="replace")):
+                    return c
+            except OSError:
+                continue
+        return candidates[0]
+
+    # Fallback: scan file contents for class declaration
+    decl_re = re.compile(
+        r'\b(?:public\s+)?(?:abstract\s+)?(?:class|interface|enum)\s+' + re.escape(class_name) + r'\b'
+    )
+    for f in java_files:
+        try:
+            if decl_re.search(f.read_text(encoding="utf-8", errors="replace")):
+                return f
+        except OSError:
+            continue
+    return None
+
+
+def _apply_rename(source: str, old_name: str, new_name: str) -> str:
+    """Apply word-boundary replacement for class name (PascalCase and camelCase forms)."""
+    # PascalCase replacement: all type references, declarations, imports
+    result = re.sub(r'\b' + re.escape(old_name) + r'\b', new_name, source)
+
+    # camelCase instance names: serviceA → serviceB (only when different from PascalCase)
+    old_camel = _to_camel(old_name)
+    new_camel = _to_camel(new_name)
+    if old_camel != old_name and old_camel in result:
+        result = re.sub(r'\b' + re.escape(old_camel) + r'\b', new_camel, result)
+
+    return result
+
+
+def _make_diff(old_text: str, new_text: str, rel_path: str) -> str:
+    """Produce a unified diff string."""
+    old_lines = old_text.splitlines(keepends=True)
+    new_lines = new_text.splitlines(keepends=True)
+    diff_lines = list(difflib.unified_diff(
+        old_lines,
+        new_lines,
+        fromfile=f"a/{rel_path}",
+        tofile=f"b/{rel_path}",
+        lineterm="",
+    ))
+    return "".join(diff_lines)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def rename_class(
+    root: Path,
+    old_name: str,
+    new_name: str,
+    *,
+    dry_run: bool = False,
+    include_tests: bool = True,
+) -> RenameResult:
+    """Rename a Java class throughout the repository.
+
+    Args:
+        root:          Absolute repo root directory.
+        old_name:      Simple class name to rename (e.g. "ServiceA").
+        new_name:      Target simple class name (e.g. "ServiceB").
+        dry_run:       If True, compute changes but do not write any files.
+        include_tests: If True (default), also rename in test files.
+
+    Returns:
+        RenameResult with structured change audit trail (BLOCKER-C format).
+    """
+    root = root.resolve()
+
+    result = RenameResult(
+        old_name=old_name,
+        new_name=new_name,
+        old_file="",
+        new_file="",
+        dry_run=dry_run,
+    )
+
+    # Validate input
+    if not old_name or not old_name[0].isupper():
+        result.errors.append(
+            f"old_name '{old_name}' must be a Java class name (PascalCase, non-empty)."
+        )
+        return result
+    if not new_name or not new_name[0].isupper():
+        result.errors.append(
+            f"new_name '{new_name}' must be a Java class name (PascalCase, non-empty)."
+        )
+        return result
+    if old_name == new_name:
+        result.errors.append("old_name and new_name are identical — nothing to rename.")
+        return result
+    if not root.is_dir():
+        result.errors.append(f"Root directory '{root}' does not exist.")
+        return result
+
+    # Collect files
+    java_files = _collect_java_files(root, include_tests=include_tests)
+    result.files_scanned = len(java_files)
+
+    # Locate the source file
+    source_file = _find_class_file(java_files, old_name, root)
+    if source_file is None:
+        result.errors.append(
+            f"Could not find a file declaring class '{old_name}' under '{root}'."
+        )
+        return result
+
+    # Determine new file path (same directory, new filename)
+    new_file_path = source_file.with_name(new_name + ".java")
+    result.old_file = str(source_file.relative_to(root)).replace("\\", "/")
+    result.new_file = str(new_file_path.relative_to(root)).replace("\\", "/")
+
+    if new_file_path.exists() and new_file_path != source_file:
+        result.errors.append(
+            f"Target file '{result.new_file}' already exists — aborting to avoid overwrite."
+        )
+        return result
+
+    # Apply text replacements to all Java files
+    changes: list[FileChange] = []
+    for java_file in java_files:
+        try:
+            old_text = java_file.read_text(encoding="utf-8", errors="replace")
+        except OSError as e:
+            result.errors.append(f"Could not read '{java_file}': {e}")
+            continue
+
+        new_text = _apply_rename(old_text, old_name, new_name)
+        if new_text == old_text:
+            continue
+
+        rel_path = str(java_file.relative_to(root)).replace("\\", "/")
+        diff = _make_diff(old_text, new_text, rel_path)
+
+        # Determine intent
+        is_source = java_file == source_file
+        if is_source:
+            intent = f"Renamed class declaration: {old_name} → {new_name}"
+        else:
+            intent = f"Updated references to {old_name} → {new_name}"
+
+        changes.append(FileChange(
+            file=rel_path,
+            intent=intent,
+            diff=diff,
+            before_lines=old_text.splitlines(),
+            after_lines=new_text.splitlines(),
+        ))
+
+        if not dry_run:
+            java_file.write_text(new_text, encoding="utf-8")
+
+    result.changes = changes
+    result.files_modified = len(changes)
+
+    # Rename the physical file (BLOCKER-A core fix)
+    if not dry_run and source_file.exists():
+        source_file.rename(new_file_path)
+    elif dry_run:
+        # In dry_run mode, add a synthetic change record for the file rename itself
+        # if no text change was found in the source file (e.g. only filename changes).
+        pass
+
+    return result

sourcecode/repository_ir.py

@@ -105,7 +105,12 @@ class EvidenceBundle:
 _PKG_RE = re.compile(r'^package\s+([\w.]+)\s*;', re.MULTILINE)
 _IMPORT_RE = re.compile(r'^import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;', re.MULTILINE)
 _ANN_RE = re.compile(r'^(@[\w.]+)')
-_ANN_WITH_ARGS_RE = re.compile(r'^(@[\w.]+)\s*(?:\(([^)]*)\))?')
+_ANN_WITH_ARGS_RE = re.compile(
+    r'^(@[\w.]+)\s*'
+    r'(?:\('
+    r'((?:[^()"\']*|"[^"]*"|\'[^\']*\'|\((?:[^()"\']*|"[^"]*"|\'[^\']*\')*\))*)'
+    r'\))?'
+)
 
 _CLASS_DECL_RE = re.compile(
     r'(?:^|(?<=\s))'
@@ -2814,6 +2819,11 @@ def build_repo_ir(
     if since:
         _since_changed = _get_git_changed_files(root, since)
 
+    # L-6: analysis_meta tracking (files_read, lines_read, symbols_analyzed, token_estimate)
+    _meta_files_read = 0
+    _meta_lines_read = 0
+    _meta_chars_read = 0
+
     # Pass 1: extract symbols from all files so we can build the same-package
     # type map before building relations.  Java classes in the same package
     # reference each other without import statements, so import_map alone cannot
@@ -2825,6 +2835,9 @@ def build_repo_ir(
             source = abs_path.read_text(encoding="utf-8", errors="replace")
         except OSError:
             continue
+        _meta_files_read += 1
+        _meta_lines_read += source.count("\n") + (1 if source and not source.endswith("\n") else 0)
+        _meta_chars_read += len(source)
         package, symbols, raw_imports = _extract_symbols(source, rel_path)
         all_symbols.extend(symbols)
         _per_file.append((rel_path, source, package, raw_imports, symbols))
@@ -2878,7 +2891,16 @@ def build_repo_ir(
     route_diffs_arg: Optional[list[dict]] = (
         sorted(all_route_diffs, key=lambda d: d["symbol"]) if since else None
     )
-    return _assemble(all_symbols, unique_relations, all_changed, spring_summary, route_diffs_arg)
+    ir = _assemble(all_symbols, unique_relations, all_changed, spring_summary, route_diffs_arg)
+
+    # L-6: inject analysis_meta — files_read, lines_read, symbols_analyzed, token_estimate
+    ir["analysis_meta"] = {
+        "files_read": _meta_files_read,
+        "lines_read": _meta_lines_read,
+        "symbols_analyzed": len(all_symbols),
+        "token_estimate": _meta_chars_read // 4,  # 4 chars ≈ 1 token (rough approximation)
+    }
+    return ir
 
 
 # ---------------------------------------------------------------------------
@@ -3303,6 +3325,52 @@ def extract_java_endpoints(root: Path) -> "dict[str, Any]":
     else:
         security_model = "unknown"
 
+    # Detect XML-based Spring Security config. When present, per-endpoint
+    # none_detected is expected and does NOT mean the endpoint is unsecured —
+    # security is declared in XML (HttpSecurity rules, filter chains, web.xml
+    # security constraints). Update security_model and re-tag affected endpoints
+    # so the output cannot be misread as "unprotected".
+    _XML_SECURITY_RE = re.compile(
+        r'(?:xmlns(?::[a-z]+)?="http://www\.springframework\.org/schema/security"'
+        r'|<security:http\b'
+        r'|<http\s[^>]*use-expressions'
+        r'|spring-security-[2345]'
+        r'|xmlns:security="http://www\.springframework\.org/schema/security")',
+        re.IGNORECASE,
+    )
+    _xml_security_detected = False
+    _XML_GLOBS = (
+        "*security*.xml", "*Security*.xml",
+        "*applicationContext*.xml", "*-context.xml", "*Context.xml",
+        "*spring*.xml", "*Spring*.xml",
+    )
+    for _glob in _XML_GLOBS:
+        for _xf in root.rglob(_glob):
+            if "target/" in str(_xf).replace("\\", "/"):
+                continue
+            try:
+                _xt = _xf.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            if _XML_SECURITY_RE.search(_xt):
+                _xml_security_detected = True
+                break
+        if _xml_security_detected:
+            break
+
+    if _xml_security_detected and security_model == "unknown":
+        security_model = "xml_or_filter_chain"
+        # Re-tag per-endpoint none_detected → xml_or_filter_chain so the output
+        # cannot be misread as "endpoint is unprotected".
+        for ep in endpoints:
+            if ep.get("security", {}).get("policy") == "none_detected":
+                ep["security"] = {"policy": "xml_or_filter_chain"}
+        # Recompute no_security_signal (now counts only truly unknown endpoints)
+        no_security_signal = sum(
+            1 for e in endpoints
+            if e.get("security", {}).get("policy") == "none_detected"
+        )
+
     return {
         "endpoints": endpoints,
         "total": len(endpoints),

sourcecode/spring_event_topology.py

@@ -197,14 +197,17 @@ def _compute_event_risk(
     consumer_count: int,
     before_commit_count: int,
     cross_module: bool,
+    sync_in_tx_count: int = 0,
 ) -> str:
     """Deterministic risk scoring per spec.
 
     high: fanout > 5 OR cross-module propagation OR BEFORE_COMMIT consumers
+          OR sync @EventListener inside @Transactional publisher
     medium: 2–5 consumers
     low: ≤1 consumer
     """
-    if consumer_count > _RISK_FANOUT_HIGH or cross_module or before_commit_count > 0:
+    if (consumer_count > _RISK_FANOUT_HIGH or cross_module
+            or before_commit_count > 0 or sync_in_tx_count > 0):
         return "high"
     if consumer_count >= _RISK_FANOUT_MEDIUM:
         return "medium"
@@ -327,9 +330,23 @@ class EventTopologyOrchestrator:
         # ── 7. TX context ──────────────────────────────────────────────────
         after_commit = [c.fqn for c in consumers if c.transactional_phase == "AFTER_COMMIT"]
         before_commit_risks = [c.fqn for c in consumers if c.transactional_phase == "BEFORE_COMMIT"]
+
+        # Detect sync @EventListener inside @Transactional publisher.
+        # Plain @EventListener fires synchronously; if the publisher method is
+        # @Transactional the listener runs inside that TX — listener exception
+        # rolls back the outer TX, and DB state may be partially committed.
+        tx_publishers = [
+            p for p in publishers
+            if "@Transactional" in ((fqn_index.get(p) or {}).get("annotations") or [])
+        ]
+        sync_in_tx_risks = [
+            c.fqn for c in consumers
+            if c.type == "spring_event" and tx_publishers
+        ]
         tx_context = {
             "after_commit_consumers": after_commit,
             "before_commit_risks": before_commit_risks,
+            "sync_in_tx_risks": sync_in_tx_risks,
         }
 
         # ── 8. Cross-module detection ──────────────────────────────────────
@@ -352,6 +369,7 @@ class EventTopologyOrchestrator:
             consumer_count=len(consumers),
             before_commit_count=len(before_commit_risks),
             cross_module=cross_module,
+            sync_in_tx_count=len(sync_in_tx_risks),
         )
 
         # ── 10. Confidence ─────────────────────────────────────────────────
@@ -385,6 +403,7 @@ class EventTopologyOrchestrator:
                 "kafka_listeners_in_repo": kafka_count,
                 "rabbit_listeners_in_repo": rabbit_count,
                 "before_commit_risk_count": len(before_commit_risks),
+                "sync_in_tx_risk_count": len(sync_in_tx_risks),
                 "level2_events": list(level2_events.keys()),
                 "cross_module": cross_module,
                 "model_build_time_ms": model.build_time_ms,

{sourcecode-1.35.25.dist-info → sourcecode-1.35.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.35.25
+Version: 1.35.27
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
@@ -40,7 +40,7 @@ Description-Content-Type: text/markdown
 
 **Persistent structural context and ultra-fast repeated analysis for AI coding agents.**
 
-![Version](https://img.shields.io/badge/version-1.35.25-blue)
+![Version](https://img.shields.io/badge/version-1.35.27-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -114,7 +114,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.35.25
+# sourcecode 1.35.27
 ```
 
 ---

{sourcecode-1.35.25.dist-info → sourcecode-1.35.27.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=1fGjuVJyBU95TOEnJBXLcVgGYs_QYMvaKwPypDXVP9g,104
+sourcecode/__init__.py,sha256=wAc-lNaY6I9JzmeKSyL20qzmqMMrwwFLFjIF6umkX0w,104
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/architecture_analyzer.py,sha256=qh749a7ykPtGmQI1MR9y6j8TtL_jBdVYFx9YRsLqOMw,44121
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
@@ -7,7 +7,7 @@ sourcecode/cache.py,sha256=wAyPrXN5DqiGivnMpeEuun2xHDKfBer2_oBsh6kj_vc,30447
 sourcecode/canonical_ir.py,sha256=2vTLc6wL1cH3NNbEcdZpfX5okh8h5dKq7xd0m0rv_Ro,24167
 sourcecode/cir_graphs.py,sha256=rZi8JV4ZrAa2WSCeyNa4JIEKQ_yZzDZTsrvVz2KfuKA,8919
 sourcecode/classifier.py,sha256=2lYoSH3vOTkXZYPU7Go2WIet1-IuNzTWVhc-ULnXtgw,8024
-sourcecode/cli.py,sha256=wy5-T6Ba_hvqJoFkSROCJxOpsy_VzbYI98TlJIEeGW0,238063
+sourcecode/cli.py,sha256=es0kuqlHSIMqzdQZZ9tHYbUgBe_Ogw2k_pjC1JFhJro,246257
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
 sourcecode/confidence_analyzer.py,sha256=_jckZSxksV-OU38vbkxfVNBnWCtlCq8Vwfg23x1uspA,19054
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
@@ -21,6 +21,7 @@ sourcecode/entrypoint_classifier.py,sha256=jhTYlyqDJH2AtdEcLVaRU3lYRTJuF8DkxVzl4
 sourcecode/env_analyzer.py,sha256=aNTyYgQk5noJDfJU6FmasmESOHfiomyJw5EvZqjy6qc,22213
 sourcecode/error_schema.py,sha256=uwosfNaSujtYm11_732Hu92z5ITV040fQDaIyefSvR4,1683
 sourcecode/explain.py,sha256=cCRpR4L0goET8UR1iFTq4gQ-2TDCRTL7jGITMO09TE4,16556
+sourcecode/file_chunker.py,sha256=xceHnlEg6SlSJAO5Iv2-bXICPjN8qvjQJ2CLYrHuq0o,14744
 sourcecode/file_classifier.py,sha256=A0fEABqtfVu1MfoaxnPAvGpZgneGgVXlJDhT74NYXxE,15314
 sourcecode/flow_analyzer.py,sha256=dSiuY4w49k29jW_EPXUOND9B5uVbuCA7kjnuHi-pIWA,28781
 sourcecode/fqn_utils.py,sha256=XLU7zDkNBXz_RZkIUNfpPmp1nekWtqP-fxV92tDV1vg,2158
@@ -29,7 +30,7 @@ sourcecode/graph_analyzer.py,sha256=DHR8fY69oU_Pi4SYaWboX6EoEFrctQKB9dsjpqwGMzw,
 sourcecode/license.py,sha256=3JCV2OeTVttKrOGBguU5uZC0c02Stig-KLB0mP2lNiY,22742
 sourcecode/mcp_nudge.py,sha256=5ELU_ixzh6uA83NXLOZT8h00OhL53okfQdji3jyKOjg,2917
 sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
-sourcecode/migrate_check.py,sha256=-jghKewJwMO0VCXML-ZY1KI_RQO5gd5-pyLCMg5u8jA,52971
+sourcecode/migrate_check.py,sha256=GuYK36DDFkwf07jbAgcoc-Ovq8ttLQNMsRqhsUilMzY,54514
 sourcecode/output_budget.py,sha256=Js9yUlfQtPhqBl9R6wn_9UHVjjJc3GtLcqyfjf5t50Q,9869
 sourcecode/path_filters.py,sha256=ROFRQ8eSLBEMiixK9f45-RO7um4VEEcjoD5AA4I427I,3739
 sourcecode/pr_comment_renderer.py,sha256=smHslxiG14lrytCkq5nFrFu-qTHgA-t-LFYfdrfjz2o,14423
@@ -39,15 +40,16 @@ sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
 sourcecode/redactor.py,sha256=SB4hwIvg8h-hvcqKcDWaZvA-aSyn-at-BIRwa0tUv5E,3227
 sourcecode/relevance_scorer.py,sha256=0AgEt4KrV73nioMqBgjhGjtY7L2C7L7cSyKtj3IKcrw,9408
+sourcecode/rename_refactor.py,sha256=lgfJ5Qp4WpduxcaqU84IrFz9ZhJlFnqnrCNkB_bf6RA,10379
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
-sourcecode/repository_ir.py,sha256=vTdWuFj0iRUavs4mOWl87JETR7Je9bKVeDycKBqOFp8,169640
+sourcecode/repository_ir.py,sha256=jOyInh72kTVX9jzyyeyBIEXfs4uFfRINV5rJOsT6YiM,172453
 sourcecode/ris.py,sha256=RcqLVwC-doFcKKViYDkCjZLBqf_wzLES7-F6vHEeWzE,20419
 sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
 sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
 sourcecode/schema.py,sha256=aHNXDf8LGyUC8ZDE_VS9kiskC2-Oswhi_WnpdGy6HDw,24897
 sourcecode/semantic_analyzer.py,sha256=TDuC3wzZR2DPm1mgrAg1YSLk2QzJoueS3TZAmyGGpCU,89417
 sourcecode/serializer.py,sha256=7SBJIbpC_Lg0RGWq8jjNbF5TiuZwoP_fi0qhHnzQM8M,124386
-sourcecode/spring_event_topology.py,sha256=LvGv5RXtU_O-fVB_OO9eDD2UmZM72Jn2oUHgOo50Qm0,17157
+sourcecode/spring_event_topology.py,sha256=5_ON_21Le5zbG-1GRc5GLIi5HJfy_QjcXLVPC5WeUGQ,18055
 sourcecode/spring_findings.py,sha256=8V91iHOg9hFgg6tLLl4FSsgrF-dBqOcO2s-K5sD_goA,5417
 sourcecode/spring_impact.py,sha256=Ohm2k3W4Wts8Kx8Z7DIM-J-cwGtTJBWKFBsX-WkupBQ,32943
 sourcecode/spring_model.py,sha256=IzMcM5ftw1_EHG3FGUDT7qdAMpo3eqbAE1LRuasfr_4,14739
@@ -94,8 +96,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=QSslxIwij8YkRWcVvxykODDrkiN_GAAEu3dUP7KIWeE,1651
-sourcecode-1.35.25.dist-info/METADATA,sha256=XdPhns9JN4tVct_5ARdKlbsb3w76e9rBFXZ_SI4-VC0,21297
-sourcecode-1.35.25.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.35.25.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.35.25.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.35.25.dist-info/RECORD,,
+sourcecode-1.35.27.dist-info/METADATA,sha256=mUXNvfLH6jEm0m4f4saI7ILJHMFMO9qjn5bcgiY-5U8,21297
+sourcecode-1.35.27.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.35.27.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.35.27.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.35.27.dist-info/RECORD,,