@event4u/agent-config 1.14.0 → 1.16.0

package/scripts/ai_council/_one_off_roundtrip.py

@@ -0,0 +1,106 @@
+"""One-off Phase-1 round-trip runner.
+
+Used exactly once to generate the evidence artefact required to lift
+the capture-only fence on `road-to-ai-council.md` Phase 2+ and the
+end-to-end verification on `road-to-council-modes.md` Phase 2a.
+
+Not part of the public CLI surface — `/council` remains the supported
+entry point. This script is committed under `scripts/ai_council/` so
+the evidence is reproducible from the git history alone.
+
+Invocation:
+    .venv/bin/python -m scripts.ai_council._one_off_roundtrip
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from scripts.ai_council.bundler import bundle_roadmap
+from scripts.ai_council.clients import AnthropicClient, load_anthropic_key
+from scripts.ai_council.orchestrator import (
+    CostBudget,
+    CouncilQuestion,
+    consult,
+    estimate,
+)
+from scripts.ai_council.pricing import estimate_cost, load_prices
+from scripts.ai_council.project_context import detect_project_context
+from scripts.ai_council.session import SessionManifest, save as save_session
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+ROADMAP_PATH = REPO_ROOT / "agents/roadmaps/road-to-council-modes.md"
+
+ORIGINAL_ASK = (
+    "Bitte review die folgende Roadmap (council-modes Phase 2c "
+    "Playwright). Die Maintainer-Recommendations für Q1-Q5 sind im "
+    "Block 'Decisions Required' bereits hinterlegt. Frage: sollten "
+    "wir die Recommendations annehmen wie sie sind, oder gibt es "
+    "blinde Flecken die wir vor dem Lift der capture-only fence "
+    "kläeren sollten?"
+)
+
+
+def main() -> int:
+    api_key = load_anthropic_key()
+    client = AnthropicClient(api_key=api_key)
+
+    context = bundle_roadmap(ROADMAP_PATH)
+    project = detect_project_context(REPO_ROOT)
+    table = load_prices()
+
+    question = CouncilQuestion(
+        mode="roadmap",
+        user_prompt=context.text,
+        max_tokens=2048,
+    )
+
+    estimates = estimate(
+        question, [client], table,
+        project=project, original_ask=ORIGINAL_ASK,
+    )
+    print(f"[estimate] {client.name}/{client.model}: "
+          f"~{estimates[0].input_tokens} in + {estimates[0].output_tokens} out "
+          f"= ${estimates[0].total_usd:.4f}")
+
+    budget = CostBudget(
+        max_input_tokens=50_000,
+        max_output_tokens=20_000,
+        max_calls=10,
+        max_total_usd=0.50,
+    )
+
+    print(f"[consult] calling {client.name}/{client.model} ...")
+    responses = consult(
+        [client], question, budget,
+        table=table, project=project, original_ask=ORIGINAL_ASK,
+    )
+
+    if not responses or responses[0].error:
+        err = responses[0].error if responses else "no response"
+        print(f"[error] {err}", file=sys.stderr)
+        return 1
+
+    r = responses[0]
+    actual = estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, table)
+    actual_usd = actual.total_usd
+    print(f"[done] tokens: {r.input_tokens} in / {r.output_tokens} out · "
+          f"latency: {r.latency_ms} ms · actual ${actual_usd:.4f}")
+
+    manifest = SessionManifest(
+        mode="roadmap",
+        artefact=str(ROADMAP_PATH.relative_to(REPO_ROOT)),
+        original_ask=ORIGINAL_ASK,
+        members=[f"{r.provider}/{r.model}"],
+        rounds=1,
+        cost_usd_estimated=estimates[0].total_usd,
+        cost_usd_actual=actual_usd,
+        extra={"purpose": "Phase 1 ai-council round-trip + Phase 2a council-modes E2E evidence"},
+    )
+    session_dir = save_session(manifest=manifest, responses=responses)
+    print(f"[saved] {session_dir.relative_to(REPO_ROOT)}/")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/ai_council/budget_guard.py

@@ -0,0 +1,172 @@
+"""Per-day rolling cost-budget guard for the council (D3).
+
+Adds a 24h-rolling-window USD limit on top of the per-session caps in
+`orchestrator.CostBudget`. Persists a small JSONL ledger in
+``~/.config/agent-config/council-spend.jsonl`` (mode 0600, same
+permission discipline as the API keys).
+
+Contract
+- The ledger is **append-only**. Each line is ``{"ts": ISO-8601 UTC,
+  "usd": float, "provider": str, "model": str}``.
+- ``today_spend_usd()`` sums entries within the last 24h from "now"
+  (true rolling window — not midnight UTC, never resets at boundary
+  surprise).
+- ``would_exceed(limit_usd, next_call_usd)`` returns True iff the next
+  call would push the rolling window past the limit.
+- ``record_spend(usd, provider, model)`` appends a single entry; never
+  raises on disk failure (logs to stderr, returns False).
+
+The guard is **advisory** to the orchestrator: it provides a check
+function the host agent can call before each council member; the
+orchestrator's per-session cost gate stays the primary defence.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import json
+import os
+import stat
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+LEDGER_PATH = Path.home() / ".config" / "agent-config" / "council-spend.jsonl"
+ROLLING_WINDOW_HOURS = 24
+
+
+@dataclass
+class SpendEntry:
+    ts: _dt.datetime  # UTC, tz-aware
+    usd: float
+    provider: str
+    model: str
+
+
+def _now_utc() -> _dt.datetime:
+    return _dt.datetime.now(_dt.timezone.utc)
+
+
+def _ensure_ledger_dir(path: Path) -> bool:
+    """Create the ledger's parent directory mode 0700 if missing."""
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        if (path.parent.stat().st_mode & 0o777) != 0o700:
+            try:
+                os.chmod(path.parent, 0o700)
+            except OSError:
+                # On macOS ~/.config may inherit umask perms; do not block.
+                pass
+        return True
+    except OSError as exc:  # noqa: BLE001 - never block the orchestrator
+        print(f"[council:budget_guard] mkdir failed: {exc}", file=sys.stderr)
+        return False
+
+
+def _ensure_ledger_file_mode(path: Path) -> None:
+    """Make sure an existing ledger file is mode 0600. Best-effort."""
+    if not path.exists():
+        return
+    current = path.stat().st_mode & 0o777
+    if current != 0o600:
+        try:
+            os.chmod(path, 0o600)
+        except OSError:
+            pass
+
+
+def _parse_iso(ts: str) -> _dt.datetime | None:
+    try:
+        # `fromisoformat` accepts "+00:00"; we always write with "+00:00".
+        return _dt.datetime.fromisoformat(ts)
+    except ValueError:
+        return None
+
+
+def read_entries(path: Path | None = None) -> list[SpendEntry]:
+    """Read every well-formed entry from the ledger.
+
+    Malformed lines are skipped silently. Empty/missing ledger → [].
+    """
+    p = path or LEDGER_PATH
+    if not p.exists():
+        return []
+    out: list[SpendEntry] = []
+    for line in p.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            obj = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        ts = _parse_iso(str(obj.get("ts", "")))
+        if ts is None:
+            continue
+        try:
+            usd = float(obj.get("usd", 0))
+        except (TypeError, ValueError):
+            continue
+        out.append(SpendEntry(
+            ts=ts, usd=usd,
+            provider=str(obj.get("provider", "")),
+            model=str(obj.get("model", "")),
+        ))
+    return out
+
+
+def today_spend_usd(
+    *,
+    path: Path | None = None,
+    now: _dt.datetime | None = None,
+    window_hours: int = ROLLING_WINDOW_HOURS,
+) -> float:
+    """Sum of USD spent in the last `window_hours` (rolling window)."""
+    cutoff = (now or _now_utc()) - _dt.timedelta(hours=window_hours)
+    return sum(e.usd for e in read_entries(path) if e.ts >= cutoff)
+
+
+def would_exceed(
+    limit_usd: float,
+    next_call_usd: float,
+    *,
+    path: Path | None = None,
+    now: _dt.datetime | None = None,
+    window_hours: int = ROLLING_WINDOW_HOURS,
+) -> bool:
+    """True iff appending `next_call_usd` would push the window past `limit_usd`.
+
+    `limit_usd <= 0` disables the guard (returns False). Mirrors the
+    `CostBudget.max_total_usd` convention.
+    """
+    if limit_usd <= 0:
+        return False
+    spent = today_spend_usd(path=path, now=now, window_hours=window_hours)
+    return (spent + next_call_usd) > limit_usd
+
+
+def record_spend(
+    usd: float,
+    provider: str,
+    model: str,
+    *,
+    path: Path | None = None,
+    now: _dt.datetime | None = None,
+) -> bool:
+    """Append one entry to the ledger. Returns True on success."""
+    if usd <= 0:
+        return True  # zero-cost calls (manual mode) skip the ledger
+    p = path or LEDGER_PATH
+    if not _ensure_ledger_dir(p):
+        return False
+    ts = (now or _now_utc()).isoformat()
+    entry = json.dumps({"ts": ts, "usd": round(usd, 6),
+                        "provider": provider, "model": model}) + "\n"
+    try:
+        with p.open("a", encoding="utf-8") as fh:
+            fh.write(entry)
+    except OSError as exc:  # noqa: BLE001 - never block the orchestrator
+        print(f"[council:budget_guard] write failed: {exc}", file=sys.stderr)
+        return False
+    _ensure_ledger_file_mode(p)
+    return True

package/scripts/ai_council/bundler.py

@@ -0,0 +1,261 @@
+"""Context bundling for council consultations.
+
+Takes a raw artefact (free-form prompt, roadmap path, diff range, or
+file set) and produces a `CouncilContext` — a redacted, size-bounded
+text bundle plus a manifest describing exactly what was included.
+
+Hard rules:
+- Redaction is fail-closed. If a redaction pattern fires, the line is
+  scrubbed *before* the bundle is built.
+- Size guard is fail-loud. > MAX_BUNDLE_BYTES → raises BundleTooLarge,
+  never silently truncates (would mislead council members).
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+MAX_BUNDLE_BYTES = 50 * 1024  # 50 KB hard ceiling; user must narrow scope on hit.
+
+
+class BundleTooLarge(RuntimeError):
+    """Raised when the assembled bundle exceeds MAX_BUNDLE_BYTES."""
+
+
+@dataclass
+class CouncilContext:
+    mode: str  # one of: prompt, roadmap, diff, files
+    text: str
+    manifest: list[str] = field(default_factory=list)
+    excluded: list[str] = field(default_factory=list)
+
+
+# ── redaction patterns ───────────────────────────────────────────────────
+# Each pattern is matched line-wise; matching lines are replaced with the
+# placeholder. Order matters — the most specific pattern goes first.
+
+_REDACTION_LINE_PATTERNS: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r".*~?/?\.config/agent-config/[^/\s]+\.key.*"),
+     "[redacted: agent-config key path]"),
+    (re.compile(r"^\s*Authorization:\s.*", re.IGNORECASE),
+     "[redacted: Authorization header]"),
+    (re.compile(r"(?i).*(api[_-]?key|secret|token|password)\s*[:=].*"),
+     "[redacted: secret-like assignment]"),
+    (re.compile(r"sk-ant-[A-Za-z0-9_\-]{8,}"), "[redacted: anthropic-key-like token]"),
+    (re.compile(r"sk-[A-Za-z0-9_\-]{20,}"), "[redacted: openai-key-like token]"),
+]
+
+
+def redact(text: str) -> str:
+    """Apply redaction patterns to a multi-line text buffer."""
+    out: list[str] = []
+    for line in text.splitlines():
+        replaced = line
+        for pattern, placeholder in _REDACTION_LINE_PATTERNS:
+            if pattern.search(replaced):
+                replaced = placeholder
+                break
+        out.append(replaced)
+    return "\n".join(out)
+
+
+def _enforce_size(text: str, mode: str) -> str:
+    encoded = text.encode("utf-8")
+    if len(encoded) > MAX_BUNDLE_BYTES:
+        raise BundleTooLarge(
+            f"Bundle for {mode!r} mode is {len(encoded)} bytes "
+            f"(> {MAX_BUNDLE_BYTES} hard ceiling). "
+            "Narrow the scope (smaller diff, fewer files, shorter prompt)."
+        )
+    return text
+
+
+def bundle_prompt(text: str) -> CouncilContext:
+    redacted = redact(text)
+    return CouncilContext(
+        mode="prompt",
+        text=_enforce_size(redacted, "prompt"),
+        manifest=["<inline prompt>"],
+    )
+
+
+def bundle_roadmap(path: str | Path) -> CouncilContext:
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(f"Roadmap not found: {p}")
+    raw = p.read_text(encoding="utf-8")
+    redacted = redact(raw)
+    return CouncilContext(
+        mode="roadmap",
+        text=_enforce_size(redacted, "roadmap"),
+        manifest=[str(p)],
+        excluded=["<linked contracts/skills not included by default>"],
+    )
+
+
+def bundle_diff(base_ref: str, head_ref: str = "HEAD", cwd: str | Path | None = None) -> CouncilContext:
+    cmd = ["git", "diff", f"{base_ref}..{head_ref}"]
+    try:
+        proc = subprocess.run(
+            cmd, cwd=cwd, check=True, capture_output=True, text=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        raise RuntimeError(
+            f"git diff {base_ref}..{head_ref} failed: {exc.stderr.strip()}"
+        ) from exc
+    redacted = redact(proc.stdout)
+    return CouncilContext(
+        mode="diff",
+        text=_enforce_size(redacted, "diff"),
+        manifest=[f"git diff {base_ref}..{head_ref}"],
+    )
+
+
+# ── smart diff context (D4) ─────────────────────────────────────────────────
+# Language-agnostic signature detection. Order matters — most specific first.
+
+_SIGNATURE_PATTERNS: list[re.Pattern[str]] = [
+    re.compile(r"^\s*(?:async\s+)?def\s+\w+\s*\("),  # Python
+    re.compile(r"^\s*class\s+\w+\b"),  # Python / PHP / JS class
+    re.compile(r"^\s*(?:public|protected|private|static|abstract|final)\s+(?:static\s+)?function\s+\w+"),  # PHP method
+    re.compile(r"^\s*function\s+\w+\s*\("),  # PHP free function / JS
+    re.compile(r"^\s*export\s+(?:default\s+)?(?:async\s+)?function\s+\w+"),  # TS/JS export fn
+    re.compile(r"^\s*export\s+(?:default\s+)?class\s+\w+"),  # TS/JS export class
+    re.compile(r"^\s*(?:export\s+)?(?:const|let)\s+\w+\s*=\s*(?:async\s+)?\("),  # TS arrow fn
+    re.compile(r"^\s*(?:public|private|protected)\s+\w+\s*\("),  # TS method
+]
+
+_HUNK_HEADER = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@")
+_DIFF_FILE = re.compile(r"^\+\+\+ b/(.+)$")
+
+
+def _parse_diff_hunks(diff_text: str) -> list[tuple[str, int]]:
+    """Return [(file_path, new_start_line), ...] per hunk in input order."""
+    out: list[tuple[str, int]] = []
+    current_file: str | None = None
+    for line in diff_text.splitlines():
+        m = _DIFF_FILE.match(line)
+        if m:
+            current_file = m.group(1)
+            continue
+        h = _HUNK_HEADER.match(line)
+        if h and current_file and current_file != "/dev/null":
+            out.append((current_file, int(h.group(1))))
+    return out
+
+
+def _enclosing_signature(
+    file_text: str, target_line: int,
+) -> tuple[int, str] | None:
+    """Walk backwards from `target_line` (1-based) to nearest signature."""
+    lines = file_text.splitlines()
+    start = min(target_line - 1, len(lines) - 1)
+    for idx in range(start, -1, -1):
+        line = lines[idx]
+        for pat in _SIGNATURE_PATTERNS:
+            if pat.match(line):
+                return (idx + 1, line.rstrip())
+    return None
+
+
+def bundle_diff_with_context(
+    base_ref: str,
+    head_ref: str = "HEAD",
+    cwd: str | Path | None = None,
+    *,
+    max_context_bytes: int = 8 * 1024,
+) -> CouncilContext:
+    """Bundle a diff plus the nearest enclosing signatures for each hunk.
+
+    Appends a `## Surrounding signatures` section after the raw diff.
+    Signatures are detected by regex across PY / PHP / JS / TS. Reads
+    files from the working tree (correct when `head_ref` == HEAD); if
+    a touched file is missing on disk it is silently dropped from the
+    context section (the diff itself still shows the change).
+
+    Hard cap: `max_context_bytes` for the signature section. Combined
+    output still goes through `_enforce_size`, so the `BundleTooLarge`
+    behaviour is unchanged.
+    """
+    base = bundle_diff(base_ref, head_ref, cwd=cwd)
+    hunks = _parse_diff_hunks(base.text)
+    if not hunks:
+        return base
+
+    root = Path(cwd) if cwd else Path(".")
+    seen: set[tuple[str, int]] = set()  # (file, signature_line)
+    by_file: dict[str, list[tuple[int, str]]] = {}
+
+    for file_path, new_start in hunks:
+        target = root / file_path
+        try:
+            file_text = target.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        sig = _enclosing_signature(file_text, new_start)
+        if sig is None:
+            continue
+        key = (file_path, sig[0])
+        if key in seen:
+            continue
+        seen.add(key)
+        by_file.setdefault(file_path, []).append(sig)
+
+    if not by_file:
+        return base
+
+    out_lines: list[str] = ["", "## Surrounding signatures", ""]
+    truncated = False
+    used = 0
+    for file_path, sigs in by_file.items():
+        header = f"### {file_path}"
+        sig_block = "\n".join(f"    L{ln}: {text}" for ln, text in sorted(sigs))
+        chunk = f"{header}\n\n{sig_block}\n\n"
+        if used + len(chunk.encode("utf-8")) > max_context_bytes:
+            truncated = True
+            break
+        out_lines.append(header)
+        out_lines.append("")
+        out_lines.append(sig_block)
+        out_lines.append("")
+        used += len(chunk.encode("utf-8"))
+
+    if truncated:
+        out_lines.append(f"[truncated: signature section capped at {max_context_bytes} bytes]")
+
+    combined = base.text + "\n" + "\n".join(out_lines)
+    redacted = redact(combined)
+    return CouncilContext(
+        mode="diff",
+        text=_enforce_size(redacted, "diff"),
+        manifest=base.manifest + [f"+ surrounding signatures for {len(by_file)} file(s)"],
+    )
+
+
+def bundle_files(paths: list[str | Path]) -> CouncilContext:
+    parts: list[str] = []
+    manifest: list[str] = []
+    excluded: list[str] = []
+    for raw_path in paths:
+        p = Path(raw_path)
+        if not p.exists():
+            excluded.append(f"{p} (not found)")
+            continue
+        try:
+            content = p.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as exc:
+            excluded.append(f"{p} ({type(exc).__name__})")
+            continue
+        parts.append(f"### {p}\n\n{content}\n")
+        manifest.append(str(p))
+    bundled = "\n".join(parts)
+    redacted = redact(bundled)
+    return CouncilContext(
+        mode="files",
+        text=_enforce_size(redacted, "files"),
+        manifest=manifest,
+        excluded=excluded,
+    )