autosentry 0.7.1__py3-none-any.whl

autosentry/__init__.py

@@ -0,0 +1,3 @@
+"""autosentry — self-healing sentry for long-running processes."""
+
+__version__ = "0.7.1"

autosentry/__main__.py

@@ -0,0 +1,4 @@
+from autosentry.cli import app
+
+if __name__ == "__main__":
+    app()

autosentry/_tail.py

@@ -0,0 +1,84 @@
+"""Shared "tail -F"-style file follower.
+
+Used by the SLURM and Attach supervisors. Both follow a single file
+that may not exist yet (SLURM creates it after the job starts; an
+attached process may rotate its log out from under us). The only
+behavioral difference is whether they want to *replay history* on
+first open:
+
+- SLURM wants the historical contents (the job may have been running
+  before autosentry attached its tail thread).
+- Attach wants to skip history (the watched service may have GB of
+  pre-existing log).
+
+The ``seek_to_end`` flag controls that choice.
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+from collections.abc import Callable
+from pathlib import Path
+
+from autosentry.logger import log
+
+
+def follow_file(
+    path_provider: Callable[[], Path | None],
+    *,
+    on_line: Callable[[str], None],
+    stop_event: threading.Event,
+    ready_event: threading.Event | None = None,
+    seek_to_end: bool,
+    error_tag: str,
+    missing_backoff_cap: float = 5.0,
+) -> None:
+    """Follow a file, calling ``on_line`` for each new line.
+
+    ``path_provider`` is a callable so callers can defer path resolution
+    (SLURM, for instance, only knows the path once the job has a job id).
+    Returns when ``stop_event`` is set.
+    """
+    backoff = 0.5
+    last_inode: int | None = None
+    pos = 0
+    while not stop_event.is_set():
+        path = path_provider()
+        if path is None or not path.exists():
+            time.sleep(min(backoff, missing_backoff_cap))
+            backoff = min(backoff * 1.5, missing_backoff_cap)
+            continue
+        backoff = 0.5
+        try:
+            with path.open("r", encoding="utf-8", errors="replace") as f:
+                inode = os.fstat(f.fileno()).st_ino
+                if last_inode != inode:
+                    last_inode = inode
+                    if seek_to_end:
+                        f.seek(0, 2)  # SEEK_END
+                        pos = f.tell()
+                    else:
+                        pos = 0
+                f.seek(pos)
+                if ready_event is not None:
+                    ready_event.set()
+                while not stop_event.is_set():
+                    line = f.readline()
+                    if not line:
+                        pos = f.tell()
+                        try:
+                            st = path.stat()
+                            if st.st_ino != last_inode:
+                                # File rotated; reopen.
+                                break
+                        except FileNotFoundError:
+                            break
+                        time.sleep(0.5)
+                        continue
+                    on_line(line.rstrip("\n"))
+                    pos = f.tell()
+        except OSError as e:
+            log().error(f"{error_tag} log tail error: {e}")
+            time.sleep(1)

autosentry/analyze.py

@@ -0,0 +1,174 @@
+"""``autosentry analyze`` — flat-text summary of the attempts ledger.
+
+Mirrors the spirit of autoresearch's ``analysis.ipynb`` without dragging
+Jupyter into the dep tree. Reads ``attempts.tsv`` (and optionally
+filters by ``--since``), then prints:
+
+- Top failing detectors in the window
+- Per-rule success rate (kept / total terminal attempts)
+- Current regression streaks per detector
+- Overall stats (totals, in-progress)
+"""
+
+from __future__ import annotations
+
+import re
+from collections import Counter, defaultdict
+from collections.abc import Iterable
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+
+from autosentry.ledger import Attempt
+
+# ----- time-window parsing -------------------------------------------------
+
+
+_SINCE_RE = re.compile(r"^\s*(\d+)\s*([smhd])\s*$", re.IGNORECASE)
+
+
+def parse_since(value: str | None) -> timedelta | None:
+    """Parse a window specifier like ``24h``, ``30m``, ``7d``, ``600s``.
+
+    Returns ``None`` for an empty/missing value (which means "no filter").
+    Raises :class:`ValueError` on malformed input.
+    """
+    if not value:
+        return None
+    m = _SINCE_RE.match(value)
+    if not m:
+        msg = f"bad --since value {value!r} (expected like '24h', '30m', '7d', '600s')"
+        raise ValueError(msg)
+    qty = int(m.group(1))
+    unit = m.group(2).lower()
+    return {
+        "s": timedelta(seconds=qty),
+        "m": timedelta(minutes=qty),
+        "h": timedelta(hours=qty),
+        "d": timedelta(days=qty),
+    }[unit]
+
+
+def filter_window(rows: Iterable[Attempt], window: timedelta | None) -> list[Attempt]:
+    if window is None:
+        return list(rows)
+    cutoff = datetime.now(tz=timezone.utc) - window
+    out: list[Attempt] = []
+    for r in rows:
+        try:
+            ts = datetime.fromisoformat(r.timestamp)
+        except ValueError:
+            # Tolerate bad timestamps — include them rather than drop them.
+            out.append(r)
+            continue
+        if ts.tzinfo is None:
+            ts = ts.replace(tzinfo=timezone.utc)
+        if ts >= cutoff:
+            out.append(r)
+    return out
+
+
+# ----- summary stats -------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class RuleStat:
+    source: str
+    total: int
+    kept: int
+    regressed: int
+    crashed: int
+    discarded: int
+    pending: int
+
+    @property
+    def success_rate(self) -> float:
+        terminal = self.kept + self.regressed + self.crashed + self.discarded
+        if terminal == 0:
+            return 0.0
+        return self.kept / terminal
+
+
+@dataclass(frozen=True)
+class DetectorStat:
+    detector: str
+    total: int
+    streak_status: str  # most recent terminal status
+    streak_len: int  # consecutive run of same terminal status (most recent first)
+
+
+@dataclass(frozen=True)
+class Summary:
+    total: int
+    by_status: dict[str, int]
+    top_detectors: list[tuple[str, int]]
+    rules: list[RuleStat]
+    detector_streaks: list[DetectorStat]
+
+
+def summarize(rows: Iterable[Attempt], *, top_n: int = 10) -> Summary:
+    rows = list(rows)
+    # Counter[AttemptStatus] → plain dict[str, int]; the str(...) cast keeps
+    # pyrefly happy and matches the Summary annotation.
+    by_status: dict[str, int] = {str(k): v for k, v in Counter(r.status for r in rows).items()}
+    detector_counts = Counter(r.detector for r in rows)
+
+    # Per-rule stats.
+    by_source: dict[str, Counter[str]] = defaultdict(Counter)
+    for r in rows:
+        by_source[r.source][r.status] += 1
+    rules = [
+        RuleStat(
+            source=source,
+            total=sum(statuses.values()),
+            kept=statuses.get("kept", 0),
+            regressed=statuses.get("regressed", 0),
+            crashed=statuses.get("crashed", 0),
+            discarded=statuses.get("discarded", 0),
+            pending=statuses.get("pending", 0),
+        )
+        for source, statuses in by_source.items()
+    ]
+    rules.sort(key=lambda r: r.total, reverse=True)
+
+    # Detector streaks — walk backward through rows-by-detector, count the
+    # longest run of identical terminal status at the tail.
+    by_detector: dict[str, list[Attempt]] = defaultdict(list)
+    for r in rows:
+        by_detector[r.detector].append(r)
+    streaks: list[DetectorStat] = []
+    for detector, drows in by_detector.items():
+        terminal = [r for r in drows if r.status != "pending"]
+        if not terminal:
+            streaks.append(
+                DetectorStat(
+                    detector=detector,
+                    total=len(drows),
+                    streak_status="pending",
+                    streak_len=0,
+                )
+            )
+            continue
+        tail_status = terminal[-1].status
+        streak_len = 0
+        for r in reversed(terminal):
+            if r.status == tail_status:
+                streak_len += 1
+            else:
+                break
+        streaks.append(
+            DetectorStat(
+                detector=detector,
+                total=len(drows),
+                streak_status=tail_status,
+                streak_len=streak_len,
+            )
+        )
+    streaks.sort(key=lambda s: s.total, reverse=True)
+
+    return Summary(
+        total=len(rows),
+        by_status=by_status,
+        top_detectors=detector_counts.most_common(top_n),
+        rules=rules,
+        detector_streaks=streaks,
+    )

autosentry/cli/__init__.py

@@ -0,0 +1,85 @@
+"""autosentry CLI.
+
+The CLI is composed out of small per-command modules under
+``autosentry.cli.commands``. This file owns the top-level Typer app
+and the eager ``--version`` callback; everything else is registered
+via :func:`_register_commands` so we don't grow a god-file again.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from autosentry import __version__
+from autosentry.cli.style import banner, console
+
+
+def _print_version(value: bool) -> None:
+    if not value:
+        return
+    console.print(banner(__version__))
+    raise typer.Exit()
+
+
+app = typer.Typer(
+    name="autosentry",
+    no_args_is_help=True,
+    add_completion=False,
+    help=(
+        "Self-healing sentry for long-running processes.\n\n"
+        "autosentry supervises a command, watches its log stream for known "
+        "failure modes and anomalies, applies deterministic YAML rules when "
+        "it can, and escalates to a Claude Code subagent when it can't. "
+        "Each event becomes a folder under .autosentry/incidents/ with "
+        "exploded stack frames, config snapshots, and the fix that was "
+        "applied. Start with `autosentry init`, then `autosentry doctor`, "
+        "then `autosentry run`."
+    ),
+    rich_markup_mode="rich",
+    pretty_exceptions_show_locals=False,
+)
+
+
+@app.callback()
+def _main(
+    version: bool = typer.Option(  # noqa: B008 — Typer idiom
+        False,
+        "--version",
+        "-V",
+        help="Print version and exit.",
+        is_flag=True,
+        callback=_print_version,
+        is_eager=True,
+    ),
+) -> None:
+    """autosentry — self-healing sentry for long-running processes."""
+
+
+def _register_commands() -> None:
+    """Import each command module so it can attach itself to ``app``.
+
+    Lazy attachment via import keeps the top-level entry fast (no
+    network, no file IO) until the user actually runs a subcommand.
+    """
+    # Import order is for help output ordering only; otherwise no constraint.
+    from autosentry.cli.commands import (  # noqa: F401
+        analyze,
+        dispatcher,
+        doctor,
+        healer,
+        incidents,
+        init,
+        onboard,
+        run,
+        skills,
+        status,
+        update,
+        watch,
+        web,
+    )
+
+
+_register_commands()
+
+
+__all__ = ["app"]

autosentry/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Each module here registers itself onto ``autosentry.cli.app``."""

autosentry/cli/commands/analyze.py

@@ -0,0 +1,154 @@
+"""``autosentry analyze`` — attempts ledger summary."""
+
+from __future__ import annotations
+
+import json as _json
+from pathlib import Path
+
+import typer
+from rich.table import Table
+
+from autosentry.cli import app
+from autosentry.cli.style import ACCENT, ERR, INFO, console
+from autosentry.config import load_config
+
+
+@app.command()
+def analyze(
+    config: Path = typer.Option(  # noqa: B008
+        Path("autosentry.yaml"),
+        "--config",
+        "-c",
+        help="Path to autosentry.yaml. Defaults to ./autosentry.yaml.",
+    ),
+    since: str = typer.Option(
+        "",
+        "--since",
+        help=(
+            "Filter window — e.g. 24h, 30m, 7d, 600s. Empty (the default) = "
+            "all-time. Useful before deciding to codify a new rule."
+        ),
+    ),
+    json_out: bool = typer.Option(
+        False,
+        "--json",
+        help="Print as JSON instead of rich tables. Pipe to jq for scripting.",
+    ),
+) -> None:
+    """Summarize the attempts ledger (`.autosentry/attempts.tsv`).
+
+    Three sections: top-failing detectors (sorted by attempt count
+    inside the window), per-rule success rate (kept vs regressed vs
+    crashed vs pending), and a regression-streak callout when a
+    detector has been failing repeatedly.
+
+    Use this to spot patterns worth codifying as YAML rules: when
+    three+ Claude-driven fixes for the same detector all `kept`,
+    that's a strong signal the pattern deserves a deterministic
+    rule.
+    """
+    from autosentry.analyze import filter_window, parse_since, summarize
+    from autosentry.ledger import AttemptsLedger
+
+    cfg = load_config(config)
+    ledger_path = cfg.resolve(".autosentry/attempts.tsv")
+    ledger = AttemptsLedger.load(ledger_path)
+    if not ledger.rows:
+        console.print(f"[dim]no attempts yet ({ledger_path})[/dim]")
+        return
+
+    try:
+        window = parse_since(since)
+    except ValueError as e:
+        console.print(f"[{ERR}]{e}[/{ERR}]")
+        raise typer.Exit(code=2) from e
+
+    rows = filter_window(ledger.rows, window)
+    summary = summarize(rows)
+
+    if json_out:
+        typer.echo(_json.dumps(_summary_to_dict(summary), indent=2))
+        return
+
+    title = f"attempts — {summary.total} total"
+    if window is not None:
+        title += f" (last {since})"
+    console.print(f"\n[bold]{title}[/bold]")
+    status_str = "  ".join(
+        f"[{INFO}]{k}[/{INFO}]={v}" for k, v in sorted(summary.by_status.items())
+    )
+    console.print(status_str + "\n")
+
+    if summary.top_detectors:
+        t = Table(title="top failing detectors", show_header=True, header_style="bold")
+        t.add_column("detector")
+        t.add_column("attempts", justify="right")
+        for name, count in summary.top_detectors:
+            t.add_row(name, str(count))
+        console.print(t)
+
+    if summary.rules:
+        t = Table(title="per-rule success", show_header=True, header_style="bold")
+        t.add_column("source (rule or claude)")
+        t.add_column("total", justify="right")
+        t.add_column("kept", justify="right")
+        t.add_column("regressed", justify="right")
+        t.add_column("crashed", justify="right")
+        t.add_column("pending", justify="right")
+        t.add_column("success", justify="right")
+        for r in summary.rules:
+            t.add_row(
+                r.source,
+                str(r.total),
+                str(r.kept),
+                str(r.regressed),
+                str(r.crashed),
+                str(r.pending),
+                f"{r.success_rate * 100:.0f}%",
+            )
+        console.print(t)
+
+    streaks_with_regression = [
+        s for s in summary.detector_streaks if s.streak_status == "regressed" and s.streak_len >= 2
+    ]
+    if streaks_with_regression:
+        t = Table(
+            title=f"[{ACCENT}]regression streaks (heads up)[/{ACCENT}]",
+            show_header=True,
+            header_style="bold",
+        )
+        t.add_column("detector")
+        t.add_column("streak", justify="right")
+        for s in streaks_with_regression:
+            t.add_row(s.detector, f"{s.streak_len}× regressed")
+        console.print(t)
+
+
+def _summary_to_dict(summary) -> dict:  # noqa: ANN001 — Summary is internal
+    return {
+        "total": summary.total,
+        "by_status": summary.by_status,
+        "top_detectors": summary.top_detectors,
+        "rules": [
+            {
+                "source": r.source,
+                "total": r.total,
+                "kept": r.kept,
+                "regressed": r.regressed,
+                "crashed": r.crashed,
+                "discarded": r.discarded,
+                "pending": r.pending,
+                "success_rate": r.success_rate,
+            }
+            for r in summary.rules
+        ],
+        "detector_streaks": [
+            {
+                "detector": s.detector,
+                "total": s.total,
+                "streak_status": s.streak_status,
+                "streak_len": s.streak_len,
+            }
+            for s in summary.detector_streaks
+        ],
+    }