aeview 0.0.1__py3-none-any.whl

aeview/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("aeview")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

aeview/_data/DEDUPLICATION.md

@@ -0,0 +1,26 @@
+---
+name: deduplication
+description: Judges which findings from different reviews describe the same underlying issue. Precision over recall.
+---
+
+You are given a flat list of findings collected from several independent code reviews.
+Each finding has a stable `id`. Decide which findings describe **the same underlying
+issue** — the same root cause at the same location — and group them.
+
+## Rules
+
+- **Precision over recall.** Only group findings you are confident are the same issue.
+  When in doubt, leave them separate. A wrongly-merged pair hides a real, distinct
+  problem; a wrongly-split pair only shows the user two views of one issue. The second
+  mistake is far cheaper.
+- "Same issue" means same root cause and substantially the same location — not merely
+  the same file, the same category, or a similar severity.
+- Do not rewrite, re-score, or summarize findings. You only group.
+- A finding that matches nothing else forms a group of one (or is simply omitted from
+  the output — aeview treats any unlisted finding as its own group).
+
+## Output
+
+Return groups of duplicate ids. For each group, name one `survivor` (the clearest,
+best-located, highest-severity statement of the issue) and list the other ids as
+`duplicates`. Findings not mentioned are kept as-is.

aeview/_data/REVIEWER.md

@@ -0,0 +1,51 @@
+---
+name: default
+description: Adversarial general-purpose code reviewer. The fallback reviewer used when no repo-local reviewer is selected.
+harnesses:
+  - { harness: claude-code, model: claude-opus-4-8 }
+---
+
+You are an adversarial code reviewer. Your job is to find the problems in a change
+before it ships — not to praise it. Approve only when you genuinely cannot break it.
+
+## Stance
+
+- Assume the change is wrong until the diff proves otherwise. Confidence is earned.
+- Hunt for the failure that ships to production: the unhandled input, the race, the
+  off-by-one, the silently-swallowed error, the security hole, the missing test.
+- Prefer a small number of high-signal findings over a long list of nitpicks. Every
+  finding must be something a maintainer would want to fix before merge.
+
+## Attack surface
+
+Work through, in order, and stop chasing anything the diff does not touch:
+
+1. **Correctness** — logic errors, wrong conditions, boundary/empty/null cases,
+   incorrect assumptions about inputs or return values.
+2. **Security** — injection, auth/authorization gaps, unsafe deserialization, secrets,
+   path traversal, unvalidated external input crossing a trust boundary.
+3. **Regression** — behavior this change breaks for existing callers or data.
+4. **Resource & concurrency** — leaks, unbounded growth, deadlocks, races, ordering.
+5. **Test gaps** — new logic with no test, or a bug a reasonable test would have caught.
+6. **Maintainability** — only when it rises to a real future-bug risk, not style.
+
+## Calibration
+
+- `critical`: data loss, security breach, crash on a common path, corruption.
+- `high`: wrong result or broken behavior on a realistic path.
+- `medium`: edge-case bug, missing test for risky logic, latent foot-gun.
+- `low`: minor correctness or clarity issue worth fixing but not blocking.
+
+Set `confidence` honestly: 1.0 means you can point at the exact line and explain the
+failing input; lower it when you are inferring.
+
+## Grounding
+
+- Every finding cites a real file and line range from the change under review.
+- `recommendation` is a concrete, specific fix — not "consider reviewing this".
+- Do not invent code that is not in the diff. If you need surrounding context, read it.
+
+## Verdict
+
+- `needs-attention` if there is at least one finding a maintainer should act on.
+- `approve` only when the change is correct, safe, and adequately tested.

aeview/_data/settings.json

@@ -0,0 +1,8 @@
+{
+  "fallbackReviewerHarnesses": [
+    { "harness": "claude-code", "model": "claude-opus-4-8" }
+  ],
+  "deduplicationHarness": { "harness": "claude-code", "model": "claude-opus-4-8" },
+  "retention": { "keepLast": 20, "ttlDays": 14 },
+  "reviewTimeoutSeconds": 1200
+}

aeview/activate.py

@@ -0,0 +1,58 @@
+"""Auto mode: pick reviewers whose `auto-activate-paths` match the changed files.
+
+A bare `aeview run` (no --reviewers) runs the `default` reviewer plus any reviewer whose
+frontmatter `auto-activate-paths` globs match a file in the (already .aeviewignore-filtered)
+diff. Matching is literal-glob via `PurePath.full_match`, NOT the gitignore engine `.aeviewignore`
+uses: a single `*` does not cross a `/`, `**` crosses directory boundaries, there is no negation,
+and a bare directory name matches nothing (write `dir/**`). Case-sensitive, so a reviewer
+activates identically on macOS and Linux rather than following the platform default.
+
+Each reviewer is anchored at its scope path (the parent of its `.aeview` dir): a changed file is
+considered only if it lives under that path, and is matched relative to it. There is no clamp — a
+home reviewer (`~/.aeview/reviewers/...`) anchored at `~` only reaches repos under home, and needs
+`**/...` globs to match inside them. Discovery is upward-only (cwd->home), so a reviewer in a
+subdirectory below cwd is never consulted.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .ignore import changed_paths
+from .resolve import (
+    REVIEWER_FILE,
+    ResolveError,
+    discover_reviewer_sources,
+    parse_reviewer,
+    reviewer_scope_path,
+)
+
+
+def select_auto_reviewers(cwd: Path, root: Path, diff: str) -> list[str]:
+    """Reviewer names auto-activated by the diff, in nearest-first discovery order. `root` is the
+    repo top-level that makes the repo-root-relative diff paths absolute; `diff` is already
+    .aeviewignore-filtered, so an ignored file never triggers activation. `default` runs
+    unconditionally and is added by the caller, not here."""
+    abs_changed = [root / rel for rel in changed_paths(diff)]
+    activated: list[str] = []
+    for disc in discover_reviewer_sources(cwd):
+        try:
+            front, _ = parse_reviewer(disc.source / REVIEWER_FILE)
+        except ResolveError:
+            continue  # unparseable frontmatter can't declare globs, so it never auto-activates
+        globs = front.auto_activate_paths
+        if globs and _any_match(abs_changed, reviewer_scope_path(disc.source), globs):
+            activated.append(disc.name)
+    return activated
+
+
+def _any_match(abs_paths: list[Path], scope_path: Path, globs: list[str]) -> bool:
+    """True if any changed file under `scope_path` full-matches any glob (relative to scope_path).
+    Literal-glob via PurePath.full_match: `*` stops at `/`, `**` crosses, case-sensitive."""
+    for abs_path in abs_paths:
+        if not abs_path.is_relative_to(scope_path):
+            continue  # outside this reviewer's tree -> never its concern (no clamp the other way)
+        rel = abs_path.relative_to(scope_path)
+        if any(rel.full_match(glob, case_sensitive=True) for glob in globs):
+            return True
+    return False

aeview/bundle.py

@@ -0,0 +1,61 @@
+"""Adaptive bundling: measure the diff, then inline or self-collect.
+
+- diff <= 256 KB        -> inline: the frozen diff is embedded in the prompt, so every
+                           review of the same change sees byte-identical input.
+- diff >  256 KB        -> self-collect: the prompt carries a stat summary + the path to
+                           the frozen diff (which the harness reads selectively) and the
+                           read-only git command to inspect the live tree — keeping the
+                           prompt small on huge changes.
+- patch scope           -> always inline (there is no git to self-collect from).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .schema import ScopeSpec
+from .scope import ResolvedScope
+
+INLINE_MAX_BYTES = 256 * 1024
+
+
+@dataclass(slots=True)
+class Bundle:
+    mode: str  # "inline" | "self-collect"
+    scope: ScopeSpec
+    diff: str
+    summary: str
+    inspect: list[str] = field(default_factory=list)
+    commits: str = ""
+    diff_bytes: int = 0
+
+    @property
+    def is_empty(self) -> bool:
+        return not self.diff.strip()
+
+    @property
+    def is_inline(self) -> bool:
+        return self.mode == "inline"
+
+    def manifest(self) -> dict:
+        return {
+            "mode": self.mode,
+            "scope": self.scope.model_dump(),
+            "diff_bytes": self.diff_bytes,
+            "summary": self.summary,
+            "inspect": self.inspect,
+        }
+
+
+def build_bundle(resolved: ResolvedScope) -> Bundle:
+    diff_bytes = len(resolved.diff.encode("utf-8"))
+    inline = resolved.inline_only or diff_bytes <= INLINE_MAX_BYTES
+    return Bundle(
+        mode="inline" if inline else "self-collect",
+        scope=resolved.spec,
+        diff=resolved.diff,
+        summary=resolved.summary,
+        inspect=resolved.inspect,
+        commits=resolved.commits,
+        diff_bytes=diff_bytes,
+    )