sourcecode 4.10.4__py3-none-any.whl → 4.10.5__py3-none-any.whl

sourcecode/__init__.py

@@ -4,4 +4,4 @@ ASK Engine is the product. ``ask`` is the canonical CLI command; ``sourcecode``
 the legacy compatibility alias and the Python/PyPI package name. See
 docs/PRODUCT_IDENTITY.md (normative)."""
 
-__version__ = "4.10.4"
+__version__ = "4.10.5"

sourcecode/cli.py

@@ -18,6 +18,7 @@ from sourcecode import __version__
 from sourcecode.error_schema import EXECUTION_FAILED_CODE, INVALID_INPUT_CODE, build_error_envelope
 from sourcecode.entrypoint_classifier import is_production_entry_point, normalize_entry_point
 from sourcecode.progress import Progress
+from sourcecode.progress import output_emitted as _progress_output_emitted
 from sourcecode import perf
 from sourcecode.caller_metrics import (
     CALLER_METRIC_RECONCILIATION,
@@ -888,8 +889,27 @@ def _safe_write_file(path: "Path", content: str) -> None:
         path = Path(path)
         path.parent.mkdir(parents=True, exist_ok=True)
         tmp = path.with_name(f".{path.name}.tmp-{os.getpid()}-{time.time_ns()}")
-        tmp.write_text(content, encoding="utf-8")
+        # C3-54 part 2: the rename is atomic, the bytes were not durable. A
+        # process torn down between `write_text` and the OS flushing its page
+        # cache leaves a file that exists at full length and holds nothing —
+        # the same total loss the false `done` line reported as success, one
+        # layer down. fsync the data before the rename, then the directory
+        # entry, so a run that reports an output file has one.
+        with open(tmp, "w", encoding="utf-8") as fh:
+            fh.write(content)
+            fh.flush()
+            os.fsync(fh.fileno())
         tmp.replace(path)
+        try:
+            dir_fd = os.open(str(path.parent), os.O_RDONLY)
+            try:
+                os.fsync(dir_fd)
+            finally:
+                os.close(dir_fd)
+        except (OSError, AttributeError):
+            # Directory fsync is POSIX-only; on Windows the rename is already
+            # ordered against the data write. Never fail a good run over it.
+            pass
         try:
             from sourcecode.runs import active_run
             run = active_run()
@@ -1213,6 +1233,9 @@ def _emit_command_output(
             # The payload is on stdout here, so this cannot join it; it is a
             # notice and takes the terminal gate rather than dirtying a capture.
             _notice("✓ copied to clipboard")
+    # The answer has been handed over. Any `done (Xs)` a command deferred is now
+    # a true claim and prints here — never before this line (C3-54).
+    _progress_output_emitted()
 
 
 def _emit_text_output(text: str, copy: bool) -> None:
@@ -1228,6 +1251,7 @@ def _emit_text_output(text: str, copy: bool) -> None:
     typer.echo(text)
     if copy and _copy_to_clipboard(text):
         _notice("✓ copied to clipboard")
+    _progress_output_emitted()
 
 
 class _TextAnswer:
@@ -1257,6 +1281,7 @@ class _TextAnswer:
     def done(self, copy: bool) -> None:
         if copy and self._lines and _copy_to_clipboard(self.text):
             _notice("✓ copied to clipboard")
+        _progress_output_emitted()
 
 
 # H-06: Intercept Click-level UsageError (unknown options, bad args) and emit JSON.
@@ -4825,8 +4850,15 @@ def repo_ir_cmd(
         size_bytes = len(raw_bytes)
         if gzip_output:
             import gzip as _gzip
+            # Same durability rule as `_safe_write_file`: the bytes are on disk
+            # before anything says they are (C3-54).
             with _gzip.open(output_path, "wb") as _gz:
                 _gz.write(raw_bytes)
+                _gz.flush()
+                try:
+                    os.fsync(_gz.fileno())
+                except (OSError, AttributeError):
+                    pass
             compressed_kb = output_path.stat().st_size // 1024
             size_kb = size_bytes // 1024
             # C3-26: when the payload went to a file, this confirmation IS the
@@ -4837,7 +4869,9 @@ def repo_ir_cmd(
                 f"IR written to {output_path} ({compressed_kb}KB gzip, {size_kb}KB uncompressed)"
             )
         else:
-            output_path.write_bytes(raw_bytes)
+            # Was a bare `write_bytes`: neither atomic nor durable, and the only
+            # `-o` write in the CLI that skipped the shared seam (C3-54).
+            _safe_write_file(output_path, output)
             size_kb = size_bytes // 1024
             if summary_only:
                 typer.echo(
@@ -4850,6 +4884,7 @@ def repo_ir_cmd(
                     f"IR written to {output_path} "
                     f"({size_kb}KB, {n_nodes} nodes, {n_edges} edges)"
                 )
+        _progress_output_emitted()
     else:
         if gzip_output:
             _emit_error_json(
@@ -9461,18 +9496,21 @@ def pr_impact_cmd(
     # --files accepts three shapes: a list file, '-' for stdin, or an inline
     # comma-separated list. The list-file shape was the only documented one and
     # the only one the error hint mentioned.
-    _files_raw = str(files).strip()
+    # Both byte-carrying shapes decode through `text_input`: stdin and list files
+    # arrive as somebody else's shell wrote them, and the locale codepage is not
+    # evidence of their encoding (C3-58).
+    from sourcecode import text_input as _text_input
+
+    _files_raw = str(files).replace(_text_input.BOM_CHAR, "").strip()
     if _files_raw == "-":
-        changed_files = [ln.strip() for ln in sys.stdin.read().splitlines() if ln.strip()]
+        changed_files = _text_input.parse_path_lines(_text_input.read_stdin_text())
         _files_desc = "stdin"
     else:
         _files_path = Path(_files_raw)
         if _files_path.is_file():
-            changed_files = [
-                line.strip()
-                for line in _files_path.read_text(encoding="utf-8").splitlines()
-                if line.strip()
-            ]
+            changed_files = _text_input.parse_path_lines(
+                _text_input.read_text_file(_files_path)
+            )
             _files_desc = str(_files_path)
         elif all(
             p.strip().lower().endswith(".java")
@@ -10309,6 +10347,9 @@ def modernize_cmd(
             sys.stdout.buffer.flush()
         except AttributeError:
             sys.stdout.write(output + "\n")
+    # This branch predates `_emit_command_output`, so it also has to release the
+    # deferred completion line itself (C3-54).
+    _progress_output_emitted()
 
     if copy:
         _copy_to_clipboard(output)

sourcecode/pr_impact.py

@@ -228,6 +228,43 @@ def _suffix_candidates(norm: str, file_class_index: dict[str, list[str]]) -> lis
     return shorter_given or longer_given
 
 
+def _exists_on_disk(norm: str, root: Path) -> bool:
+    """True when the given path names a file that is actually there."""
+    try:
+        candidate = Path(norm)
+        if candidate.is_absolute():
+            return candidate.is_file()
+        return (root / norm).is_file()
+    except OSError:
+        # A path the OS refuses to even stat (illegal characters after a bad
+        # decode, a name past MAX_PATH) is not on disk as far as we can tell.
+        return False
+
+
+def _unresolved_warning(path_str: str, norm: str, root: Path) -> str:
+    """Name the right thing to check for a changed file that mapped to nothing.
+
+    The two causes need opposite investigations and the single old message sent
+    every operator to the wrong one. A path that is *not there* is a path
+    problem — the field case was a BOM and cp1252 mojibake reaching us through
+    stdin (C3-58), and the message said "not in CIR", so the operator went
+    looking at analysis coverage. A path that *is* there carries no class
+    symbols, which is a fact about the file.
+    """
+    if _exists_on_disk(norm, root):
+        return (
+            f"No Spring classes found for '{path_str}' — the file exists but "
+            "contributes no class symbols to the CIR (interface-free package-info, "
+            "an empty file, or a file excluded from analysis)."
+        )
+    return (
+        f"No file at '{path_str}' under the analyzed repository — nothing was "
+        "matched, and this is a path problem, not an analysis gap. Check the path "
+        "form (relative to the repo root) and its encoding: a byte-order mark or a "
+        "non-UTF-8 pipe corrupts accented names."
+    )
+
+
 def _resolve_changed_files(
     file_list: list[str],
     file_class_index: dict[str, list[str]],
@@ -293,10 +330,7 @@ def _resolve_changed_files(
 
         if not candidates:
             unresolved_java.append(norm)
-            warnings.append(
-                f"No Spring classes found for '{path_str}' — "
-                "file not in CIR or has no class symbols."
-            )
+            warnings.append(_unresolved_warning(path_str, norm, root))
 
         for cls in candidates:
             if cls not in seen_classes:

sourcecode/progress.py

@@ -3,6 +3,18 @@
 Writes only to stderr. Zero-cost when stderr is not a TTY or CI is detected,
 unless ASK_PROGRESS=1 explicitly requests line heartbeats for supervised jobs.
 Thread-safe; stop() is idempotent.
+
+`done (Xs)` is a claim, and C3-54 is what happens when it is made early: the
+field log printed `[ask] done (6.8m)` and the output directory held no
+`f3-audit.json`, because the completion line was emitted when the *analysis*
+finished — before the render and the write — and the process was torn down in
+that window. 6.8 minutes of CPU, zero recoverable bytes, reported as success.
+
+So the line is not printed where `finish()` is called. `finish()` claims the
+work is done; the line is emitted when the **answer has actually been handed
+over**, which the CLI signals through `output_emitted()` at its output seams. A
+run that is killed between the two prints nothing, which is the honest outcome:
+no answer, no completion line.
 """
 from __future__ import annotations
 
@@ -14,6 +26,40 @@ from typing import Optional
 
 _FRAMES = ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏")
 
+#: Consecutive failed heartbeat writes before the loop gives up on the stream.
+_MAX_WRITE_FAILURES = 5
+
+# --- Completion registry ----------------------------------------------------
+# Module state, not per-instance: the emitter of the answer (the CLI output
+# seam) and the owner of the completion line (a Progress somewhere up the call
+# stack) never see each other.
+_registry_lock = threading.Lock()
+_output_events = 0
+_pending_done: "list[Progress]" = []
+
+
+def output_emitted() -> None:
+    """The command's answer has been written. Release any deferred `done` line.
+
+    Called from every CLI output seam. Safe to call when no Progress is running
+    and safe to call more than once per run.
+    """
+    global _output_events
+    with _registry_lock:
+        _output_events += 1
+        released = list(_pending_done)
+        _pending_done.clear()
+    for prog in released:
+        prog._print_done()
+
+
+def _reset_for_tests() -> None:
+    """Drop registry state between in-process test runs."""
+    global _output_events
+    with _registry_lock:
+        _output_events = 0
+        _pending_done.clear()
+
 
 def _terminal_capable() -> bool:
     if os.environ.get("ASK_PROGRESS", "").lower() in ("1", "true", "yes", "on"):
@@ -57,6 +103,10 @@ class Progress:
         self._stop_event = threading.Event()
         self._thread: Optional[threading.Thread] = None
         self._stopped = False
+        self._done_printed = False
+        self._outputs_at_start = 0
+        self._elapsed_at_finish = 0.0
+        self._write_failures = 0
 
     @property
     def elapsed(self) -> float:
@@ -67,6 +117,9 @@ class Progress:
         with self._lock:
             self._phase = phase
         self._stopped = False
+        self._done_printed = False
+        with _registry_lock:
+            self._outputs_at_start = _output_events
         if not self._enabled:
             return self
         self._stop_event.clear()
@@ -95,14 +148,41 @@ class Progress:
         return elapsed
 
     def finish(self) -> None:
-        """Stop spinner and print a completion line to stderr."""
-        elapsed = self.stop()
+        """Stop the spinner and claim completion — as soon as that is true.
+
+        If the command has already handed over its answer (the `spring-audit`
+        shape: `finish()` called after the write), the line prints here. If it
+        has not, the line waits for `output_emitted()`. It is never printed on a
+        run that dies in between, and never on a run that raised: `finally:
+        finish()` on an exception path leaves a claim pending that nothing
+        releases (C3-54).
+        """
+        self._elapsed_at_finish = self.stop()
         if not self._enabled:
             return
+        with _registry_lock:
+            if _output_events > self._outputs_at_start:
+                already_emitted = True
+            else:
+                already_emitted = False
+                if self not in _pending_done:
+                    _pending_done.append(self)
+        if already_emitted:
+            self._print_done()
+
+    def _print_done(self) -> None:
+        """Write the completion line once, for an answer that now exists."""
+        if self._done_printed or not self._enabled:
+            return
+        self._done_printed = True
+        elapsed = getattr(self, "_elapsed_at_finish", self.elapsed)
         t = f"{elapsed:.1f}s" if elapsed < 60 else f"{elapsed / 60:.1f}m"
         prefix = "[ask] " if self._line_mode else "✓ "
-        sys.stderr.write(f"{prefix}done ({t})\n")
-        sys.stderr.flush()
+        try:
+            sys.stderr.write(f"{prefix}done ({t})\n")
+            sys.stderr.flush()
+        except Exception:
+            pass
 
     def _loop(self) -> None:
         idx = 0
@@ -120,6 +200,19 @@ class Progress:
             try:
                 sys.stderr.write(line)
                 sys.stderr.flush()
-            except Exception:
+                self._write_failures = 0
+            except ValueError:
+                # The stream is closed — the run is ending. Nothing to retry.
                 break
+            except Exception:
+                # C3-56: a single failed write used to end the heartbeat for the
+                # rest of the run, and the operator's only remaining way to tell
+                # work from a hang was reading the worker's CPU time. One bad
+                # write is not evidence that the next one fails: on Windows a
+                # redirected stderr can reject a write transiently. Give up only
+                # when the stream refuses repeatedly.
+                self._write_failures += 1
+                if self._write_failures >= _MAX_WRITE_FAILURES:
+                    break
+                continue
             idx += 1

sourcecode/repository_ir.py

@@ -21,7 +21,7 @@ import subprocess
 from collections import deque
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Iterable, Optional
+from typing import Any, Iterable, Iterator, Optional
 
 from sourcecode.caller_metrics import CALLER_METRIC_RECONCILIATION, caller_classes
 from sourcecode.degradation import cap_effect as _cap_effect
@@ -5634,6 +5634,43 @@ _VENDOR_DIRS: frozenset[str] = frozenset({
     "generated-resources",
 })
 
+#: Metadata trees that hold no repository source at all. Kept apart from
+#: `_VENDOR_DIRS` because that set answers "is this file part of the product";
+#: this one answers "is there anything here worth opening". `.git` alone holds
+#: 5 542 loose objects in this repository, and every unpruned `rglob` visits
+#: every one of them.
+_METADATA_DIRS: frozenset[str] = frozenset({
+    ".git", ".hg", ".svn", ".idea", ".vscode", "__pycache__",
+})
+
+#: One ignore set for every tree walk that is looking for source (C3-64). A
+#: second, hand-kept list beside this one is how two surfaces come to disagree
+#: about what counts as source.
+PRUNED_TREE_DIRS: frozenset[str] = _VENDOR_DIRS | _METADATA_DIRS
+
+
+def walk_source_tree(
+    root: Path, *, prune: frozenset[str] = PRUNED_TREE_DIRS,
+) -> "Iterator[Path]":
+    """Yield every file under `root`, never descending into a pruned directory.
+
+    `Path.rglob` has no way to skip a subtree: it walks the build output and the
+    VCS metadata and then filters by name, so the cost of a scan is set by what
+    the build wrote rather than by what the developer did. Measured on
+    openmrs-core, 47 % of all tree entries live under directories in `prune`
+    (C3-64).
+
+    Yields absolute paths, and never raises: an unreadable directory is skipped
+    the same way the previous `rglob` calls swallowed `OSError`.
+    """
+    import os
+
+    for dirpath, dirnames, filenames in os.walk(root, onerror=lambda _e: None):
+        dirnames[:] = [d for d in dirnames if d not in prune]
+        base = Path(dirpath)
+        for name in filenames:
+            yield base / name
+
 
 def apply_ir_size_limits(
     ir: dict,

sourcecode/security_config_scan.py

@@ -609,13 +609,36 @@ def scan_security_configuration(
         out.extend(_scan_commented_controls(source, rel, xml=False))
         out.extend(_scan_java(blank_java_comments(source), rel))
 
+    # C3-64 — one pruned walk for all three populations. This used to be five
+    # `rglob` calls (one per config suffix, one for descriptors, one for
+    # mappers), none of which could skip a subtree: the cost was set by the size
+    # of `target/`, `node_modules/` and `.git` rather than by the source. The
+    # ignore set is the walker's own (`repository_ir.PRUNED_TREE_DIRS`), so this
+    # surface and Java discovery cannot disagree about what is source.
+    from sourcecode.repository_ir import walk_source_tree
+
+    _walked_config: "list[str]" = []
+    descriptors: "list[str]" = []
+    mappers: "list[str]" = []
+    for path in walk_source_tree(root):
+        name = path.name
+        lower = name.lower()
+        try:
+            rel_posix = path.relative_to(root).as_posix()
+        except ValueError:
+            continue
+        if name.startswith("application") and name.endswith(_CONFIG_SUFFIXES):
+            _walked_config.append(rel_posix)
+        elif lower.endswith(".xml"):
+            # A descriptor that also ends in `Mapper.xml` stays a descriptor —
+            # the old code took the same side by subtracting one set from the other.
+            if lower in _DESCRIPTOR_NAMES or lower.endswith(_DESCRIPTOR_SUFFIXES):
+                descriptors.append(rel_posix)
+            elif name.endswith("Mapper.xml"):
+                mappers.append(rel_posix)
+
     if config_files is None:
-        config_files = []
-        for suffix in _CONFIG_SUFFIXES:
-            config_files += [
-                p.relative_to(root).as_posix()
-                for p in root.rglob(f"application*{suffix}")
-            ]
+        config_files = _walked_config
     for rel in sorted(set(config_files)):
         try:
             text = (root / rel).read_text(encoding="utf-8", errors="replace")
@@ -624,18 +647,10 @@ def scan_security_configuration(
         out.extend(_scan_commented_config_controls(text, rel))
         out.extend(_scan_config(blank_hash_comments(text), rel))
 
-    # CL-10 — the descriptors. Discovered the same way `environment_resolution`
+    # CL-10 — the descriptors. Classified the same way `environment_resolution`
     # classifies them, so the two surfaces cannot disagree about which files are
     # deployment descriptors, and a per-environment overlay tree is covered
     # because the walk finds the file wherever the build put it.
-    descriptors: "list[str]" = []
-    try:
-        for path in root.rglob("*.xml"):
-            name = path.name.lower()
-            if name in _DESCRIPTOR_NAMES or name.endswith(_DESCRIPTOR_SUFFIXES):
-                descriptors.append(path.relative_to(root).as_posix())
-    except OSError:
-        pass
     for rel in sorted(set(descriptors)):
         try:
             text = (root / rel).read_text(encoding="utf-8", errors="replace")
@@ -644,13 +659,6 @@ def scan_security_configuration(
         out.extend(_scan_commented_controls(text, rel, xml=True))
         out.extend(_scan_descriptor(blank_xml_comments(text), rel))
 
-    mappers: "list[str]" = []
-    try:
-        for path in root.rglob("*.xml"):
-            if path.name.endswith("Mapper.xml"):
-                mappers.append(path.relative_to(root).as_posix())
-    except OSError:
-        pass
     for rel in sorted(set(mappers) - set(descriptors)):
         try:
             text = (root / rel).read_text(encoding="utf-8", errors="replace")

sourcecode/text_input.py

@@ -0,0 +1,93 @@
+"""text_input.py — one authority for decoding text that arrives from outside.
+
+Every path list this CLI accepts (stdin, a list file) is bytes written by
+somebody else's shell. Python decodes stdin with the *locale* encoding, which on
+Windows is the ANSI codepage (cp1252), not UTF-8 — so a path piped from
+PowerShell came back mojibake and resolved to nothing:
+
+    Año…java  ->  Año…java        (UTF-8 bytes read as cp1252)
+    src/…  ->  src/…      (the UTF-8 BOM read as three cp1252 chars)
+
+Both forms silently produced an empty blast radius on `pr-impact --files -`,
+which is the gating command: `CRITICAL` became a green pipeline (C3-58).
+
+The rule here is that the *bytes* decide the encoding, never the platform
+locale: a BOM is authoritative when present, UTF-8 otherwise. A byte sequence
+that is not valid UTF-8 (a genuinely cp1252-encoded list) decodes with
+replacement characters rather than raising — the path then fails to resolve and
+the consumer's diagnostic names encoding as a cause, which beats a traceback.
+
+Pure module: no I/O policy, no CLI imports.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+#: Byte-order marks, longest first — UTF-32-LE starts with the UTF-16-LE mark.
+#: The codec named here is the one that *consumes* the mark: `utf-16-le` leaves a
+#: U+FEFF at the head of the text, `utf-16` reads the mark and drops it.
+_BOMS: tuple[tuple[bytes, str], ...] = (
+    (b"\x00\x00\xfe\xff", "utf-32"),
+    (b"\xff\xfe\x00\x00", "utf-32"),
+    (b"\xef\xbb\xbf", "utf-8-sig"),
+    (b"\xfe\xff", "utf-16"),
+    (b"\xff\xfe", "utf-16"),
+)
+
+#: The BOM as a character. `utf-16`/`utf-32` decoding consumes the mark, but a
+#: BOM in the *middle* of a stream (PowerShell writing one per redirection) and
+#: a stream already handed to us as `str` both leave it in the text.
+BOM_CHAR = ""
+
+
+def sniff_encoding(data: bytes) -> str:
+    """Return the encoding named by `data`'s byte-order mark, else `utf-8`."""
+    for mark, encoding in _BOMS:
+        if data.startswith(mark):
+            return encoding
+    return "utf-8"
+
+
+def decode_bytes(data: bytes) -> str:
+    """Decode externally supplied bytes. BOM decides; UTF-8 is the default.
+
+    Never raises: undecodable bytes become U+FFFD so the caller can report an
+    unusable path instead of dying on it.
+    """
+    return data.decode(sniff_encoding(data), errors="replace")
+
+
+def read_stdin_text() -> str:
+    """Read all of stdin as text, decoded by the bytes rather than the locale.
+
+    Falls back to `sys.stdin.read()` when the stream has no binary buffer —
+    Click's `CliRunner` and test doubles replace `sys.stdin` with a `StringIO`.
+    """
+    buffer = getattr(sys.stdin, "buffer", None)
+    if buffer is None:
+        return sys.stdin.read()
+    return decode_bytes(buffer.read())
+
+
+def read_text_file(path: Path) -> str:
+    """Read a file supplied by the user as text, BOM-aware.
+
+    `Path.read_text(encoding="utf-8")` raised on the file PowerShell 5.1 writes
+    by default: `git diff --name-only > changed.txt` there is UTF-16-LE.
+    """
+    return decode_bytes(path.read_bytes())
+
+
+def parse_path_lines(text: str) -> list[str]:
+    """Split a path listing into clean entries.
+
+    Strips the BOM character wherever it survived decoding, normalises CRLF, and
+    drops blank lines. Order is preserved; duplicates are the caller's business.
+    """
+    entries: list[str] = []
+    for line in text.splitlines():
+        cleaned = line.replace(BOM_CHAR, "").strip()
+        if cleaned:
+            entries.append(cleaned)
+    return entries

{sourcecode-4.10.4.dist-info → sourcecode-4.10.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 4.10.4
+Version: 4.10.5
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
@@ -42,7 +42,7 @@ Description-Content-Type: text/markdown
 
 **Context · Impact · Migration · Architecture · Review — everything from one structural model.**
 
-![Version](https://img.shields.io/badge/version-4.10.4-blue)
+![Version](https://img.shields.io/badge/version-4.10.5-blue)
 ![Python](https://img.shields.io/badge/python-3.9%2B-green)
 
 > **ASK Engine** is the product. The CLI command is **`ask`**. The legacy **`sourcecode`**
@@ -106,7 +106,7 @@ brew tap haroundominique/sourcecode && brew install sourcecode
 # pip / pipx
 pipx install sourcecode        # or: pip install sourcecode
 
-ask version                    # ask 4.10.4 — and, on a build that has aged,
+ask version                    # ask 4.10.5 — and, on a build that has aged,
                                # how many releases have probably shipped since
 ```
 

{sourcecode-4.10.4.dist-info → sourcecode-4.10.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=CWukY8bLFVrEUIM2D9buLe9rM2OWPuG0EFvr8TfFs2s,309
+sourcecode/__init__.py,sha256=N-KHrUXD6ch30-2odxw2VCquK5xEfMXbG2ZoDVLuWQU,309
 sourcecode/adaptive_scanner.py,sha256=yJBKjNpkY6bpueYJ2YnRezen3sYZDecEt7WaaNWdqug,9466
 sourcecode/archetype.py,sha256=CZvRLpkHot_D8D3JFQVorr-EHDJyh0BbS7RnSTqBigM,40499
 sourcecode/architectural_baseline.py,sha256=ihbYyVgR9MJ2RBuEfayY3rWfubS27MT7m0JPc2NpSWU,20087
@@ -18,7 +18,7 @@ sourcecode/chain_rules.py,sha256=Bi6UHfgd-GxWswmnHRcPz5jdbAuqka3Zkz_P-MTvqhw,127
 sourcecode/change_plan.py,sha256=kFjjp16XYbupgkv1CPkfqo39_SiZPMRQ8OOfC-Vy9eg,7929
 sourcecode/cir_graphs.py,sha256=9G0HHj1kw2325IDyzo2OpX73BNswEckecf4MZUXB4JM,12078
 sourcecode/classifier.py,sha256=JBzPwSSrDG-tUHAbcKB678HRbjLpD-ohzbzzO62mgpo,20114
-sourcecode/cli.py,sha256=5_80ItmEER0L6udbjLBZ3NbDH-oG7-bE8rusLe1dLEo,528213
+sourcecode/cli.py,sha256=yUCVp8xLvSIieX417jnIPJq-Tc_W5ThDle6V3El_Gxk,530346
 sourcecode/client_calls.py,sha256=daRTgbXNUOfkzGXJpVb6A737R_Thhka8vw1_YgxCaLg,13548
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
 sourcecode/compare.py,sha256=xq3zsqAOAw4AWkoD9khb9xDP_O3KvwqO9k-pf8sbi3g,10951
@@ -79,9 +79,9 @@ sourcecode/perf.py,sha256=2YlJTXjyur1S7hecOMz_joUHAXE5bkcZ85a_LXBEcHQ,13931
 sourcecode/pipe_contract.py,sha256=PML0Er5d8uDyec4OrdUXuyqHbGPUYndjeaKUjkFz2u4,8369
 sourcecode/posture.py,sha256=VWnUjqmWp4Koa43dzhonaSvAgMqbOwqaMKCg4ITbgIc,76194
 sourcecode/pr_comment_renderer.py,sha256=239PmJdf95av_ZW236C7_tvq_ahECeuF9AZxrheJ4OQ,15573
-sourcecode/pr_impact.py,sha256=eaFgcPMDsjaF8VZvcitFWCPCabMTi-khtGdxpK0wXTQ,22461
+sourcecode/pr_impact.py,sha256=b315e2ZCRihuw23EXxHIJll1hDs7M2CZTczrZwAxGFQ,24044
 sourcecode/prepare_context.py,sha256=B8TiBQbazxUOz6D37Dt9zqbOtD5b2S_fR3MB15P9DrI,237206
-sourcecode/progress.py,sha256=hbOPMSNMfoHYS-BL1HAH0VAQFR4u3TzWq0oJdeAPdjM,3921
+sourcecode/progress.py,sha256=In9yXx-WOXLVkj_jxu_ae2_4bABHnhj4nWg4KvetfHM,7921
 sourcecode/provenance.py,sha256=gLbsLv0gze7k7ChM4i5M3MwKfFPzs8wzM72rUd2C5sM,7342
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
 sourcecode/readiness_timeline.py,sha256=qqc14vL9nj9E4qw4bVZpGhfMLaVaYr9s6Pak_VUIwt0,8008
@@ -93,7 +93,7 @@ sourcecode/relevance_scorer.py,sha256=0AgEt4KrV73nioMqBgjhGjtY7L2C7L7cSyKtj3IKcr
 sourcecode/remedies.py,sha256=8lgvKkW1WuBG-QfTnA0uBhEKnwWGSvgSMWCfTjzYhEY,6516
 sourcecode/rename_refactor.py,sha256=h6dNFlB9aZ_3q6heeHBkgXQeXaT03nvPSsYH6P8qxFg,12965
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
-sourcecode/repository_ir.py,sha256=UdA13zDUvhgZvdUt8BIbfHOXi40OkdvqtpMJG7hYkms,358320
+sourcecode/repository_ir.py,sha256=zCQAZ-SfkbXcgNJJGX5Tv-Z5c2DFTE4GoyzAUitBx48,359936
 sourcecode/ris.py,sha256=SjjDNMcc9Zr9us9G8ikBVkoPXKK3BpM-dBodSGMh_g4,24783
 sourcecode/risk.py,sha256=UgTVdMc8XBArO6D9e2Xx9I-kKqx-PW4W0hSe1Jy9qjU,54491
 sourcecode/rule_catalog.py,sha256=xmphuULUCtg_GWTbriwY25D-N2IaeMXXvB5CNU1xSuA,4925
@@ -103,7 +103,7 @@ sourcecode/sarif.py,sha256=3hQEegUxIZbojFdY59oB-yKsK-rnafHdTNmYsEP2--A,25984
 sourcecode/scanner.py,sha256=z3CV0rcGunu0Y8mpNgp07wI7nxT0pxw1BkXRRtI0Rpo,9609
 sourcecode/schema.py,sha256=aHNXDf8LGyUC8ZDE_VS9kiskC2-Oswhi_WnpdGy6HDw,24897
 sourcecode/security_config.py,sha256=KblMEoRiEjrIE68YsPaUAFebxFp8UM7MS7lAk5CGD8U,3531
-sourcecode/security_config_scan.py,sha256=RDxBNm7oVdAaY6gbQgeA2FjHy2pVc6MPRnrBwTnASqY,27247
+sourcecode/security_config_scan.py,sha256=m146K51cA9g9wPRwloLSalHAk0qaEybGj_h0bSO4acQ,27916
 sourcecode/security_posture.py,sha256=CjJ2Qm87HhKXepnaWx1ncJLW-SxI18udCmUDIkCyAsY,50270
 sourcecode/semantic_analyzer.py,sha256=bpgdC6m0_ftVtRf3rSdwhbhWjnZnGxRXaZVcfe4BbcQ,95414
 sourcecode/semantic_impact_engine.py,sha256=t09IirGC3JjQDy33JZd1_WKzQVKXkoNl3-XEUr5kjis,20563
@@ -125,6 +125,7 @@ sourcecode/summarizer.py,sha256=0aD4x3vgPngqBCEBKGuES1J2Vk5f7mqCm_ZWErwm3js,2702
 sourcecode/target_admission.py,sha256=wFZ4pzlxhiF6Q6s2lEAZEzcCfj1Y6xNvujjt8MdO0Qo,7154
 sourcecode/test_gap_ranking.py,sha256=hl-tTyQUXZGJycG1b6npbLeE_DaVHaOsvPwG9qqC5y8,15711
 sourcecode/test_sources.py,sha256=6qXI47rVt_DFEbziFUyU-_KIUIGt8YQ5Uf4-sdiAhKU,9277
+sourcecode/text_input.py,sha256=3pL8DxR_DMI3ece-B70DnppvrEaLh4R17Pp8dK9G_hc,3596
 sourcecode/token_estimate.py,sha256=G-ivzIJfVq5TLQN04dC0WK4LZJjWVYL54Ebcxe4fJ7M,9268
 sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/type_usage_surface.py,sha256=51IrKRQoIoRnlsiDjHnqpJBn2rc6E59aRhgS0HTzAF0,4428
@@ -193,8 +194,8 @@ sourcecode/telemetry/consent.py,sha256=pQdl-QeLl6Gcibn0eWHSKZrm-HYSsjpVqOnjrgFp8
 sourcecode/telemetry/events.py,sha256=4_yeO58U-Cwc1Qb27VB0_EjhmroY0k91n3_VGxeALB8,2776
 sourcecode/telemetry/filters.py,sha256=RzxauTz8HliO4BllQnXEXc7zTeqdCZi5MgqGEDuW7OQ,6570
 sourcecode/telemetry/transport.py,sha256=4gGHsq0WeY9VywEZXA3vUxykfiYnw9uuqfjAAec7F8o,1681
-sourcecode-4.10.4.dist-info/METADATA,sha256=kDEJYN6SFhGKasJ12BhdsBF7yyoDst5XmkNscJCfFb4,36660
-sourcecode-4.10.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-4.10.4.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
-sourcecode-4.10.4.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-4.10.4.dist-info/RECORD,,
+sourcecode-4.10.5.dist-info/METADATA,sha256=YVaP0d14yBclh0t3bccUj_lbJOuaI7cFJbWzotlts7g,36660
+sourcecode-4.10.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-4.10.5.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-4.10.5.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-4.10.5.dist-info/RECORD,,