@event4u/agent-config 6.0.0 → 7.0.0

package/src/scripts/ci_status.py

@@ -1,301 +0,0 @@
-#!/usr/bin/env python3
-"""Wrap ``gh run list`` and assert the required-check set is green.
-
-Phase A Step 6 of ``road-to-adoption-proof-and-ci-green.md``. Sits
-between the maintainer and the GitHub UI so a one-line
-``task ci:status`` shows whether the required-check floor (as defined
-in ``docs/contracts/branch-protection-policy.md`` § Per-PR-shape
-required-check matrix) is green on the branch passed via ``--branch``.
-
-Phantom 0-job runs are filtered before the tally — they are listed
-under "advisory / phantom" in ``docs/contracts/ci-green-floor.md`` and
-must not freeze merges (the ``--strict`` flag honours this).
-
-CLI:
-
-  scripts/ci_status.py [--branch main] [--limit 30] [--strict]
-                       [--shape feature|release|docs] [--json]
-
-Exit codes:
-
-  0 — every required check on the most recent run is success
-      (or the matching workflow simply has not run yet under
-      ``--strict``; the gate distinguishes "missing" from "red").
-  1 — at least one required-check workflow is red or in a
-      terminal-non-success state.
-  2 — invalid arguments / unreachable gh CLI.
-
-The required-check shape vocabulary mirrors
-``branch-protection-policy.md`` exactly so a future ruleset edit in
-one place stays single-sourced.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import shutil
-import subprocess
-import sys
-from dataclasses import dataclass
-
-
-# Source-of-truth for the per-shape required-check set. Anchored to
-# the matrix in docs/contracts/branch-protection-policy.md § Per-PR-shape
-# required-check matrix. When that doc changes, this dict changes in
-# lockstep — a CI-side linter cross-checks the two surfaces.
-REQUIRED_CHECKS_BY_SHAPE: dict[str, set[str]] = {
-    "feature": {
-        "Consistency",
-        "Smoke Contracts",
-        "Skill Lint",
-        "Tests",
-        "Python Version Sweep",
-        "Public Install Smoke",
-    },
-    "release": {
-        "Consistency",
-        "Smoke Contracts",
-        "Release Validation",
-    },
-    "docs": {
-        "Consistency",
-        "Smoke Contracts",
-    },
-}
-
-
-@dataclass(frozen=True)
-class Run:
-    name: str
-    conclusion: str
-    status: str
-    jobs: int
-
-
-def fetch_runs(branch: str, limit: int) -> list[Run]:
-    """Call `gh run list` and return parsed Run records."""
-    if shutil.which("gh") is None:
-        raise SystemExit("error: gh CLI not found in PATH")
-    cmd = [
-        "gh",
-        "run",
-        "list",
-        "--branch",
-        branch,
-        "--limit",
-        str(limit),
-        "--json",
-        "databaseId,name,status,conclusion",
-    ]
-    try:
-        proc = subprocess.run(cmd, capture_output=True, text=True, check=True)
-    except subprocess.CalledProcessError as exc:
-        raise SystemExit(f"error: gh run list failed — {exc.stderr.strip()}")
-    raw = json.loads(proc.stdout or "[]")
-    runs: list[Run] = []
-    for r in raw:
-        # `gh run list` does not surface Jobs count — we need a second
-        # call per run id to find phantom 0-job runs. Keep that call to
-        # the runs that *would* be counted (non-success terminal) so the
-        # cost is bounded by the number of red runs, not the full window.
-        runs.append(
-            Run(
-                name=r.get("name", ""),
-                conclusion=r.get("conclusion", ""),
-                status=r.get("status", ""),
-                jobs=-1,  # unknown — resolved lazily for non-success runs
-            )
-        )
-    return runs
-
-
-def resolve_jobs_count(run_id: int) -> int:
-    """Return the number of jobs for a single run id (for phantom filter)."""
-    cmd = [
-        "gh",
-        "run",
-        "view",
-        str(run_id),
-        "--json",
-        "jobs",
-    ]
-    proc = subprocess.run(cmd, capture_output=True, text=True)
-    if proc.returncode != 0:
-        return -1
-    data = json.loads(proc.stdout or "{}")
-    return len(data.get("jobs", []))
-
-
-def is_phantom(run: Run) -> bool:
-    """True when the run has 0 jobs AND its conclusion is `failure`."""
-    if run.conclusion != "failure":
-        return False
-    if run.jobs == 0:
-        return True
-    return False
-
-
-def latest_per_workflow(runs: list[Run]) -> dict[str, Run]:
-    """Pick the latest run per workflow name (input order is mtime-desc)."""
-    out: dict[str, Run] = {}
-    for r in runs:
-        if r.name in out:
-            continue
-        if r.status != "completed":
-            # In-progress / queued runs are pending; treat as unknown.
-            continue
-        out[r.name] = r
-    return out
-
-
-def compute_status(
-    runs: list[Run],
-    required: set[str],
-    resolve_jobs: bool = True,
-) -> tuple[list[tuple[str, Run]], list[str], list[tuple[str, Run]]]:
-    """Return (greens, missing, reds-after-phantom-filter)."""
-    by_name = latest_per_workflow(runs)
-    greens: list[tuple[str, Run]] = []
-    reds: list[tuple[str, Run]] = []
-    missing: list[str] = []
-    for name in sorted(required):
-        run = by_name.get(name)
-        if run is None:
-            missing.append(name)
-            continue
-        if run.conclusion == "success":
-            greens.append((name, run))
-            continue
-        # Non-success — check for phantom 0-job.
-        if resolve_jobs and run.jobs < 0:
-            # Resolve the jobs count for this single run lazily.
-            # We don't have the database id in our Run records (the JSON
-            # field is `databaseId` and we dropped it for brevity); refetch
-            # the latest red run for this workflow by name.
-            run_id = _latest_run_id_for_workflow(name, run)
-            jobs_count = resolve_jobs_count(run_id) if run_id else -1
-            run = Run(
-                name=run.name,
-                conclusion=run.conclusion,
-                status=run.status,
-                jobs=jobs_count,
-            )
-        if is_phantom(run):
-            # Phantom — filter out; treat as success-equivalent for gating.
-            greens.append((name, run))
-        else:
-            reds.append((name, run))
-    return greens, missing, reds
-
-
-# Cache for the lazy run-id lookup; keyed by workflow name + conclusion.
-_RUN_ID_CACHE: dict[tuple[str, str], int | None] = {}
-
-
-def _latest_run_id_for_workflow(name: str, run: Run) -> int | None:
-    """Refetch the latest run id for a workflow whose top-of-list run is non-success."""
-    key = (name, run.conclusion)
-    if key in _RUN_ID_CACHE:
-        return _RUN_ID_CACHE[key]
-    cmd = [
-        "gh",
-        "run",
-        "list",
-        "--workflow",
-        name,
-        "--limit",
-        "1",
-        "--json",
-        "databaseId",
-    ]
-    proc = subprocess.run(cmd, capture_output=True, text=True)
-    if proc.returncode != 0:
-        _RUN_ID_CACHE[key] = None
-        return None
-    data = json.loads(proc.stdout or "[]")
-    if not data:
-        _RUN_ID_CACHE[key] = None
-        return None
-    rid = int(data[0].get("databaseId", 0)) or None
-    _RUN_ID_CACHE[key] = rid
-    return rid
-
-
-def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
-    p = argparse.ArgumentParser(
-        prog="ci_status",
-        description="Assert the required-check set is green on a branch.",
-    )
-    p.add_argument(
-        "--branch",
-        default="main",
-        help="Branch to check (default: main).",
-    )
-    p.add_argument(
-        "--limit",
-        type=int,
-        default=30,
-        help="Number of recent runs to scan (default: 30).",
-    )
-    p.add_argument(
-        "--shape",
-        choices=["feature", "release", "docs"],
-        default="feature",
-        help="PR shape (default: feature) — picks the required-check set.",
-    )
-    p.add_argument(
-        "--strict",
-        action="store_true",
-        help="Exit non-zero if any required check is missing (not just red).",
-    )
-    p.add_argument(
-        "--json",
-        action="store_true",
-        help="Emit JSON instead of human-readable text.",
-    )
-    p.add_argument(
-        "--no-phantom-resolve",
-        action="store_true",
-        help="Skip the lazy 0-job lookup (faster but lets phantoms through).",
-    )
-    return p.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = parse_args(argv)
-    required = REQUIRED_CHECKS_BY_SHAPE[args.shape]
-    runs = fetch_runs(args.branch, args.limit)
-    greens, missing, reds = compute_status(
-        runs,
-        required,
-        resolve_jobs=not args.no_phantom_resolve,
-    )
-
-    if args.json:
-        out = {
-            "branch": args.branch,
-            "shape": args.shape,
-            "required": sorted(required),
-            "green": [name for name, _ in greens],
-            "missing": missing,
-            "red": [{"name": name, "conclusion": run.conclusion} for name, run in reds],
-        }
-        print(json.dumps(out, indent=2))
-    else:
-        print(f"branch={args.branch} shape={args.shape} required={len(required)}")
-        for name, _ in greens:
-            print(f"  ✅  {name}")
-        for name in missing:
-            print(f"  ⚠️   {name} — no run found on this branch (last {args.limit})")
-        for name, run in reds:
-            print(f"  ❌  {name} — {run.conclusion}")
-
-    if reds:
-        return 1
-    if args.strict and missing:
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/ci_summary.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python3
-"""
-CI Summary — render a GitHub Step Summary from dispatcher run results.
-
-Consumes JSON files produced by `scripts/runtime_dispatcher.py run
---output FILE`. Each file is an ExecutionResult dump (see runtime_handler).
-
-Usage:
-    python3 scripts/ci_summary.py --runs agents/runtime/reports/runs [--title TITLE]
-
-Writes to $GITHUB_STEP_SUMMARY if the environment variable is set,
-otherwise prints the markdown to stdout. Missing or empty run
-directories render a short "no runs" note and exit 0.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-from pathlib import Path
-from typing import List, Dict
-
-
-def load_runs(runs_dir: Path) -> List[Dict]:
-    """Load every *.json in runs_dir as an ExecutionResult dict. Sorted by filename."""
-    if not runs_dir.is_dir():
-        return []
-    runs: List[Dict] = []
-    for path in sorted(runs_dir.glob("*.json")):
-        try:
-            runs.append(json.loads(path.read_text(encoding="utf-8")))
-        except (OSError, json.JSONDecodeError):
-            # Skip unreadable/malformed files — CI still reports the rest.
-            continue
-    return runs
-
-
-_STATUS_ICON = {
-    "success": "✅",
-    "failure": "❌",
-    "timeout": "⏱️",
-    "error": "⚠️",
-}
-
-
-def render_summary(runs: List[Dict], title: str) -> str:
-    """Render a markdown summary for the given runs."""
-    lines: List[str] = [f"## {title}", ""]
-
-    if not runs:
-        lines.append("*No dispatcher runs recorded in this job.*")
-        lines.append("")
-        return "\n".join(lines)
-
-    total = len(runs)
-    passed = sum(1 for r in runs if r.get("status") == "success")
-    failed = total - passed
-
-    lines.append(f"- Runs: **{total}**  ·  Passed: **{passed}**  ·  Failed: **{failed}**")
-    lines.append("")
-    lines.append("| Skill | Status | Exit | Duration |")
-    lines.append("|---|---|---:|---:|")
-    for r in runs:
-        status = str(r.get("status", "?"))
-        icon = _STATUS_ICON.get(status, "•")
-        duration_ms = r.get("duration_ms", 0) or 0
-        lines.append(
-            f"| `{r.get('skill_name', '?')}` "
-            f"| {icon} {status} "
-            f"| {r.get('exit_code', '?')} "
-            f"| {duration_ms} ms |"
-        )
-
-    failures = [r for r in runs if r.get("status") != "success"]
-    if failures:
-        lines.append("")
-        lines.append("### Failure details")
-        for r in failures:
-            name = r.get("skill_name", "?")
-            lines.append(f"<details><summary><code>{name}</code></summary>")
-            err = r.get("error")
-            if err:
-                lines.append("")
-                lines.append(f"**Error:** {err}")
-            stderr = (r.get("stderr") or "").rstrip()
-            if stderr:
-                lines.append("")
-                lines.append("```")
-                lines.append(stderr[-1500:])
-                lines.append("```")
-            lines.append("</details>")
-
-    lines.append("")
-    return "\n".join(lines)
-
-
-def write_output(summary: str) -> bool:
-    """Append to $GITHUB_STEP_SUMMARY if set; return True when the env path was used."""
-    path = os.environ.get("GITHUB_STEP_SUMMARY")
-    if not path:
-        return False
-    with open(path, "a", encoding="utf-8") as fh:
-        fh.write(summary)
-        if not summary.endswith("\n"):
-            fh.write("\n")
-    return True
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Render CI summary from dispatcher runs")
-    parser.add_argument(
-        "--runs", type=Path, default=Path("agents/runtime/reports/runs"),
-        help="Directory containing ExecutionResult JSON files",
-    )
-    parser.add_argument(
-        "--title", default="🤖 Dispatcher runs",
-        help="Section title for the summary",
-    )
-    args = parser.parse_args()
-
-    runs = load_runs(args.runs)
-    summary = render_summary(runs, args.title)
-
-    if not write_output(summary):
-        print(summary)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/ci_time_ratio.py

@@ -1,168 +0,0 @@
-#!/usr/bin/env python3
-"""CI-time / local-edit-time ratio (council file 07, Phase 2.3).
-
-Samples the last N commits on a branch, classifies each by touched
-paths (doc / skill / test / meta / mixed), and computes:
-
-    ratio = ci_time / local_time
-
-where:
-- `local_time` = delta between author-date of the *previous* commit and
-  author-date of the current commit, capped at 60 min to filter breaks.
-- `ci_time`  = sum of GitHub Actions workflow durations for that commit
-  sha (via `gh run list --commit <sha>`).
-
-Threshold rule (Round-3 Sonnet protocol):
-- Median ratio > 5× for any frequent class → that class needs a cheaper tier
-- Median ratio < 3× across all classes      → structural overhead acceptable
-
-Output: human-readable table on stdout + JSON to
-`agents/runtime/reports/ci-time-ratio.json`.
-
-Usage:
-    python3 scripts/ci_time_ratio.py --limit 30
-    python3 scripts/ci_time_ratio.py --branch main --limit 30 --out path.json
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import statistics
-import subprocess
-import sys
-from collections import defaultdict
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-DEFAULT_OUT = REPO_ROOT / "agents" / "reports" / "ci-time-ratio.json"
-
-LOCAL_TIME_CAP_S = 60 * 60          # cap a single edit window at 60 min
-THRESHOLD_FAIL = 5.0
-THRESHOLD_PASS = 3.0
-
-
-def run(cmd: list[str]) -> str:
-    return subprocess.check_output(cmd, cwd=REPO_ROOT, text=True)
-
-
-def list_commits(branch: str, limit: int) -> list[dict]:
-    out = run(["git", "log", branch, f"-n{limit + 1}",
-               "--format=%H\t%at\t%s"]).strip().splitlines()
-    rows = []
-    for line in out:
-        sha, ts, subject = line.split("\t", 2)
-        rows.append({"sha": sha, "timestamp": int(ts), "subject": subject})
-    return rows
-
-
-def classify(sha: str) -> str:
-    files = run(["git", "show", "--name-only", "--format=", sha]).strip().splitlines()
-    files = [f for f in files if f]
-    if not files:
-        return "empty"
-    doc = sum(1 for f in files if f.startswith("docs/") or f.endswith(".md"))
-    skill = sum(1 for f in files if "/skills/" in f or f.startswith(".agent-src.uncondensed/skills/"))
-    test = sum(1 for f in files if f.startswith("tests/") or "/tests/" in f)
-    meta = sum(1 for f in files if f.startswith(("Taskfile", "src/scripts/", ".github/", "pyproject", "package")))
-    total = len(files)
-    # Single-class dominance: 70% of touched files in one bucket
-    for label, n in [("skill", skill), ("test", test), ("doc", doc), ("meta", meta)]:
-        if n >= max(1, int(total * 0.7)):
-            return label
-    return "mixed"
-
-
-def ci_duration_for(sha: str) -> int | None:
-    """Total wall-clock seconds for all completed runs of this commit."""
-    try:
-        out = run(["gh", "run", "list", "--commit", sha, "--limit", "20",
-                   "--json", "createdAt,updatedAt,status,conclusion"])
-    except subprocess.CalledProcessError:
-        return None
-    runs = json.loads(out)
-    if not runs:
-        return None
-    durations = []
-    for r in runs:
-        if r.get("status") != "completed":
-            continue
-        from datetime import datetime
-        c = datetime.fromisoformat(r["createdAt"].replace("Z", "+00:00"))
-        u = datetime.fromisoformat(r["updatedAt"].replace("Z", "+00:00"))
-        durations.append((u - c).total_seconds())
-    if not durations:
-        return None
-    # Workflows run in parallel — wall-clock is the max, not the sum.
-    return int(max(durations))
-
-
-def collect(branch: str, limit: int) -> list[dict]:
-    commits = list_commits(branch, limit)
-    if len(commits) < 2:
-        return []
-    rows = []
-    for i in range(len(commits) - 1):
-        cur, prev = commits[i], commits[i + 1]
-        local_s = min(cur["timestamp"] - prev["timestamp"], LOCAL_TIME_CAP_S)
-        if local_s < 30:
-            continue
-        ci_s = ci_duration_for(cur["sha"])
-        if ci_s is None:
-            continue
-        cls = classify(cur["sha"])
-        rows.append({
-            "sha": cur["sha"][:10], "class": cls,
-            "local_s": local_s, "ci_s": ci_s,
-            "ratio": round(ci_s / local_s, 2) if local_s else None,
-            "subject": cur["subject"][:80],
-        })
-    return rows
-
-
-def summarise(rows: list[dict]) -> dict:
-    by_class: dict[str, list[float]] = defaultdict(list)
-    for r in rows:
-        if r["ratio"] is not None:
-            by_class[r["class"]].append(r["ratio"])
-    summary = {}
-    for cls, ratios in sorted(by_class.items()):
-        m = statistics.median(ratios)
-        if m > THRESHOLD_FAIL:
-            verdict = "optimise"
-        elif m < THRESHOLD_PASS:
-            verdict = "acceptable"
-        else:
-            verdict = "watch"
-        summary[cls] = {"n": len(ratios), "median": round(m, 2),
-                        "min": round(min(ratios), 2), "max": round(max(ratios), 2),
-                        "verdict": verdict}
-    all_ratios = [r["ratio"] for r in rows if r["ratio"] is not None]
-    overall = {"n": len(all_ratios),
-               "median": round(statistics.median(all_ratios), 2) if all_ratios else None,
-               "verdict": ("acceptable" if all_ratios and statistics.median(all_ratios) < THRESHOLD_PASS
-                          else "needs-review" if all_ratios else "no-data")}
-    return {"overall": overall, "by_class": summary}
-
-
-def main() -> int:
-    p = argparse.ArgumentParser()
-    p.add_argument("--branch", default="HEAD")
-    p.add_argument("--limit", type=int, default=30)
-    p.add_argument("--out", type=Path, default=DEFAULT_OUT)
-    args = p.parse_args()
-    rows = collect(args.branch, args.limit)
-    report = summarise(rows)
-    report["sample"] = rows
-    args.out.parent.mkdir(parents=True, exist_ok=True)
-    args.out.write_text(json.dumps(report, indent=2) + "\n")
-    print(f"✅  Wrote {args.out.relative_to(REPO_ROOT)}  (n={report['overall']['n']})")
-    ov = report["overall"]
-    print(f"   overall median ratio: {ov['median']}×  →  {ov['verdict']}")
-    for cls, s in report["by_class"].items():
-        print(f"   {cls:7}  n={s['n']:2}  median={s['median']:.2f}×  range=[{s['min']}–{s['max']}]  {s['verdict']}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/command_suggester/__init__.py

@@ -1,51 +0,0 @@
-"""Context-aware command suggestion engine.
-
-Public API exposed for the always-on `command-suggestion` rule and for
-tests. The engine is **deterministic** and **read-only**: it scores
-candidate commands against a user message + recent context, applies
-ranking, suppresses cooled-down suggestions, and renders a numbered
-options block. It never executes a command — the user pick is what
-triggers the standard slash flow.
-
-See `agents/settings/contexts/command-suggestion-eligibility.md` for the
-locked eligibility table and `road-to-context-aware-command-suggestion`
-for the full design.
-"""
-from .types import CommandSpec, Match, Settings, CooldownState
-from .loader import load_commands
-from .match import match
-from .rank import rank
-from .cooldown import (
-    apply_cooldown,
-    CooldownStore,
-    detect_disable_directive,
-    is_explicit_slash_invocation,
-)
-from .render import render
-from .sanitize import (
-    sanitize_context,
-    sanitize_message,
-    strip_code_blocks,
-    strip_suggestion_echo,
-)
-from .settings import load_settings
-
-__all__ = [
-    "CommandSpec",
-    "Match",
-    "Settings",
-    "CooldownState",
-    "CooldownStore",
-    "load_commands",
-    "load_settings",
-    "match",
-    "rank",
-    "apply_cooldown",
-    "detect_disable_directive",
-    "is_explicit_slash_invocation",
-    "render",
-    "sanitize_context",
-    "sanitize_message",
-    "strip_code_blocks",
-    "strip_suggestion_echo",
-]