agentdir-cli 0.7.5__py3-none-any.whl

agentdir/query.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .index import connect_index
+
+
+def query_messages(
+    root: str | Path,
+    *,
+    session_id: str | None = None,
+    event_type: str | None = None,
+    actor: str | None = None,
+    task_id: str | None = None,
+    tool: str | None = None,
+    git_head: str | None = None,
+    workspace: str | None = None,
+    text: str | None = None,
+    since: str | None = None,
+    until: str | None = None,
+    limit: int = 100,
+) -> list[dict[str, Any]]:
+    clauses: list[str] = []
+    params: list[Any] = []
+    if session_id:
+        clauses.append("session_id = ?")
+        params.append(session_id)
+    if event_type:
+        clauses.append("event_type = ?")
+        params.append(event_type)
+    if actor:
+        clauses.append("(from_actor like ? or to_actor like ?)")
+        params.extend([f"{actor}%", f"{actor}%"])
+    if task_id:
+        clauses.append("task_id = ?")
+        params.append(task_id)
+    if tool:
+        clauses.append("tool = ?")
+        params.append(tool)
+    if git_head:
+        clauses.append("git_head = ?")
+        params.append(git_head)
+    if workspace:
+        clauses.append("workspace = ?")
+        params.append(workspace)
+    if since:
+        clauses.append("coalesce(date_utc, indexed_at) >= ?")
+        params.append(since)
+    if until:
+        clauses.append("coalesce(date_utc, indexed_at) <= ?")
+        params.append(until)
+    if text:
+        clauses.append("(subject like ? or body_text like ? or message_id like ?)")
+        like = f"%{text}%"
+        params.extend([like, like, like])
+
+    sql = "select * from messages"
+    if clauses:
+        sql += " where " + " and ".join(clauses)
+    sql += " order by coalesce(date_utc, indexed_at), coalesce(created_ns, 0), file_path, id limit ?"
+    params.append(limit)
+
+    with connect_index(root) as conn:
+        return [dict(row) for row in conn.execute(sql, params).fetchall()]

agentdir/redaction.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+SECRET_PATTERNS = [
+    ("github-token", re.compile(r"gh[opsu]_[A-Za-z0-9_]{20,}")),
+    ("aws-access-key", re.compile(r"AKIA[0-9A-Z]{16}")),
+    (
+        "key-value-secret",
+        re.compile(r"(?i)(api[_-]?key|secret|token|password)\s*[:=]\s*['\"]?[A-Za-z0-9_./+=-]{12,}"),
+    ),
+    ("private-key", re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----")),
+]
+
+
+@dataclass(frozen=True)
+class RedactionResult:
+    text: str
+    replacements: int
+    labels: tuple[str, ...] = ()
+
+
+def redact_text(text: str) -> RedactionResult:
+    replacements = 0
+    redacted = text
+    labels: list[str] = []
+    for label, pattern in SECRET_PATTERNS:
+        redacted, count = pattern.subn(f"<redacted:{label}>", redacted)
+        replacements += count
+        if count:
+            labels.append(label)
+    return RedactionResult(text=redacted, replacements=replacements, labels=tuple(labels))
+
+
+def looks_secret_bearing(text: str) -> bool:
+    return any(pattern.search(text) for _label, pattern in SECRET_PATTERNS)
+
+
+def secret_labels(text: str) -> tuple[str, ...]:
+    return tuple(label for label, pattern in SECRET_PATTERNS if pattern.search(text))

agentdir/rendering.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def rich_status(status: dict[str, Any]) -> str | None:
+    rich = _rich()
+    if rich is None:
+        return None
+    Console, Table = rich
+    table = Table(title="AgentDir Status", show_header=True, header_style="bold")
+    table.add_column("Area")
+    table.add_column("Key")
+    table.add_column("Value")
+    root = status["root"]
+    session = status["session"]
+    context = status["context"]
+    memory = status["memory"]
+    federation = status["federation"]
+    health = status["health"]
+    table.add_row("root", "path", root["path"])
+    table.add_row("root", "scope", root["scope"])
+    table.add_row("root", "version", str(root.get("version") or ""))
+    table.add_row("session", "active", _bool(session["active"]))
+    table.add_row("session", "current", session["current"]["session_id"] if session.get("current") else "")
+    table.add_row("context", "latest_pack", context["latest_pack"]["pack_id"] if context.get("latest_pack") else "")
+    table.add_row("evidence", "count", str(status["evidence"]["count"]))
+    table.add_row("memory", "documents", str(memory.get("memory_documents", 0)))
+    table.add_row("memory", "passages", str(memory.get("passages", 0)))
+    table.add_row("federation", "registered_roots", str(federation["registered_roots"]))
+    table.add_row("federation", "stale_roots", str(federation["stale_roots"]))
+    table.add_row("health", "doctor_ok", _bool(health["ok"]))
+    return _export(table, Console)
+
+
+def rich_root_diagnostics(rows: list[dict[str, Any]]) -> str | None:
+    rich = _rich()
+    if rich is None:
+        return None
+    Console, Table = rich
+    table = Table(title="AgentDir Root Diagnostics", show_header=True, header_style="bold")
+    for column in ("Root", "Name", "Status", "Freshness", "Path", "Details"):
+        table.add_column(column)
+    for row in rows:
+        details = "; ".join([*row.get("errors", []), *row.get("warnings", [])])
+        table.add_row(
+            row["root_id"],
+            row["name"],
+            "ok" if row["ok"] else "error",
+            "stale" if row.get("stale") else "fresh",
+            row["root_path"],
+            details,
+        )
+    return _export(table, Console)
+
+
+def rich_doctor(report: dict[str, Any]) -> str | None:
+    rich = _rich()
+    if rich is None:
+        return None
+    Console, Table = rich
+    table = Table(title="AgentDir Doctor", show_header=True, header_style="bold")
+    table.add_column("Level")
+    table.add_column("Message")
+    table.add_row("ok", _bool(report["ok"]))
+    for warning in report.get("warnings", []):
+        table.add_row("warning", warning)
+    for error in report.get("errors", []):
+        table.add_row("error", error)
+    return _export(table, Console)
+
+
+def _rich() -> tuple[Any, Any] | None:
+    try:
+        from rich.console import Console
+        from rich.table import Table
+    except ImportError:
+        return None
+    return Console, Table
+
+
+def _export(renderable: Any, Console: Any) -> str:
+    console = Console(record=True, force_terminal=False, color_system=None, width=120)
+    console.print(renderable)
+    return console.export_text(clear=True)
+
+
+def _bool(value: bool) -> str:
+    return "true" if value else "false"

agentdir/replay.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from .index import rebuild_index
+from .query import query_messages
+
+
+def replay_session(root: str | Path, session_id: str) -> list[str]:
+    try:
+        rows = query_messages(root, session_id=session_id, limit=10_000)
+    except sqlite3.DatabaseError as exc:
+        if not _looks_like_missing_index(exc):
+            raise
+        rebuild_index(root)
+        rows = query_messages(root, session_id=session_id, limit=10_000)
+    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"
+        subject = row.get("subject") or ""
+        body = (row.get("body_text") or "").strip().replace("\n", "\\n")
+        file_path = row.get("file_path") or ""
+        lines.append(f"{date} {event_type} {subject} {body} [{file_path}]")
+    return lines
+
+
+def _looks_like_missing_index(exc: sqlite3.DatabaseError) -> bool:
+    message = str(exc).lower()
+    return "no such table" in message or "file is not a database" in message or "database disk image is malformed" in message

agentdir/retention.py

@@ -0,0 +1,319 @@
+from __future__ import annotations
+
+import shutil
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from .index import rebuild_index
+from .mailbox import fsync_directory
+from .sessions import read_current_session
+from .store import AgentDirError, init_root, validate_id
+
+SECONDS_PER_DAY = 24 * 60 * 60
+
+
+@dataclass(frozen=True)
+class RetentionCandidate:
+    session_id: str
+    store: str
+    path: str
+    event_count: int
+    latest_event_at: float | None
+    active: bool = False
+
+
+@dataclass(frozen=True)
+class RetentionResult:
+    action: str
+    dry_run: bool
+    selected: list[RetentionCandidate]
+    protected: list[RetentionCandidate]
+    changed: list[str]
+    rebuilt_index: bool = False
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "action": self.action,
+            "dry_run": self.dry_run,
+            "selected": [asdict(candidate) for candidate in self.selected],
+            "protected": [asdict(candidate) for candidate in self.protected],
+            "changed": self.changed,
+            "rebuilt_index": self.rebuilt_index,
+        }
+
+
+def archive_sessions(
+    root: str | Path,
+    *,
+    sessions: list[str] | None = None,
+    older_than_days: int | None = None,
+    keep_recent: int | None = None,
+    apply: bool = False,
+) -> RetentionResult:
+    paths = init_root(root)
+    _validate_selectors(
+        sessions=sessions,
+        older_than_days=older_than_days,
+        keep_recent=keep_recent,
+        command="archive",
+    )
+    active_id = _active_session_id(paths.root)
+    candidates = _list_sessions(paths.sessions, store="sessions", active_session_id=active_id)
+    selected, protected = _select_candidates(
+        candidates,
+        sessions=sessions,
+        older_than_days=older_than_days,
+        keep_recent=keep_recent,
+    )
+    _raise_on_exact_active("archive", sessions, protected)
+
+    changed: list[str] = []
+    if apply:
+        target_root = paths.archives / "sessions"
+        target_root.mkdir(parents=True, exist_ok=True)
+        targets: list[tuple[RetentionCandidate, Path]] = []
+        for candidate in selected:
+            target = target_root / candidate.session_id
+            if target.exists():
+                raise AgentDirError(f"archive target already exists: {target}")
+            targets.append((candidate, target))
+        for candidate, target in targets:
+            source = Path(candidate.path)
+            source.rename(target)
+            fsync_directory(paths.sessions)
+            fsync_directory(target_root)
+            changed.append(f"{candidate.session_id}:sessions->archives")
+        rebuilt = bool(changed)
+        if rebuilt:
+            rebuild_index(paths.root)
+    else:
+        rebuilt = False
+
+    return RetentionResult(
+        action="archive",
+        dry_run=not apply,
+        selected=selected,
+        protected=protected,
+        changed=changed,
+        rebuilt_index=rebuilt,
+    )
+
+
+def prune_sessions(
+    root: str | Path,
+    *,
+    sessions: list[str] | None = None,
+    older_than_days: int | None = None,
+    keep_recent: int | None = None,
+    include_live_sessions: bool = False,
+    apply: bool = False,
+) -> RetentionResult:
+    paths = init_root(root)
+    _validate_selectors(
+        sessions=sessions,
+        older_than_days=older_than_days,
+        keep_recent=keep_recent,
+        command="prune",
+    )
+    active_id = _active_session_id(paths.root)
+    candidates = _list_sessions(
+        paths.archives / "sessions",
+        store="archives",
+        active_session_id=active_id,
+    )
+    if include_live_sessions:
+        candidates.extend(
+            _list_sessions(paths.sessions, store="sessions", active_session_id=active_id)
+        )
+    selected, protected = _select_candidates(
+        candidates,
+        sessions=sessions,
+        older_than_days=older_than_days,
+        keep_recent=keep_recent,
+    )
+    _raise_on_exact_active("prune", sessions, protected)
+
+    changed: list[str] = []
+    live_changed = False
+    if apply:
+        for candidate in selected:
+            source = Path(candidate.path)
+            shutil.rmtree(source)
+            fsync_directory(source.parent)
+            changed.append(f"{candidate.session_id}:{candidate.store}->deleted")
+            live_changed = live_changed or candidate.store == "sessions"
+        if live_changed:
+            rebuild_index(paths.root)
+
+    return RetentionResult(
+        action="prune",
+        dry_run=not apply,
+        selected=selected,
+        protected=protected,
+        changed=changed,
+        rebuilt_index=apply and live_changed,
+    )
+
+
+def format_retention_result(result: RetentionResult) -> str:
+    mode = "dry-run" if result.dry_run else "applied"
+    lines = [
+        f"action={result.action}",
+        f"mode={mode}",
+        f"selected={len(result.selected)}",
+        f"protected={len(result.protected)}",
+        f"changed={len(result.changed)}",
+    ]
+    for candidate in result.selected:
+        lines.append(
+            f"selected: {candidate.session_id} store={candidate.store} events={candidate.event_count}"
+        )
+    for candidate in result.protected:
+        lines.append(f"protected: {candidate.session_id} store={candidate.store} active=true")
+    for changed in result.changed:
+        lines.append(f"changed: {changed}")
+    if result.rebuilt_index:
+        lines.append("rebuilt_index=true")
+    if result.dry_run and result.selected:
+        lines.append("rerun with --apply to perform this change")
+    return "\n".join(lines)
+
+
+def _validate_selectors(
+    *,
+    sessions: list[str] | None,
+    older_than_days: int | None,
+    keep_recent: int | None,
+    command: str,
+) -> None:
+    if not sessions and older_than_days is None and keep_recent is None:
+        raise AgentDirError(
+            f"{command} requires --session, --older-than-days, or --keep-recent"
+        )
+    if sessions and (older_than_days is not None or keep_recent is not None):
+        raise AgentDirError("Use --session or age/count filters, not both")
+    for session_id in sessions or []:
+        validate_id(session_id, "session id")
+    if older_than_days is not None and older_than_days < 0:
+        raise AgentDirError("--older-than-days must be non-negative")
+    if keep_recent is not None and keep_recent < 0:
+        raise AgentDirError("--keep-recent must be non-negative")
+
+
+def _active_session_id(root: Path) -> str | None:
+    try:
+        state = read_current_session(root)
+    except Exception:
+        return None
+    if state and state.status == "active":
+        return state.session_id
+    return None
+
+
+def _list_sessions(
+    directory: Path,
+    *,
+    store: str,
+    active_session_id: str | None,
+) -> list[RetentionCandidate]:
+    if not directory.is_dir():
+        return []
+    candidates: list[RetentionCandidate] = []
+    for session_dir in sorted(directory.iterdir()):
+        if not session_dir.is_dir() or not (session_dir / "Maildir").is_dir():
+            continue
+        event_paths = [
+            path
+            for state in ("new", "cur")
+            for path in (session_dir / "Maildir" / state).glob("*")
+            if path.is_file() and not path.name.startswith(".")
+        ]
+        latest_event_at = max((path.stat().st_mtime for path in event_paths), default=None)
+        if latest_event_at is None:
+            latest_event_at = session_dir.stat().st_mtime
+        candidates.append(
+            RetentionCandidate(
+                session_id=session_dir.name,
+                store=store,
+                path=str(session_dir),
+                event_count=len(event_paths),
+                latest_event_at=latest_event_at,
+                active=session_dir.name == active_session_id and store == "sessions",
+            )
+        )
+    return candidates
+
+
+def _select_candidates(
+    candidates: list[RetentionCandidate],
+    *,
+    sessions: list[str] | None,
+    older_than_days: int | None,
+    keep_recent: int | None,
+) -> tuple[list[RetentionCandidate], list[RetentionCandidate]]:
+    selected = _select_unprotected_candidates(
+        candidates,
+        sessions=sessions,
+        older_than_days=older_than_days,
+        keep_recent=keep_recent,
+    )
+    protected = [candidate for candidate in selected if candidate.active]
+    return [candidate for candidate in selected if not candidate.active], protected
+
+
+def _select_unprotected_candidates(
+    candidates: list[RetentionCandidate],
+    *,
+    sessions: list[str] | None,
+    older_than_days: int | None,
+    keep_recent: int | None,
+) -> list[RetentionCandidate]:
+    if sessions:
+        requested = set(sessions)
+        selected = [candidate for candidate in candidates if candidate.session_id in requested]
+        found = {candidate.session_id for candidate in selected}
+        missing = sorted(requested - found)
+        if missing:
+            raise AgentDirError(f"unknown session id(s): {', '.join(missing)}")
+        return selected
+
+    selected = list(candidates)
+    if older_than_days is not None:
+        cutoff = time.time() - (older_than_days * SECONDS_PER_DAY)
+        selected = [
+            candidate
+            for candidate in selected
+            if (candidate.latest_event_at or 0) <= cutoff
+        ]
+    if keep_recent is not None:
+        ordered = sorted(
+            candidates,
+            key=lambda candidate: (
+                candidate.latest_event_at or 0,
+                candidate.store,
+                candidate.session_id,
+            ),
+            reverse=True,
+        )
+        prune_keys = {
+            (candidate.store, candidate.session_id)
+            for candidate in ordered[keep_recent:]
+        }
+        selected = [
+            candidate
+            for candidate in selected
+            if (candidate.store, candidate.session_id) in prune_keys
+        ]
+    return selected
+
+
+def _raise_on_exact_active(
+    command: str,
+    sessions: list[str] | None,
+    protected: list[RetentionCandidate],
+) -> None:
+    if not sessions or not protected:
+        return
+    ids = ", ".join(candidate.session_id for candidate in protected)
+    raise AgentDirError(f"refusing to {command} active session(s): {ids}")