crapkit 0.2.0__py3-none-any.whl

crapkit/__init__.py

@@ -0,0 +1,2 @@
+"""crapkit: deterministic CRAP-score framework."""
+__version__ = "0.2.0"

crapkit/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

crapkit/_pygdefer.py

@@ -0,0 +1,86 @@
+"""Keep pygments out of a crapkit process that will never parse Erlang.
+
+lizard imports every reader it ships, and `lizard_languages/erlang.py` binds
+pygments at module scope — so `import lizard` drags in pygments, and behind it
+importlib.metadata, email, zipfile and socket. Measured on this box: 42ms with
+pygments, 16ms without, paid by every process that touches the analysis stack,
+the pre-commit hook included.
+
+crapkit analyzes five languages (typescript, tsx, javascript, python, swift).
+Erlang is not one of them and no scope can name it. The readers that need
+pygments are still SHIPPED, not removed: `deferred_pygments()` puts proxies in
+sys.modules for the duration of the lizard import, so the readers bind stand-ins
+and the real package loads the first time anything reads or calls one. An .erl
+file analyzed through lizard directly gets the same answer; it just pays the
+import at that moment.
+
+Nothing is installed once pygments is already imported: a consumer that wanted
+it keeps the module it loaded.
+"""
+from __future__ import annotations
+
+import importlib
+import sys
+import types
+from contextlib import contextmanager
+
+_NAMES = ("pygments", "pygments.token", "pygments.lexers")
+
+
+def _evict() -> None:
+    """Drop the proxies so importlib loads the real modules underneath them."""
+    for name in _NAMES:
+        if isinstance(sys.modules.get(name), (_Proxy, _LazyCallable)):
+            del sys.modules[name]
+
+
+class _LazyCallable:
+    """A pygments function bound by `from pygments import lex` before it exists."""
+
+    def __init__(self, module: str, attr: str) -> None:
+        self._module, self._attr = module, attr
+
+    def __call__(self, *args, **kwargs):
+        _evict()
+        return getattr(importlib.import_module(self._module), self._attr)(*args, **kwargs)
+
+
+class _Proxy(types.ModuleType):
+    """Stands in for a pygments module until something actually reads it."""
+
+    def __getattr__(self, attr: str):
+        if attr.startswith("__"):
+            raise AttributeError(attr)
+        _evict()
+        return getattr(importlib.import_module(self.__name__), attr)
+
+
+def _install() -> bool:
+    """Proxy the three names lizard's Erlang reader binds. False when pygments
+    is already loaded, which leaves the real module exactly where it is."""
+    if "pygments" in sys.modules:
+        return False
+    stubs = {name: _Proxy(name) for name in _NAMES}
+    stubs["pygments"].token = stubs["pygments.token"]
+    stubs["pygments"].lexers = stubs["pygments.lexers"]
+    stubs["pygments"].lex = _LazyCallable("pygments", "lex")
+    sys.modules.update(stubs)
+    return True
+
+
+@contextmanager
+def deferred_pygments():
+    """Import lizard inside this: its readers bind the proxies, and the proxies
+    come straight back out of sys.modules afterwards.
+
+    Taking them out is the part that matters for anything but speed. A module
+    left in sys.modules with no __path__ breaks the next `import
+    pygments.formatters` a process makes; only the readers that already bound a
+    proxy keep one, and each resolves itself on first use.
+    """
+    installed = _install()
+    try:
+        yield
+    finally:
+        if installed:
+            _evict()

crapkit/analyze.py

@@ -0,0 +1,375 @@
+"""Analysis shell: run lizard once over explicit file lists and read both ccn columns off it.
+
+Lizard is always fed explicit files, never directories: its own walker descends
+nested node_modules (measured hang on the first consumer repo).
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import time
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+
+from ._pygdefer import deferred_pygments
+
+with deferred_pygments():  # lizard's Erlang reader would load pygments here
+    import lizard
+
+from .cache import partition_by_cache, updated_cache
+from .errors import ToolError
+from .lizardcognitive import LizardExtension as _Cognitive
+from .merge import FunctionRecord
+
+_POOL_THRESHOLD = 16
+
+# Bump whenever analysis semantics change (merge rules, extension set, record
+# extraction): the fingerprint must invalidate cached records produced by older
+# logic even when file content and tool versions are identical.
+ANALYSIS_VERSION = 3  # 3: cognitive complexity column joined the standard pass
+
+# The three tokens lizard's modified rule reacts to. Membership is checked before
+# anything else runs, so the common token pays one frozenset lookup.
+_SWITCH_TOKENS = frozenset({"switch", "match", "case"})
+
+
+def _switch_delta(token: str, reader) -> int:
+    """+1 for a switch-like block opener, -1 for one of its arms.
+
+    `match` and `case` are soft keywords in Python: the same spelling is an
+    identifier elsewhere, so the reader's own flags decide, exactly as lizard's
+    modified extension decides.
+    """
+    if token == "case":
+        return -int("case" in reader.conditions or getattr(reader, "_keyword_case", False))
+    if token == "switch":
+        return 1
+    return int(getattr(reader, "_keyword_match", False))
+
+
+class _ModifiedDelta:
+    """ccn_mod minus ccn_std, counted inside the standard pass.
+
+    lizard's modified extension does one thing: add_condition(+1) on a
+    switch/match opener and add_condition(-1) on each arm. It filters no tokens
+    and reads nothing else, so the two columns differ by that sum and by nothing
+    else, which made the second full tokenization of every file pure waste.
+    """
+
+    FUNCTION_INFO = {"modified_delta": {"caption": " Mod "}}
+
+    def __call__(self, tokens, reader):
+        context = reader.context
+        for token in tokens:
+            if token in _SWITCH_TOKENS:
+                fn = context.current_function
+                delta = _switch_delta(token, reader)
+                fn.modified_delta = getattr(fn, "modified_delta", 0) + delta
+            yield token
+
+
+# Built once per process, not once per file: 14k files paid 14k chain builds.
+# Every extension in it keeps its state in the generator frame __call__ opens,
+# so one chain serves every file. Cognitive comes FIRST because lizard's own
+# preprocessors strip the whitespace tokens its python rules read; the delta
+# comes last, where the modified pass used to sit.
+_EXTENSIONS = [_Cognitive()] + lizard.get_extensions(["ND"]) + [_ModifiedDelta()]
+
+
+def _record(rel_path: str, fn) -> FunctionRecord:
+    std = fn.cyclomatic_complexity
+    mod = std + (getattr(fn, "modified_delta", 0) or 0)
+    return FunctionRecord(
+        path=rel_path,
+        long_name=fn.long_name,
+        start=fn.start_line,
+        end=fn.end_line,
+        ccn_std=std,
+        ccn_mod=mod,
+        ccn=min(std, mod),
+        nloc=fn.nloc,
+        params=len(fn.parameters),
+        nesting=getattr(fn, "max_nesting_depth", 0) or 0,
+        cognitive=getattr(fn, "cognitive_complexity", 0) or 0,
+    )
+
+
+def analyze_one(args: tuple[str, str]) -> tuple[str, list[FunctionRecord]]:
+    abs_path, rel_path = args
+    try:
+        analysis = lizard.FileAnalyzer(_EXTENSIONS)(abs_path)
+        return rel_path, [_record(rel_path, fn) for fn in analysis.function_list]
+    except Exception as exc:  # loud, with the file named
+        raise ToolError(f"lizard failed on {rel_path}: {exc}") from exc
+
+
+def analyze_source(rel_path: str, code: str) -> list[FunctionRecord]:
+    """The records analyze_one would produce for a file holding `code`.
+
+    analyze_source_code is what FileAnalyzer.__call__ runs once it has read the
+    file, so nothing about the analysis depends on whether the source arrived
+    from the disk or from a git blob the caller already holds; rel_path picks
+    the language exactly as the path on disk did.
+    """
+    try:
+        analysis = lizard.FileAnalyzer(_EXTENSIONS).analyze_source_code(rel_path, code)
+        return [_record(rel_path, fn) for fn in analysis.function_list]
+    except Exception as exc:  # loud, with the file named
+        raise ToolError(f"lizard failed on {rel_path}: {exc}") from exc
+
+
+def content_hash(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def fingerprint() -> str:
+    from . import __version__
+    return f"crapkit={__version__};analysis={ANALYSIS_VERSION};lizard={lizard.version}"
+
+
+def _drained_records(entries: dict) -> dict[str, list[FunctionRecord]]:
+    """Turn parsed rows into records, freeing each row list as it is consumed.
+
+    A comprehension over `entries` would hold the whole parsed list-of-lists
+    alongside the records built from it; on a large corpus that doubling is tens
+    of MB for no reason. Draining leaves the caller's parsed dict empty, which is
+    fine: nothing reads it afterwards.
+    """
+    records: dict[str, list[FunctionRecord]] = {}
+    while entries:
+        h, rows = entries.popitem()
+        records[h] = [FunctionRecord(*vals) for vals in rows]
+    return records
+
+
+def load_cache(path: Path) -> dict:
+    """A cache is disposable: corrupt or truncated content reads as cold, never as a crash.
+
+    save_cache is not atomic, so a killed process can leave a torn file; the
+    cache keys on raw bytes, so cross-machine line-ending settings just miss.
+    """
+    if not path.is_file():
+        return {}
+    try:
+        with path.open(encoding="utf-8") as fh:
+            raw = json.load(fh)
+        return {"fp": raw.get("fp"), "entries": _drained_records(raw.get("entries", {}))}
+    except (json.JSONDecodeError, OSError, TypeError, ValueError):
+        return {}
+
+
+def save_cache(path: Path, cache: dict, *, prior: dict | None = None) -> None:
+    """Rewrite the cache file, unless `prior` says the bytes would not move.
+
+    Callers hand back what load_cache gave them. A fully-warm run rebuilds an
+    entry map equal to the one already on disk, and serializing it is the most
+    expensive thing such a run does; equal maps serialize identically because
+    the dump sorts its keys.
+    """
+    if cache == prior:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8", newline="") as fh:
+        _write_entries(fh, cache["entries"])
+        fh.write(f", {json.dumps('fp')}: {json.dumps(cache['fp'])}}}")
+
+
+def _write_entries(fh, entries: dict) -> None:
+    """The `entries` object, one entry serialized at a time.
+
+    Byte-for-byte what json.dumps(document, sort_keys=True) wrote: keys sorted,
+    the two-character separators json uses by default, and `entries` ahead of
+    `fp` because sorted keys put it there. Building the document first meant the
+    rebuilt lists, the whole 18.6 MB string and its encoding were all live at
+    once; this way one entry is.
+    """
+    fh.write('{"entries": {')
+    lead = ""
+    for h in sorted(entries):
+        fh.write(f"{lead}{json.dumps(h)}: {json.dumps([list(r) for r in entries[h]])}")
+        lead = ", "
+    fh.write("}")
+
+
+_STAMPS_NAME = "stat-stamps.json"
+
+# A stamp is only recorded once the file has held still this long. Windows moves
+# a file time on a ~15 ms clock tick, so two writes inside one tick can land on
+# one mtime; a file written moments ago is not evidence that it is unchanged.
+_STAMP_SETTLE_NS = 2_000_000_000
+
+
+def _stamps_path(root: Path) -> Path:
+    return root / ".crapkit" / _STAMPS_NAME
+
+
+def _load_stamps(path: Path) -> dict:
+    """rel path -> [mtime_ns, size, content hash], or nothing at all.
+
+    An index of what the last run saw. Disposable exactly like the analysis
+    cache: unreadable, torn, or written by another format reads as no index,
+    which costs a full hashing pass and never a wrong answer.
+    """
+    try:
+        with path.open(encoding="utf-8") as fh:
+            raw = json.load(fh)
+        return raw["stamps"] if raw.get("v") == 1 else {}
+    except (json.JSONDecodeError, OSError, TypeError, ValueError, KeyError, AttributeError):
+        return {}
+
+
+def _save_stamps(path: Path, stamps: dict, prior: dict) -> None:
+    if stamps == prior:
+        return
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps({"v": 1, "stamps": stamps}, sort_keys=True), encoding="utf-8")
+    except OSError:
+        pass  # an index nobody can write is a slower run, never a failed one
+
+
+def _stat_of(path: Path) -> tuple[int, int] | None:
+    try:
+        st = path.stat()
+    except OSError:
+        return None
+    return st.st_mtime_ns, st.st_size
+
+
+def _unmoved(stat: tuple[int, int] | None, prior) -> bool:
+    """True when this file's stat is exactly what it was when we hashed it."""
+    return bool(prior) and stat is not None and stat[0] == prior[0] and stat[1] == prior[1]
+
+
+def _stamp(fresh: dict, rel: str, stat: tuple[int, int] | None, digest: str, now: int) -> None:
+    if stat is not None and now - stat[0] >= _STAMP_SETTLE_NS:
+        fresh[rel] = [stat[0], stat[1], digest]
+
+
+def _hash_paths(root: Path, rel_paths: list[str], stamps: dict) -> tuple[dict[str, str], dict]:
+    """Content hash per path, plus the stat index the next run should keep.
+
+    The cache keys are content hashes and stay content hashes; (mtime_ns, size)
+    only decides whether a hash has to be recomputed. A file that has not moved
+    since the run that hashed it keeps that hash without being opened, which is
+    the difference between reading 14k files and stat-ing them.
+
+    Its one blind spot: content rewritten to the same length under a deliberately
+    restored mtime. Any real write moves the mtime, and a write too close to the
+    last one is refused a stamp, so the next genuine change corrects it.
+    """
+    now = time.time_ns()
+    hashes: dict[str, str] = {}
+    fresh: dict = {}
+    for rel in rel_paths:
+        stat = _stat_of(root / rel)
+        prior = stamps.get(rel)
+        hashes[rel] = prior[2] if _unmoved(stat, prior) else content_hash(root / rel)
+        _stamp(fresh, rel, stat, hashes[rel], now)
+    return hashes, fresh
+
+
+def _kept_stamps(prior: dict, fresh: dict, visited: set) -> dict:
+    """Paths this run looked at are described by this run alone: a file too
+    recently written to stamp must not keep an older run's stamp. Paths it never
+    looked at keep theirs, or a rescore of four files would blind the next
+    inventory of fourteen thousand."""
+    kept = {rel: stamp for rel, stamp in prior.items() if rel not in visited}
+    kept.update(fresh)
+    return kept
+
+
+def _restamped(hits: dict[str, list[FunctionRecord]]) -> dict[str, list[FunctionRecord]]:
+    # A cache entry keys on content only; re-stamp the path so a moved file cannot
+    # carry its old location into the snapshot. Almost nothing moves between two
+    # runs, and rebuilding 140k namedtuples to write back the path they already
+    # hold is the most expensive thing a fully-warm run does.
+    return {path: _rows_for(path, rows) for path, rows in hits.items()}
+
+
+def _rows_for(path: str, rows: list[FunctionRecord]) -> list[FunctionRecord]:
+    """One entry's rows all carry one path, because analyze_one stamps every
+    record it emits with the single path it was handed. The first row answers
+    for all of them."""
+    if rows and rows[0].path == path:
+        return rows
+    return [r._replace(path=path) for r in rows]
+
+
+_MEMORY_BUDGET_ENV = "CRAPKIT_ANALYSIS_MEMORY_MB"
+
+# Measured peak RSS of one analysis worker over the consumer repo: 24 workers reached
+# 807 MB of tree RSS, the biggest child 47 MB, the median child 35 MB.
+_WORKER_PEAK_MB = 35
+
+
+def _memory_budget_mb() -> int | None:
+    """The budget in MB, or None when it is unset or not a positive whole number.
+
+    A mistyped knob must not silently serialize a run: unreadable reads as absent.
+    """
+    raw = os.environ.get(_MEMORY_BUDGET_ENV, "").strip()
+    if not raw.isdigit() or raw == "0":
+        return None
+    return int(raw)
+
+
+def _memory_bounded(workers: int | None) -> int | None:
+    """The worker count, capped by CRAPKIT_ANALYSIS_MEMORY_MB when it is set.
+
+    Off by default: no budget means one worker per core, as before. Cold over
+    the consumer repo, 24 workers peak at 807 MB in 11.8 s and 16 at 565 MB in 14.2 s, so
+    a box short of memory can buy 242 MB back for 2.4 s. Never returns zero
+    workers: a budget smaller than one worker still gets one.
+    """
+    budget = _memory_budget_mb()
+    if budget is None:
+        return workers
+    return min(workers or os.cpu_count() or 1, max(1, budget // _WORKER_PEAK_MB))
+
+
+def analyze_jobs(
+    jobs: list[tuple[str, str]],
+    *,
+    workers: int | None = None,
+    pool_threshold: int = _POOL_THRESHOLD,
+    chunksize: int = 32,
+) -> dict[str, list[FunctionRecord]]:
+    """Run lizard over (abs_path, rel_path) jobs, pooled once there are enough.
+
+    The two knobs exist because the inventory and the pre-commit hook sit at
+    different scales: an inventory feeds thousands of files and wants fat
+    chunks, a hook feeds a commit's worth and needs each job dealt to a
+    different worker (a chunksize above the job count leaves one worker doing
+    all of them, serially, after paying for the pool).
+    """
+    fresh: dict[str, list[FunctionRecord]] = {}
+    if len(jobs) >= pool_threshold:
+        with ProcessPoolExecutor(max_workers=_memory_bounded(workers)) as pool:
+            for rel_path, records in pool.map(analyze_one, jobs, chunksize=chunksize):
+                fresh[rel_path] = records
+        return fresh
+    for job in jobs:
+        rel_path, records = analyze_one(job)
+        fresh[rel_path] = records
+    return fresh
+
+
+def analyze_files(
+    root: Path, rel_paths: list[str], *, cache: dict, workers: int | None = None
+) -> tuple[dict[str, list[FunctionRecord]], int, dict]:
+    fp = fingerprint()
+    stamps_path = _stamps_path(root)
+    prior_stamps = _load_stamps(stamps_path)
+    hashes, fresh_stamps = _hash_paths(root, rel_paths, prior_stamps)
+    kept = _kept_stamps(prior_stamps, fresh_stamps, set(rel_paths))
+    _save_stamps(stamps_path, kept, prior_stamps)
+    hits, misses = partition_by_cache(hashes, cache, fingerprint=fp)
+    hits = _restamped(hits)
+
+    fresh = analyze_jobs([(str(root / rel), rel) for rel in misses], workers=workers)
+
+    all_records = {**hits, **fresh}
+    new_cache = updated_cache(hashes, all_records, fingerprint=fp)
+    return all_records, len(hits), new_cache

crapkit/cache.py

@@ -0,0 +1,58 @@
+"""Content-hash analysis cache. Pure partition/update; the shell owns file I/O.
+
+Keys are file content hashes, never mtimes (checkout resets mtimes). The
+fingerprint bundles everything that changes analysis output for identical
+content (lizard pin, crapkit analysis version); a fingerprint change drops
+the whole cache rather than serving stale records.
+"""
+from __future__ import annotations
+
+from .merge import FunctionRecord
+
+
+def partition_by_cache(
+    hashes: dict[str, str],
+    cache: dict,
+    *,
+    fingerprint: str,
+) -> tuple[dict[str, list[FunctionRecord]], list[str]]:
+    entries = cache.get("entries", {}) if cache.get("fp") == fingerprint else {}
+    hits: dict[str, list[FunctionRecord]] = {}
+    misses: list[str] = []
+    for path in sorted(hashes):
+        records = entries.get(hashes[path])
+        if records is None:
+            misses.append(path)
+        else:
+            hits[path] = records
+    return hits, misses
+
+
+def updated_cache(
+    hashes: dict[str, str],
+    records_by_path: dict[str, list[FunctionRecord]],
+    *,
+    fingerprint: str,
+    stale_hashes: list[str] | None = None,
+) -> dict:
+    return {
+        "fp": fingerprint,
+        "entries": {hashes[path]: records for path, records in sorted(records_by_path.items())},
+    }
+
+
+def merged_cache(prior: dict, fresh: dict) -> dict:
+    """Fold a partial run's entries into the prior map instead of replacing it.
+
+    A run that analyzed a handful of files (rescore, watch, the pre-commit hook)
+    knows nothing about the rest of the corpus, so its `entries` map is not a new
+    cache but an addition to one. Merging leaves entries for content that has
+    left the corpus behind; the whole-corpus runs (inventory, coverage) save their
+    rebuilt map without merging, and that stays the one eviction point.
+
+    A prior written under another fingerprint is not stale, it is wrong; drop it
+    exactly as partition_by_cache does.
+    """
+    fp = fresh["fp"]
+    prior_entries = prior.get("entries", {}) if prior.get("fp") == fp else {}
+    return {"fp": fp, "entries": {**prior_entries, **fresh["entries"]}}

crapkit/churn.py

@@ -0,0 +1,113 @@
+"""Per-file churn from git history. Pure parser; the shell supplies the log text.
+
+The log format is one \\x01-prefixed author line per commit followed by the
+commit's file paths (git log --format=%x01%an --name-only).
+"""
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import NamedTuple
+
+
+class FileChurn(NamedTuple):
+    commits: int
+    authors: int
+    weight: float = 0.0  # recency-weighted commit sum; commit count when untimestamped
+
+
+_SIMPLE_ESCAPES = {"n": 10, "t": 9, "r": 13, '"': 34, "\\": 92, "a": 7, "b": 8, "f": 12, "v": 11}
+
+
+def _is_quoted(line: str) -> bool:
+    return len(line) >= 2 and line.startswith('"') and line.endswith('"')
+
+
+def _escape_at(body: str, i: int) -> tuple[bytes, int]:
+    """Decode the escape starting at the backslash on `i`; return its bytes and the next index."""
+    nxt = body[i + 1] if i + 1 < len(body) else ""
+    if nxt.isdigit():
+        return bytes([int(body[i + 1:i + 4], 8)]), i + 4
+    if nxt in _SIMPLE_ESCAPES:
+        return bytes([_SIMPLE_ESCAPES[nxt]]), i + 2
+    return nxt.encode("utf-8"), i + 2
+
+
+def _unquote_git_path(line: str) -> str:
+    """Undo git's core.quotePath C-style quoting so churn keys match ls-files paths.
+
+    Quoted lines are wrapped in double quotes with backslash escapes; non-ASCII
+    bytes appear as literal octal text (\\303\\251). Decoded octal bytes are
+    UTF-8.
+    """
+    if not _is_quoted(line):
+        return line
+    body = line[1:-1]
+    out = bytearray()
+    i = 0
+    while i < len(body):
+        ch = body[i]
+        if ch != "\\":
+            out += ch.encode("utf-8")
+            i += 1
+            continue
+        chunk, i = _escape_at(body, i)
+        out += chunk
+    return out.decode("utf-8", errors="replace")
+
+
+def _twr(ts: int, oldest: int, newest: int) -> float:
+    import math
+
+    span = max(newest - oldest, 1)
+    t_norm = (ts - oldest) / span
+    return 1.0 / (1.0 + math.exp(-12.0 * t_norm + 12.0))
+
+
+def _split_author(line: str) -> tuple[str, int | None]:
+    body = line[1:]
+    if "\x02" not in body:
+        return body, None
+    name, _, raw = body.partition("\x02")
+    return name, int(raw) if raw.isdigit() else None
+
+
+def _collect(lines: Iterable[str]):
+    commits: dict[str, int] = {}
+    authors: dict[str, set[str]] = {}
+    stamps: dict[str, list[int]] = {}
+    author, ts = None, None
+    for raw in lines:
+        line = raw.strip()
+        if not line:
+            continue
+        if line.startswith("\x01"):
+            author, ts = _split_author(line)
+            continue
+        if author is None:
+            continue
+        path = _unquote_git_path(line).replace("\\", "/")
+        commits[path] = commits.get(path, 0) + 1
+        authors.setdefault(path, set()).add(author)
+        if ts is not None:
+            stamps.setdefault(path, []).append(ts)
+    return commits, authors, stamps
+
+
+def parse_git_log(text: str) -> dict[str, FileChurn]:
+    """Whole-text entrypoint: the log already in hand."""
+    return parse_git_log_lines(text.splitlines())
+
+
+def parse_git_log_lines(lines: Iterable[str]) -> dict[str, FileChurn]:
+    """Streaming entrypoint: one commit block resident at a time, whatever the log's size."""
+    commits, authors, stamps = _collect(lines)
+    all_stamps = [s for lst in stamps.values() for s in lst]
+    oldest, newest = (min(all_stamps), max(all_stamps)) if all_stamps else (0, 0)
+
+    def weight(path: str, count: int) -> float:
+        if path not in stamps:
+            return float(count)  # untimestamped log: degrade to commit count
+        return round(sum(_twr(s, oldest, newest) for s in stamps[path]), 4)
+
+    return {p: FileChurn(commits=c, authors=len(authors[p]), weight=weight(p, c))
+            for p, c in commits.items()}