sourcecode 1.35.26__py3-none-any.whl → 1.35.28__py3-none-any.whl

sourcecode/__init__.py

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

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")
@@ -5159,10 +5397,13 @@ def cold_start_cmd(
     result = _gcs(target)
     if compact:
         # P1-C: cap at ~10K tokens — keep only fields essential for orientation.
-        _cs_keys = {"status", "git_head", "stacks", "entry_points",
-                    "key_dependencies", "project_type", "project_summary",
-                    "validation", "_meta"}
+        # BUG-6 fix: use actual RIS key names (summary/entrypoints, not stacks/entry_points)
+        _cs_keys = {"status", "git_head", "summary", "entrypoints", "endpoints",
+                    "project_type", "validation", "_meta"}
         result = {k: v for k, v in result.items() if k in _cs_keys}
+        # Truncate endpoints to first 30 to stay within ~10K token budget
+        if isinstance(result.get("endpoints"), list):
+            result["endpoints"] = result["endpoints"][:30]
         result["_meta"] = {**(result.get("_meta") or {}), "compact_mode": True,
                            "full_available": "sourcecode cold-start (without --compact)"}
     _out = _json.dumps(result, indent=2, ensure_ascii=False)

sourcecode/explain.py

@@ -28,6 +28,9 @@ _STEREOTYPE_DESC: dict[str, str] = {
     "component": "Spring @Component — general-purpose bean",
     "configuration": "Spring @Configuration — bean factory / config",
     "bean": "Spring @Bean — managed component",
+    "entity": "JPA @Entity — persistent domain object mapped to a database table",
+    "mappedsuperclass": "JPA @MappedSuperclass — base class sharing persistent state with subclasses",
+    "embeddable": "JPA @Embeddable — value object embedded in owning entity table",
 }
 
 _SECURITY_ANNOTATION_PREFIXES = (

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/rename_refactor.py

@@ -0,0 +1,351 @@
+"""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 (
+                "/src/test/" in rel or rel.startswith("src/test/")
+                or "/src/tests/" in rel or rel.startswith("src/tests/")
+                or rel.startswith("test/") or rel.startswith("tests/")
+            ):
+                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)."""
+    result = re.sub(r'\b' + re.escape(old_name) + r'\b', new_name, source)
+
+    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
+
+
+# Matches a class/interface/enum/record declaration of a given name
+_CLASS_DECL_RE_TMPL = r'\b(?:class|interface|enum|record)\s+{name}\b'
+# Matches a constructor declaration: optional access modifier + ClassName + (
+_CTOR_DECL_RE_TMPL = r'^\s*(?:(?:public|protected|private)\s+)?' + r'{name}\s*\('
+
+
+def _apply_rename_refs_only(source: str, old_name: str, new_name: str) -> str:
+    """Rename old_name→new_name in a non-source file (import/type references only).
+
+    Skips lines containing a class/interface/enum/record declaration or constructor
+    declaration of old_name, so that a class sharing the simple name in another
+    package is not corrupted.
+    """
+    class_decl_re = re.compile(_CLASS_DECL_RE_TMPL.format(name=re.escape(old_name)))
+    ctor_decl_re = re.compile(_CTOR_DECL_RE_TMPL.format(name=re.escape(old_name)))
+    ref_re = re.compile(r'\b' + re.escape(old_name) + r'\b')
+
+    lines = source.splitlines(keepends=True)
+    result_lines = []
+    for line in lines:
+        if class_decl_re.search(line) or ctor_decl_re.search(line):
+            result_lines.append(line)
+        else:
+            result_lines.append(ref_re.sub(new_name, line))
+    result = ''.join(result_lines)
+
+    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("\\", "/")
+
+    # BUG-2: check for collision anywhere in the repo, not just same directory
+    collision = next(
+        (f for f in java_files if f.stem == new_name and f.resolve() != new_file_path.resolve()),
+        None,
+    )
+    if collision is not None:
+        collision_rel = str(collision.relative_to(root)).replace("\\", "/")
+        result.errors.append(
+            f"'{new_name}' already exists at '{collision_rel}' — "
+            f"rename would create a duplicate class name. Pass --force to override."
+        )
+        return result
+
+    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
+
+        is_source = java_file == source_file
+        if is_source:
+            new_text = _apply_rename(old_text, old_name, new_name)
+        else:
+            # BUG-4: use refs-only variant to avoid clobbering same-named class in other package
+            new_text = _apply_rename_refs_only(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)
+
+        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

@@ -202,8 +202,9 @@ _SECURITY_MARKER_ANNOTATIONS: frozenset[str] = frozenset({
 # is expected and does NOT mean endpoints are unprotected.
 _FILTER_SECURITY_ANNOTATIONS: frozenset[str] = frozenset({
     "@EnableWebSecurity",
-    "@EnableMethodSecurity",
-    "@EnableGlobalMethodSecurity",
+    # @EnableMethodSecurity / @EnableGlobalMethodSecurity enable per-method annotation
+    # security (@PreAuthorize/@Secured), NOT a filter chain — must NOT be treated as
+    # filter_based or SEC-001 is suppressed for every unannotated endpoint.
 })
 
 # Programmatic security: method-call patterns that indicate runtime auth enforcement.
@@ -2819,6 +2820,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
@@ -2830,6 +2836,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))
@@ -2883,7 +2892,58 @@ 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)
+
+    # BUG-7: XML Spring Security detection for the canonical CIR pipeline.
+    # _assemble only sees Java symbols — XML config is invisible to it.
+    # Scan here (where root is available) and retag route_surface entries so
+    # build_canonical_ir produces correct CanonicalEndpoint.security values.
+    _xml_sec_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_sec_detected = False
+    for _xml_glob in (
+        "*security*.xml", "*Security*.xml",
+        "*applicationContext*.xml", "*-context.xml", "*Context.xml",
+        "*spring*.xml", "*Spring*.xml",
+    ):
+        for _xf in root.rglob(_xml_glob):
+            if "target/" in str(_xf).replace("\\", "/"):
+                continue
+            try:
+                _xt = _xf.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            if _xml_sec_re.search(_xt):
+                _xml_sec_detected = True
+                break
+        if _xml_sec_detected:
+            break
+    if _xml_sec_detected:
+        _sec_model = ir.get("security_model", "unknown")
+        if _sec_model == "unknown":
+            ir["security_model"] = "xml_or_filter_chain"
+        elif _sec_model in ("annotation_based", "mixed"):
+            ir["security_model"] = "mixed"
+        # Retag route_surface entries that have no security (would become none_detected in CIR)
+        for _r in ir.get("route_surface") or []:
+            _r_sec = _r.get("security_annotations")
+            if _r_sec is None or (isinstance(_r_sec, dict) and _r_sec.get("policy") == "none_detected"):
+                _r["security_annotations"] = {"policy": "xml_or_filter_chain"}
+
+    # 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
 
 
 # ---------------------------------------------------------------------------
@@ -3341,13 +3401,18 @@ def extract_java_endpoints(root: Path) -> "dict[str, Any]":
         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".
+    if _xml_security_detected:
+        # Re-tag per-endpoint none_detected → xml_or_filter_chain regardless of security_model.
+        # BUG-7 fix: previously only ran when model == "unknown", causing false-positive SEC-001
+        # when annotation security (@PreAuthorize) coexisted with XML security config.
         for ep in endpoints:
             if ep.get("security", {}).get("policy") == "none_detected":
                 ep["security"] = {"policy": "xml_or_filter_chain"}
+        if security_model == "unknown":
+            security_model = "xml_or_filter_chain"
+        elif security_model in ("annotation_based", "mixed"):
+            security_model = "mixed"
+        # filter_based stays filter_based — XML + filter chain is still filter_based
         # Recompute no_security_signal (now counts only truly unknown endpoints)
         no_security_signal = sum(
             1 for e in endpoints
@@ -3378,7 +3443,11 @@ def find_java_files(root: Path, *, max_files: int = 8000, limitations: list[str]
             continue
         parts = rel.split("/")
         # Skip test dirs
-        if "/test/" in rel or "/tests/" in rel or rel.startswith("test/"):
+        if (
+            "/src/test/" in rel or rel.startswith("src/test/")
+            or "/src/tests/" in rel or rel.startswith("src/tests/")
+            or rel.startswith("test/") or rel.startswith("tests/")
+        ):
             continue
         # Skip vendor/generated/build dirs
         if any(part in _VENDOR_DIRS for part in parts[:-1]):

sourcecode/spring_model.py

@@ -41,6 +41,8 @@ _CALL_SKIP: frozenset[str] = frozenset({"annotated_with", "mapped_to", "containe
 _BEAN_ANNOTATIONS: frozenset[str] = frozenset({
     "@Component", "@Service", "@Repository",
     "@Controller", "@RestController", "@Configuration", "@Bean",
+    # JPA persistence annotations — not Spring beans but need stereotype recognition in explain
+    "@Entity", "@MappedSuperclass", "@Embeddable",
 })
 
 _GENERIC_PARAM_RE = re.compile(r"<[A-Z][\w,\s<>?]*>")

{sourcecode-1.35.26.dist-info → sourcecode-1.35.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.35.26
+Version: 1.35.28
 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.26-blue)
+![Version](https://img.shields.io/badge/version-1.35.28-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -114,7 +114,9 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.35.26
+# sourcecode 1.35.28
+
+**v1.35.28** — 7 bug fixes: `rename-class` cross-package disambiguation (BUG-4), `rename-class` collision detection (BUG-2), `find_java_files` false positive on `com/test/` package paths (BUG-1), `cold-start --compact` correct key names (BUG-6), `@EnableMethodSecurity` no longer suppresses SEC-001 (BUG-3), `explain` @Entity stereotype detection (BUG-5), XML+annotation mixed security retagging (BUG-7).
 ```
 
 ---

{sourcecode-1.35.26.dist-info → sourcecode-1.35.28.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=HYA42OYABbKZ43Trr1VCdpUkXMtz0AqpwPt0ENMTTjo,104
+sourcecode/__init__.py,sha256=6hJmVTMbA3xWMi_K8kDZKhf82Qh1AoNAv1zZtaf2IEg,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=SZDc7biuDWEXYGn1kvvN4RqmWOA-GHnmJbGdHnYBdh0,246491
 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
@@ -20,7 +20,8 @@ sourcecode/doc_analyzer.py,sha256=05bjTUbDbmnbajD_cgRnACzS8T7xxBKVX4CjkJlhZg8,24
 sourcecode/entrypoint_classifier.py,sha256=jhTYlyqDJH2AtdEcLVaRU3lYRTJuF8DkxVzl4-W3zWE,5322
 sourcecode/env_analyzer.py,sha256=aNTyYgQk5noJDfJU6FmasmESOHfiomyJw5EvZqjy6qc,22213
 sourcecode/error_schema.py,sha256=uwosfNaSujtYm11_732Hu92z5ITV040fQDaIyefSvR4,1683
-sourcecode/explain.py,sha256=cCRpR4L0goET8UR1iFTq4gQ-2TDCRTL7jGITMO09TE4,16556
+sourcecode/explain.py,sha256=N5189hO8Ydbunr431zWDpSueSTdgBZh9l2xU-fH-AO8,16832
+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
@@ -39,8 +40,9 @@ 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=rWCsXoDxJNdsmkUXjPtHphT5CjYOgEPmcc817_8Gu-Y,12538
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
-sourcecode/repository_ir.py,sha256=hl7Vc7o5LD0xWZ6Er7-x2IDrLurJZIfBKGPD-3cfraU,171754
+sourcecode/repository_ir.py,sha256=n--piFig_NjiGFRzQF8p2-UkLnspHh-4ZFIhUURg2ik,175044
 sourcecode/ris.py,sha256=RcqLVwC-doFcKKViYDkCjZLBqf_wzLES7-F6vHEeWzE,20419
 sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
 sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
@@ -50,7 +52,7 @@ sourcecode/serializer.py,sha256=7SBJIbpC_Lg0RGWq8jjNbF5TiuZwoP_fi0qhHnzQM8M,1243
 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
+sourcecode/spring_model.py,sha256=6Lk3rGGFy2suq867S8Da_aCNAXtSGJ36XBaQd9VNTFc,14888
 sourcecode/spring_security_audit.py,sha256=AmUkqoExkNZ3YxxZf9TwkwX-f7P_SETm0QC7VqEAqh4,20618
 sourcecode/spring_semantic.py,sha256=CiAf77p48-RFrUF0zbgww4w2Xigrbo1t5M3ZCDIfV_g,12032
 sourcecode/spring_tx_analyzer.py,sha256=u4_ckdEFZUiIsHdUX4OaIhnvoTdAwrxNTFweG6vc7wE,30526
@@ -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.26.dist-info/METADATA,sha256=M8Y5dAsVOUGs7ij_YJC26hy4SJtJ_4fFGZZ6NpuabKQ,21297
-sourcecode-1.35.26.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.35.26.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.35.26.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.35.26.dist-info/RECORD,,
+sourcecode-1.35.28.dist-info/METADATA,sha256=2IgUuaTJL4deTV1f5JN_uZoyxnHCr_pj4nSptbPpnfo,21705
+sourcecode-1.35.28.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.35.28.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.35.28.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.35.28.dist-info/RECORD,,