agentdir-cli 0.7.5__py3-none-any.whl

agentdir/review.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+from .index import rebuild_index
+from .query import query_messages
+from .sessions import require_current_session
+
+EVIDENCE_FAMILIES = ("test", "lint", "typecheck", "build", "doctor", "release", "diagnostic")
+
+_FAMILY_KEYWORDS: dict[str, tuple[str, ...]] = {
+    "test": (
+        "pytest",
+        "unittest",
+        "test",
+        "tests",
+        "npm test",
+        "pnpm test",
+        "yarn test",
+        "go test",
+        "cargo test",
+        "rspec",
+    ),
+    "lint": ("lint", "eslint", "ruff", "flake8", "prettier", "clippy", "golangci-lint"),
+    "typecheck": ("typecheck", "type-check", "tsc", "mypy", "pyright", "sorbet", "staticcheck"),
+    "build": ("build", "npm run build", "pnpm build", "yarn build", "cargo build", "go build", "make"),
+    "doctor": ("doctor", "health", "diagnose", "diagnostic"),
+    "release": ("release", "publish", "pack", "version", "tag", "twine", "npm publish"),
+}
+
+_DIAGNOSTIC_EVENTS = {"file.diff"}
+
+
+def resolve_review_session(root: str | Path, session_id: str | None) -> str:
+    if session_id:
+        return session_id
+    return require_current_session(root).session_id
+
+
+def ensure_index(root: str | Path) -> None:
+    rebuild_index(root)
+
+
+def summarize_session(root: str | Path, session_id: str | None = None, *, rebuild: bool = True) -> dict[str, Any]:
+    resolved = resolve_review_session(root, session_id)
+    if rebuild:
+        ensure_index(root)
+    rows = query_messages(root, session_id=resolved, limit=10_000)
+    counts = Counter(row.get("event_type") or "unknown" for row in rows)
+    tool_results = [row for row in rows if row.get("event_type") == "tool.result"]
+    failed_tools = [row for row in tool_results if row.get("tool_exit_code") not in (None, 0)]
+    return {
+        "session_id": resolved,
+        "events": len(rows),
+        "event_counts": dict(sorted(counts.items())),
+        "tool_results": len(tool_results),
+        "failed_tools": len(failed_tools),
+        "first_event": rows[0]["date_header"] if rows else None,
+        "last_event": rows[-1]["date_header"] if rows else None,
+    }
+
+
+def format_summary(summary: dict[str, Any]) -> str:
+    lines = [
+        f"session={summary['session_id']}",
+        f"events={summary['events']}",
+        f"tool_results={summary['tool_results']}",
+        f"failed_tools={summary['failed_tools']}",
+    ]
+    for event_type, count in summary["event_counts"].items():
+        lines.append(f"{event_type}={count}")
+    return "\n".join(lines)
+
+
+def evidence_rows(root: str | Path, session_id: str | None = None, *, rebuild: bool = True) -> list[dict[str, Any]]:
+    resolved = resolve_review_session(root, session_id)
+    if rebuild:
+        ensure_index(root)
+    rows = query_messages(root, session_id=resolved, limit=10_000)
+    wanted = {"tool.call", "tool.result", "file.diff"}
+    evidence = [
+        row
+        for row in rows
+        if row.get("event_type") in wanted or str(row.get("event_type") or "").startswith("git.hook.")
+    ]
+    for row in evidence:
+        row["family"] = classify_evidence(row)
+        row["failed"] = evidence_failed(row)
+    return evidence
+
+
+def classify_evidence(row: dict[str, Any]) -> str:
+    event_type = str(row.get("event_type") or "")
+    if event_type in _DIAGNOSTIC_EVENTS or event_type.startswith("git.hook."):
+        return "diagnostic"
+    primary = " ".join(str(row.get(key) or "") for key in ("tool", "subject")).lower()
+    for family in EVIDENCE_FAMILIES:
+        if family == "diagnostic":
+            continue
+        if any(keyword in primary for keyword in _FAMILY_KEYWORDS.get(family, ())):
+            return family
+    haystack = _evidence_search_text(row)
+    for family in EVIDENCE_FAMILIES:
+        if family == "diagnostic":
+            continue
+        if any(keyword in haystack for keyword in _FAMILY_KEYWORDS.get(family, ())):
+            return family
+    return "diagnostic"
+
+
+def evidence_failed(row: dict[str, Any]) -> bool:
+    return row.get("event_type") == "tool.result" and row.get("tool_exit_code") not in (None, 0)
+
+
+def evidence_ref(row: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "event_type": row.get("event_type"),
+        "family": row.get("family") or classify_evidence(row),
+        "tool": row.get("tool"),
+        "exit_code": row.get("tool_exit_code"),
+        "subject": row.get("subject"),
+        "date": row.get("date_header") or row.get("date_utc") or row.get("indexed_at"),
+        "path": row.get("file_path"),
+        "failed": row.get("failed") if "failed" in row else evidence_failed(row),
+    }
+
+
+def filter_evidence(
+    rows: list[dict[str, Any]],
+    *,
+    family: str | None = None,
+    failed: bool = False,
+) -> list[dict[str, Any]]:
+    if family and family not in EVIDENCE_FAMILIES:
+        raise ValueError(f"unknown evidence family: {family}")
+    filtered: list[dict[str, Any]] = []
+    for row in rows:
+        row_family = row.get("family") or classify_evidence(row)
+        row_failed = row.get("failed") if "failed" in row else evidence_failed(row)
+        if family and row_family != family:
+            continue
+        if failed and not row_failed:
+            continue
+        copied = dict(row)
+        copied["family"] = row_family
+        copied["failed"] = row_failed
+        filtered.append(copied)
+    return filtered
+
+
+def evidence_brief(rows: list[dict[str, Any]], *, family: str | None = None, failed: bool = False) -> dict[str, Any]:
+    filtered = filter_evidence(rows, family=family, failed=failed)
+    grouped: dict[str, list[dict[str, Any]]] = {name: [] for name in EVIDENCE_FAMILIES}
+    for row in filtered:
+        grouped[str(row.get("family") or classify_evidence(row))].append(row)
+    failed_rows = [row for row in filtered if row.get("failed") or evidence_failed(row)]
+    families: list[dict[str, Any]] = []
+    latest_by_family: dict[str, dict[str, Any]] = {}
+    for name in EVIDENCE_FAMILIES:
+        items = grouped[name]
+        if not items:
+            continue
+        latest = evidence_ref(items[-1])
+        latest_by_family[name] = latest
+        families.append(
+            {
+                "family": name,
+                "total": len(items),
+                "failed": sum(1 for row in items if row.get("failed") or evidence_failed(row)),
+                "latest": latest,
+            }
+        )
+    return {
+        "families": families,
+        "latest_by_family": latest_by_family,
+        "failed_evidence": [evidence_ref(row) for row in failed_rows],
+        "counts": {
+            "total": len(filtered),
+            "failed": len(failed_rows),
+            "families": len(families),
+        },
+    }
+
+
+def format_evidence_brief(brief: dict[str, Any]) -> str:
+    lines: list[str] = []
+    failed = brief.get("failed_evidence") or []
+    if failed:
+        lines.append("Failed evidence:")
+        for item in failed:
+            lines.append(_format_evidence_ref(item))
+    families = brief.get("families") or []
+    if families:
+        if lines:
+            lines.append("")
+        lines.append("Latest evidence by family:")
+        for family in families:
+            lines.append(_format_evidence_ref(family["latest"], prefix=f"{family['family']}: "))
+    if not lines:
+        return "No evidence captured."
+    return "\n".join(lines)
+
+
+def timeline_rows(
+    root: str | Path,
+    session_id: str | None = None,
+    *,
+    limit: int = 100,
+    rebuild: bool = True,
+) -> list[dict[str, Any]]:
+    resolved = resolve_review_session(root, session_id)
+    if rebuild:
+        ensure_index(root)
+    rows = query_messages(root, session_id=resolved, limit=limit)
+    return [timeline_ref(row) for row in rows]
+
+
+def timeline_ref(row: dict[str, Any]) -> dict[str, Any]:
+    event_type = row.get("event_type")
+    item = {
+        "date": row.get("date_header") or row.get("date_utc") or row.get("indexed_at"),
+        "event_type": event_type,
+        "subject": row.get("subject"),
+        "tool": row.get("tool"),
+        "exit_code": row.get("tool_exit_code"),
+        "actor": row.get("from_actor"),
+        "path": row.get("file_path"),
+    }
+    if event_type in {"tool.call", "tool.result", "file.diff"} or str(event_type or "").startswith("git.hook."):
+        item["family"] = classify_evidence(row)
+        item["failed"] = evidence_failed(row)
+    return item
+
+
+def format_timeline(rows: list[dict[str, Any]]) -> str:
+    lines: list[str] = []
+    for row in rows:
+        date = row.get("date") or "unknown-date"
+        event_type = row.get("event_type") or "unknown"
+        subject = row.get("subject") or ""
+        tool = row.get("tool") or ""
+        exit_code = row.get("exit_code")
+        family = row.get("family") or ""
+        detail_parts = []
+        if tool:
+            detail_parts.append(str(tool))
+        if family:
+            detail_parts.append(f"family={family}")
+        if exit_code is not None:
+            detail_parts.append(f"exit={exit_code}")
+        detail = " ".join(detail_parts)
+        lines.append(f"{date} {event_type} {detail} {subject}".rstrip())
+    return "\n".join(lines)
+
+
+def format_evidence(rows: list[dict[str, Any]]) -> str:
+    lines: list[str] = []
+    for row in rows:
+        date = row.get("date_header") or row.get("indexed_at") or "unknown-date"
+        event_type = row.get("event_type") or "unknown"
+        tool = row.get("tool") or ""
+        exit_code = row.get("tool_exit_code")
+        subject = row.get("subject") or ""
+        file_path = row.get("file_path") or ""
+        family = row.get("family") or classify_evidence(row)
+        detail = f" exit={exit_code}" if exit_code is not None else ""
+        family_detail = f" family={family}" if family else ""
+        lines.append(f"{date} {event_type} {tool}{detail}{family_detail} {subject} [{file_path}]")
+    return "\n".join(lines)
+
+
+def _evidence_search_text(row: dict[str, Any]) -> str:
+    return " ".join(
+        str(row.get(key) or "")
+        for key in ("tool", "subject", "body_text", "event_type", "message_id")
+    ).lower()
+
+
+def _format_evidence_ref(item: dict[str, Any], *, prefix: str = "- ") -> str:
+    tool = item.get("tool") or ""
+    exit_code = item.get("exit_code")
+    subject = item.get("subject") or ""
+    date = item.get("date") or "unknown-date"
+    exit_text = f" exit={exit_code}" if exit_code is not None else ""
+    failed = " failed=true" if item.get("failed") else ""
+    return f"{prefix}{date} {item.get('event_type') or 'unknown'} {tool}{exit_text}{failed} {subject}".rstrip()

agentdir/secrets.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import os
+from dataclasses import asdict, dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from .envelope import envelope_bytes, parse_envelope
+from .index import rebuild_index
+from .mailbox import fsync_directory, iter_records
+from .redaction import redact_text, secret_labels
+from .store import is_mailbox, require_root
+
+
+@dataclass(frozen=True)
+class SecretFinding:
+    path: str
+    mailbox: str
+    message_id: str | None
+    event_type: str | None
+    subject: str | None
+    labels: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class SecretRedaction:
+    path: str
+    labels: tuple[str, ...]
+    replacements: int
+    applied: bool
+
+
+def scan_secret_records(root: str | Path) -> list[SecretFinding]:
+    paths = require_root(root)
+    findings: list[SecretFinding] = []
+    for mailbox in _all_mailboxes(paths.root):
+        for record in iter_records(mailbox):
+            parsed = parse_envelope(record.path)
+            labels = secret_labels(parsed.body_text)
+            if not labels:
+                continue
+            findings.append(
+                SecretFinding(
+                    path=str(record.path.relative_to(paths.root)),
+                    mailbox=str(mailbox.relative_to(paths.root)),
+                    message_id=parsed.message_id,
+                    event_type=parsed.message.get("X-AgentDir-Event-Type"),
+                    subject=parsed.message.get("Subject"),
+                    labels=labels,
+                )
+            )
+    return findings
+
+
+def redact_secret_records(root: str | Path, *, apply: bool = False) -> dict[str, Any]:
+    paths = require_root(root)
+    redactions: list[SecretRedaction] = []
+    for mailbox in _all_mailboxes(paths.root):
+        for record in iter_records(mailbox):
+            parsed = parse_envelope(record.path)
+            result = redact_text(parsed.body_text)
+            if result.replacements == 0:
+                continue
+            if apply:
+                _rewrite_body(record.path, parsed.message, result.text, result.labels, result.replacements)
+            redactions.append(
+                SecretRedaction(
+                    path=str(record.path.relative_to(paths.root)),
+                    labels=result.labels,
+                    replacements=result.replacements,
+                    applied=apply,
+                )
+            )
+    if apply and redactions:
+        rebuild_index(paths.root)
+    return {
+        "applied": apply,
+        "count": len(redactions),
+        "redactions": [asdict(item) for item in redactions],
+        "index_rebuilt": bool(apply and redactions),
+    }
+
+
+def format_secret_findings(findings: list[SecretFinding]) -> str:
+    if not findings:
+        return "No secret-like envelope bodies found."
+    lines = [f"Found {len(findings)} secret-like envelope body/bodies:"]
+    for finding in findings:
+        labels = ",".join(finding.labels)
+        event = finding.event_type or "unknown"
+        lines.append(f"- {finding.path} [{event}] labels={labels}")
+    lines.append("No body text was printed.")
+    return "\n".join(lines)
+
+
+def format_secret_redaction(result: dict[str, Any]) -> str:
+    count = int(result["count"])
+    if count == 0:
+        return "No secret-like envelope bodies found."
+    action = "Redacted" if result["applied"] else "Would redact"
+    lines = [f"{action} {count} secret-like envelope body/bodies:"]
+    for item in result["redactions"]:
+        labels = ",".join(item["labels"])
+        lines.append(f"- {item['path']} labels={labels} replacements={item['replacements']}")
+    if result["applied"]:
+        lines.append("Rebuilt the derived SQLite index after redaction.")
+    else:
+        lines.append("Dry run only. Re-run with --apply to rewrite bodies and rebuild the index.")
+    lines.append("No body text was printed.")
+    return "\n".join(lines)
+
+
+def _all_mailboxes(root: Path) -> list[Path]:
+    return sorted(path for path in root.glob("**/Maildir") if is_mailbox(path))
+
+
+def _rewrite_body(
+    path: Path,
+    message: Any,
+    body: str,
+    labels: tuple[str, ...],
+    replacements: int,
+) -> None:
+    message.set_content(body, subtype="plain", charset="utf-8")
+    _replace_header(message, "X-AgentDir-Secret-Redacted", "true")
+    _replace_header(message, "X-AgentDir-Secret-Redacted-At", datetime.now(UTC).isoformat())
+    _replace_header(message, "X-AgentDir-Secret-Redaction-Labels", ",".join(labels))
+    _replace_header(message, "X-AgentDir-Secret-Redaction-Replacements", str(replacements))
+    _atomic_replace(path, envelope_bytes(message))
+
+
+def _replace_header(message: Any, name: str, value: str) -> None:
+    while name in message:
+        del message[name]
+    message[name] = value
+
+
+def _atomic_replace(path: Path, data: bytes) -> None:
+    temp = path.with_name(f".{path.name}.agentdir-redact-tmp")
+    if temp.exists():
+        temp.unlink()
+    mode = path.stat().st_mode
+    fd = os.open(temp, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    try:
+        with os.fdopen(fd, "wb") as handle:
+            handle.write(data)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.chmod(temp, mode)
+        os.replace(temp, path)
+        fsync_directory(path.parent)
+    except Exception:
+        try:
+            temp.unlink()
+        except FileNotFoundError:
+            pass
+        raise

agentdir/sessions.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import asdict, dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+
+from .events import emit_event
+from .git import git_head, workspace_name
+from .store import AgentDirError, init_root, paths_for, validate_id
+
+
+@dataclass
+class SessionState:
+    session_id: str
+    title: str
+    actor: str
+    workspace: str
+    git_head: str | None
+    started_at: str
+    status: str = "active"
+    ended_at: str | None = None
+
+
+def now_iso() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def safe_session_id(value: str) -> str:
+    safe = "".join(ch if ch.isalnum() or ch in "._@+-" else "-" for ch in value.strip())
+    safe = safe.strip(".-") or "agent-session"
+    return validate_id(safe[:128], "session id")
+
+
+def default_session_id(cwd: str | Path | None = None) -> str:
+    stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+    suffix = f"{time.time_ns() % 1_000_000_000:09d}"
+    return safe_session_id(f"repo-{workspace_name(cwd)}-{stamp}-{suffix}")
+
+
+def current_session_path(root: str | Path) -> Path:
+    return paths_for(root).state / "current-session.json"
+
+
+def last_session_path(root: str | Path) -> Path:
+    return paths_for(root).state / "last-session.json"
+
+
+def write_session_state(root: str | Path, state: SessionState) -> None:
+    paths = init_root(root)
+    paths.state.mkdir(parents=True, exist_ok=True)
+    current_session_path(root).write_text(json.dumps(asdict(state), indent=2) + "\n", encoding="utf-8")
+
+
+def read_current_session(root: str | Path) -> SessionState | None:
+    path = current_session_path(root)
+    if not path.is_file():
+        return None
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    return SessionState(**payload)
+
+
+def require_current_session(root: str | Path) -> SessionState:
+    state = read_current_session(root)
+    if state is None or state.status != "active":
+        raise AgentDirError("No active AgentDir session; run: agentdir session ensure")
+    return state
+
+
+def ensure_session(
+    root: str | Path,
+    session_id: str | None = None,
+    *,
+    title: str | None = None,
+    actor: str = "agent",
+    emit_started: bool = True,
+) -> SessionState:
+    if session_id:
+        current = read_current_session(root)
+        if current and current.session_id == session_id and current.status == "active":
+            return current
+        return start_session(root, session_id=session_id, title=title, actor=actor, emit_started=emit_started)
+    current = read_current_session(root)
+    if current and current.status == "active":
+        return current
+    return start_session(root, title=title or "AgentDir auto session", actor=actor, emit_started=emit_started)
+
+
+def start_session(
+    root: str | Path,
+    *,
+    session_id: str | None = None,
+    title: str | None = None,
+    actor: str = "agent",
+    note: str | None = None,
+    cwd: str | Path | None = None,
+    emit_started: bool = True,
+) -> SessionState:
+    resolved_id = safe_session_id(session_id) if session_id else default_session_id(cwd)
+    state = SessionState(
+        session_id=resolved_id,
+        title=title or resolved_id,
+        actor=actor,
+        workspace=workspace_name(cwd),
+        git_head=git_head(cwd),
+        started_at=now_iso(),
+    )
+    write_session_state(root, state)
+    if emit_started:
+        body = "\n".join(
+            [
+                f"session_id={state.session_id}",
+                f"title={state.title}",
+                f"actor={state.actor}",
+                f"workspace={state.workspace}",
+                f"git_head={state.git_head or ''}",
+                f"started_at={state.started_at}",
+                "",
+                note or "AgentDir session started.",
+            ]
+        )
+        emit_event(
+            root,
+            session_id=state.session_id,
+            event_type="session.started",
+            body=body,
+            subject=state.title,
+            from_actor=actor,
+            workspace=state.workspace,
+            git_head=state.git_head,
+        )
+    return state
+
+
+def end_session(
+    root: str | Path,
+    *,
+    status: str = "completed",
+    summary: str | None = None,
+    actor: str = "agent",
+) -> SessionState:
+    state = require_current_session(root)
+    state.status = status
+    state.ended_at = now_iso()
+    body = "\n".join(
+        [
+            f"session_id={state.session_id}",
+            f"status={state.status}",
+            f"ended_at={state.ended_at}",
+            "",
+            summary or "AgentDir session ended.",
+        ]
+    )
+    emit_event(
+        root,
+        session_id=state.session_id,
+        event_type="session.ended",
+        body=body,
+        subject=f"session {status}",
+        from_actor=actor,
+        workspace=state.workspace,
+        git_head=git_head(),
+    )
+    paths = init_root(root)
+    last_session_path(root).write_text(json.dumps(asdict(state), indent=2) + "\n", encoding="utf-8")
+    current = current_session_path(root)
+    if current.exists():
+        current.unlink()
+    paths.state.mkdir(parents=True, exist_ok=True)
+    return state