Blame for code/vera/references.py

"""Pre-staged references and tested reference-grade computation for agents.

The motivating claim here was originally that the sandbox blocks reference downloads.
That was measured on one transcript and it is **false**. Across every transcript we have,
39 attempted a reference fetch and they succeed: a 939 MB `hg38.fa` arrives, `bwa index`
completes, `bwa mem` reports `Processed 533334 reads`, and 21 runs produce a sorted BAM.
`Errno 101` appears exactly once. Agents can obtain and index references.

What they get wrong is the statistic computed *from* the alignment. On the Cas9 problem
the baseline built minimap2 from source, indexed hg38, aligned the full library and stated
the correct plan itself -- rank loci by clusters of soft-clipped fragments, because a
nuclease cut gives a sharp breakpoint peak. It then wrote that analysis in awk as

    if(c ~ /^[0-9]+S/) L[$4]++;        # leading clip: junction at POS      -- correct
    if(c ~ /[0-9]+S$/) R[$4+ref]++;    # trailing clip: POS+ref             -- off by one

The last aligned base is POS + ref - 1. Its measurement therefore said left-clips at
46,373,178 and right-clips at 46,373,179, it read that as a cut between them, and its
independent PAM calculation also said 179. Two errors agreed, so neither was caught, and
the run reported a confident wrong coordinate.

So staging a genome is a convenience. The contribution is a *tested* implementation of the
computation the agent already knows it wants, rather than one re-derived in awk under a
step budget where an off-by-one is invisible. `vera/breakpoints.py` carries a registered
mutation for this exact defect.
"""

from __future__ import annotations

import os
import shutil
import subprocess
from dataclasses import dataclass
from pathlib import Path

# Roots searched for a staged reference, most specific first. Extend rather than edit:
# an unreachable entry is skipped, so listing several machines is harmless.
REFERENCE_ROOTS = (
    Path(os.environ.get("VERA_REFERENCE_ROOT", "/extra/zhanglab1/pengchx3")),
    Path("/srv/disk00/sshfs/pengchx3"),
    Path("/tmp/galaxy_srv_disk00/pengchx3"),
)


@dataclass(frozen=True)
class Reference:
    """One staged reference genome or transcriptome.

    Attributes:
        key: Short name used by callers.
        relpath: Location under a reference root.
        fasta: Filename of the sequence file within that directory.
        aligner: Which aligner's index is expected alongside it.
        note: What questions this reference can answer.
    """

    key: str
    relpath: str
    fasta: str
    aligners: tuple[str, ...]
    note: str

    @property
    def aligner(self) -> str:
        """The preferred aligner. Kept so callers that expect one name still work."""
        return self.aligners[0]


REFERENCES: dict[str, Reference] = {
    "hg38": Reference(
        key="hg38", relpath="hg38", fasta="hg38.fa", aligners=("minimap2", "bwa"),
        note="human genome; exact coordinates, split reads, on-target site location",
    ),
    "hg38-ml": Reference(
        key="hg38-ml", relpath="caduceus_hg38", fasta="hg38.ml.fa",
        aligners=("minimap2", "bwa"),
        note="human genome, alternative staging",
    ),
}

# Absolute fallbacks for binaries that may not be on an agent's PATH. The agent's shell
# inherits whatever the harness set and commonly activates its own conda environment
# mid-run, so `which` alone is not a reliable answer to "is this installed".
KNOWN_BINARIES: dict[str, tuple[str, ...]] = {
    "minimap2": ("/home/pengchx3/miniconda/bin/minimap2",),
    "samtools": ("/usr/bin/samtools", "/home/pengchx3/miniconda/bin/samtools"),
    "bwa": ("/extra/zhanglab0/INDV/pengchx3/Biomni/biomni_env/biomni_tools/bin/bwa",),
}


def find_binary(name: str) -> str | None:
    """Locate an executable on PATH, falling back to known absolute locations."""
    found = shutil.which(name)
    if found:
        return found
    for candidate in KNOWN_BINARIES.get(name, ()):
        if os.access(candidate, os.X_OK):
            return candidate
    return None


def index_files(fasta: Path, aligner: str) -> tuple[Path, ...]:
    """Index files an aligner needs beside `fasta`.

    minimap2 can align straight from a FASTA, but building a human index costs minutes
    and about 11 GB every call, so a prebuilt `.sr.mmi` is treated as required. The
    suffix records the preset: an index built for one preset misaligns under another.
    """
    if aligner == "bwa":
        return tuple(fasta.with_name(fasta.name + s)
                     for s in (".amb", ".ann", ".bwt", ".pac", ".sa"))
    if aligner == "minimap2":
        return (fasta.with_suffix(".sr.mmi"),)
    return ()


def find_reference(key: str) -> Path | None:
    """Locate a staged reference, or None.

    Raises:
        KeyError: If `key` is not registered, so a typo fails loudly rather than being
            reported as a missing reference.
    """
    spec = REFERENCES[key]
    for root in REFERENCE_ROOTS:
        candidate = root / spec.relpath / spec.fasta
        try:
            if candidate.is_file():
                return candidate
        except OSError:
            # A stale network mount raises here rather than returning False; probing the
            # next root is the point of the loop.
            continue
    return None


def has_index(fasta: Path, aligner: str = "bwa") -> bool:
    """Whether an aligner index sits alongside `fasta`.

    Checked because building one for a human genome takes roughly an hour, far beyond an
    agent's step budget -- an unindexed reference is not usable inside a run, and saying
    so is more useful than letting the agent discover it slowly.
    """
    needed = index_files(fasta, aligner)
    return bool(needed) and all(p.exists() for p in needed)


def usable_aligners(fasta: Path, spec: Reference) -> list[str]:
    """Aligners that are both installed here and indexed against `fasta`."""
    return [name for name in spec.aligners
            if find_binary(name) is not None and has_index(fasta, name)]


def aligner_target(fasta: Path, aligner: str) -> Path:
    """What to hand the aligner: bwa reads the FASTA, minimap2 reads its own index."""
    return index_files(fasta, aligner)[0] if aligner == "minimap2" else fasta


def available() -> list[dict]:
    """Every registered reference, with whether it is staged and indexed."""
    out = []
    for spec in REFERENCES.values():
        path = find_reference(spec.key)
        usable = usable_aligners(path, spec) if path else []
        out.append({"key": spec.key, "note": spec.note,
                    "staged": path is not None,
                    "indexed": bool(path and any(has_index(path, a)
                                                 for a in spec.aligners)),
                    "aligners": usable,
                    "path": str(path) if path else ""})
    return out


def align_reads(fastq: Path, reference: str = "hg38", *, n_reads: int = 20_000,
                threads: int = 4, timeout: int = 1800) -> dict:
    """Align a head sample of reads to a staged reference and summarise where they land.

    Args:
        fastq: Reads, gzipped or plain.
        reference: Registry key.
        n_reads: Reads to take from the head. Bounded because the point is to locate
            signal, not to produce a publication-grade alignment, and an agent cannot
            wait for a full library.
        threads: Aligner threads.
        timeout: Wall clock, seconds.

    Returns:
        ``{"reference": path, "n_reads": int, "mapped": int, "top_loci": [...]}`` where
        loci are ``(chrom, position_bin, count)`` ordered by count.

    Raises:
        RuntimeError: If the reference is not staged or indexed, or the aligner is
            missing, naming which -- an agent cannot fix any of these from inside the
            sandbox, so a precise message is the useful failure.
    """
    path, spec, aligner, binary = resolve(reference)

    head = fastq.with_suffix(".head.fq")
    reader = "zcat" if fastq.suffix == ".gz" else "cat"
    subprocess.run(f"{reader} {fastq} | head -n {n_reads * 4} > {head}",
                   shell=True, check=False, timeout=timeout)
    try:
        proc = subprocess.run(align_command(aligner, binary, path, [head], threads),
                              capture_output=True, text=True, errors="replace",
                              timeout=timeout)
        loci: dict[tuple[str, int], int] = {}
        mapped = 0
        for line in proc.stdout.splitlines():
            if line.startswith("@"):
                continue
            parts = line.split("\t")
            if len(parts) < 4 or parts[2] == "*":
                continue
            mapped += 1
            try:
                # 1 kb bins: enough to localise a site without pretending to base accuracy.
                loci[(parts[2], int(parts[3]) // 1000)] = \
                    loci.get((parts[2], int(parts[3]) // 1000), 0) + 1
            except ValueError:
                continue
        top = sorted(loci.items(), key=lambda kv: -kv[1])[:15]
        return {"reference": str(path), "n_reads": n_reads, "mapped": mapped,
                "top_loci": [{"chrom": c, "start": b * 1000, "reads": n}
                             for (c, b), n in top]}
    finally:
        head.unlink(missing_ok=True)


def resolve(reference: str) -> tuple[Path, Reference, str, str]:
    """Locate a staged, indexed, installed reference/aligner pair.

    Returns:
        ``(fasta, spec, aligner_name, aligner_binary)``.

    Raises:
        RuntimeError: Naming which of the three preconditions failed. An agent cannot
            fix any of them from inside the sandbox, so a precise message is the useful
            failure -- and "bwa is missing" once reached a nine-minute alignment before
            failing inside a pipe, which is what naming it early prevents.
    """
    path = find_reference(reference)
    if path is None:
        raise RuntimeError(f"reference {reference!r} is not staged on this machine")
    spec = REFERENCES[reference]
    usable = usable_aligners(path, spec)
    if not usable:
        installed = [a for a in spec.aligners if find_binary(a)]
        if not installed:
            raise RuntimeError(f"none of {', '.join(spec.aligners)} is installed")
        raise RuntimeError(
            f"reference {reference!r} has no index for {', '.join(installed)}; "
            f"building one exceeds an agent's budget")
    aligner = usable[0]
    return path, spec, aligner, find_binary(aligner)


def align_command(aligner: str, binary: str, fasta: Path, fastqs: list[Path],
                  threads: int) -> list[str]:
    """The argv that aligns `fastqs`, writing SAM to stdout."""
    target = str(aligner_target(fasta, aligner))
    reads = [str(f) for f in fastqs]
    if aligner == "minimap2":
        return [binary, "-ax", "sr", "-t", str(threads), target, *reads]
    if aligner == "bwa":
        return [binary, "mem", "-t", str(threads), target, *reads]
    raise RuntimeError(f"no command known for aligner {aligner!r}")


def align_to_bam(fastqs: list[Path], reference: str = "hg38-ml", *, threads: int = 8,
                 workdir: Path | None = None, timeout: int = 7200) -> Path:
    """Align a whole library to a staged reference, returning a sorted, indexed BAM.

    Unlike `align_reads`, this does not subsample: base-resolution questions -- an exact
    cut coordinate, a fusion junction -- are answered by a pile of reads agreeing on one
    base, and a head sample of a whole-genome library will not contain that pile.

    An existing BAM is reused, so an agent that asks a second question of the same reads
    pays the alignment once.

    Raises:
        RuntimeError: If the reference, its index, samtools or the aligner is missing,
            naming which; or if the aligner fails, quoting its stderr.
    """
    fasta, _spec, aligner, binary = resolve(reference)
    samtools = find_binary("samtools")
    if samtools is None:
        raise RuntimeError("samtools is not installed")
    reads = [Path(f) for f in fastqs]
    for f in reads:
        if not f.is_file():
            raise RuntimeError(f"no such reads file: {f}")

    work = Path(workdir or os.environ.get("VERA_WORK") or reads[0].parent / ".vera_align")
    work.mkdir(parents=True, exist_ok=True)
    stem = "_".join(f.stem for f in reads)[:80]
    bam = work / f"{stem}.{reference}.bam"
    if bam.exists() and (bam.with_suffix(".bam.bai")).exists():
        return bam

    cmd = align_command(aligner, binary, fasta, reads, threads)
    sort = [samtools, "sort", "-@", "2", "-m", "1G", "-o", str(bam), "-"]
    with subprocess.Popen(cmd, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE) as aln:
        proc = subprocess.run(sort, stdin=aln.stdout, capture_output=True, text=True,
                              errors="replace", timeout=timeout)
        aln.stdout.close()
        err = (aln.stderr.read() or b"").decode("utf-8", "replace")
        aln.wait()
    if proc.returncode != 0 or not bam.exists() or bam.stat().st_size == 0:
        bam.unlink(missing_ok=True)
        raise RuntimeError(f"{aligner} failed: {(err or proc.stderr)[-400:]}")
    subprocess.run([samtools, "index", "-@", "2", str(bam)], check=True, timeout=1800)
    return bam