@event4u/agent-config 6.1.0 → 7.0.0

package/src/scripts/_pilot_measure.py

@@ -1,53 +0,0 @@
-"""Pilot condensation ratio + Iron-Law checksum verification (one-off, not CI)."""
-import sys, re, hashlib, statistics
-from pathlib import Path
-
-sys.path.insert(0, "src/scripts")
-from measure_rule_budget import strip_frontmatter
-
-FENCE_RE = re.compile(r"```(?:[^\n]*\n)([\s\S]*?)```")
-
-
-def iron_law_sha(body: str) -> str:
-    blocks = FENCE_RE.findall(body)
-    norm = "".join(re.sub(r"\s+", " ", b).strip().upper() for b in blocks)
-    return hashlib.sha256(norm.encode()).hexdigest()[:16]
-
-
-pairs = [
-    ("agent-authority",   ".agent-src.uncondensed/rules/agent-authority.md",   "docs/contracts/pilot/agent-authority.md"),
-    ("direct-answers",    ".agent-src.uncondensed/rules/direct-answers.md",    "docs/contracts/pilot/direct-answers.md"),
-    ("language-and-tone", ".agent-src.uncondensed/rules/language-and-tone.md", "docs/contracts/pilot/language-and-tone.md"),
-]
-
-header = f"{'rule':25s} {'orig':>6s}  {'pilot':>6s}  {'r':>6s}  {'budget':>7s}  {'sha-orig':>16s}  {'sha-pilot':>16s}  {'IL':>3s}"
-print(header)
-print("-" * len(header))
-
-ratios = []
-for rid, orig_path, pilot_path in pairs:
-    orig_body, _  = strip_frontmatter(Path(orig_path).read_text())
-    pilot_body, _ = strip_frontmatter(Path(pilot_path).read_text())
-    o, p = len(orig_body), len(pilot_body)
-    r = p / o
-    ratios.append(r)
-    sha_o = iron_law_sha(orig_body)
-    sha_p = iron_law_sha(pilot_body)
-    match = "OK" if sha_o == sha_p else "FAIL"
-    budget = "OK" if p <= 1500 else f"+{p - 1500}"
-    print(f"{rid:25s} {o:6d}  {p:6d}  {r:6.3f}  {budget:>7s}  {sha_o:>16s}  {sha_p:>16s}  {match:>3s}")
-
-mean   = sum(ratios) / len(ratios)
-median = statistics.median(ratios)
-print()
-print(f"r-values : {[round(x, 3) for x in ratios]}")
-print(f"mean   r = {mean:.3f}")
-print(f"median r = {median:.3f}")
-print(f"max    r = {max(ratios):.3f}")
-print(f"min    r = {min(ratios):.3f}")
-print()
-
-TOTAL = 32403
-print(f"Projected always-bucket @ r=mean ({mean:.3f})  : {int(TOTAL * mean):>6d}  (target ≤ 25000)")
-print(f"Projected always-bucket @ r=max  ({max(ratios):.3f})  : {int(TOTAL * max(ratios)):>6d}  (target ≤ 25000)")
-print(f"Projected always-bucket @ r=med  ({median:.3f})  : {int(TOTAL * median):>6d}  (target ≤ 25000)")

package/src/scripts/_tmp_scan_framework_leakage.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python3
-"""Scan generic skills/rules/commands for framework/language leakage.
-
-Carve-out criterion: artifact filename or directory path matches an explicit
-framework/language marker. Everything else MUST be framework-neutral.
-TEMPORARY scanner — delete after audit roadmap is drafted.
-"""
-from __future__ import annotations
-
-import re
-import sys
-from pathlib import Path
-
-ROOT = Path(".agent-src.uncondensed")
-
-CARVE_OUT_PATTERNS = [
-    r"laravel", r"^php-", r"^eloquent", r"^blade", r"^livewire", r"^flux",
-    r"^pest-", r"^artisan-", r"^composer-", r"^jobs-events$", r"^symfony",
-    r"^nextjs", r"^react-", r"^async-python", r"^openapi$", r"^quality-tools",
-    r"^sql-writing", r"^tailwind", r"^terraform", r"^terragrunt", r"^traefik",
-    r"^mobile-e2e",
-    r"^project-analysis-(laravel|symfony|nextjs|react|node-express|zend-laminas)",
-    r"^docker", r"^aws-", r"^grafana", r"^playwright",
-    r"^laravel-", r"^docker-", r"^symfony-", r"^copilot-", r"^devcontainer",
-    r"-routing$",
-]
-CARVE_OUT_RE = re.compile("|".join(CARVE_OUT_PATTERNS), re.IGNORECASE)
-
-LEAKAGE = {
-    "Laravel": [
-        r"\bLaravel\b", r"\bEloquent\b", r"\bArtisan\b", r"\bFormRequest\b",
-        r"\bForm Request\b", r"\bBlade\b(?! Runner)", r"\bLivewire\b",
-        r"\bResource::(make|collection)\b", r"\bModel::\b",
-        r"\bapp/Http/", r"\broutes/(api|web)\.php",
-        r"\bdatabase/(migrations|seeders|factories)\b",
-        r"\bphp artisan\b", r"\bIlluminate\\\\", r"\bIlluminate\\",
-        r"\bbootstrap/app\.php",
-    ],
-    "PHP": [
-        r"\bPHPStan\b", r"\bPest\b(?! Control)", r"\bPHPUnit\b", r"\bRector\b",
-        r"\bECS\b", r"\bcomposer\.json\b", r"\bvendor/bin/",
-        r"\bdeclare\(strict_types=1\)", r"\.php\b",
-        r"\bnamespace App\\\\", r"\bnamespace App\\",
-        r"\bcomposer (require|install|update|dump-autoload)\b",
-    ],
-    "Symfony": [
-        r"\bSymfony\b", r"\bbin/console\b", r"\bDoctrine\b", r"\bTwig\b",
-    ],
-    "JS-specific": [
-        r"\bpackage\.json\b",
-        r"\bnpm (install|run|test|ci)\b",
-        r"\byarn (install|add|test)\b",
-        r"\bpnpm (install|add|run|test)\b",
-        r"\bnode_modules\b",
-    ],
-    "Python-specific": [
-        r"\bpyproject\.toml\b", r"\brequirements\.txt\b",
-        r"\bpip install\b", r"\bpytest\b",
-    ],
-}
-
-
-def is_carve_out(path: Path) -> bool:
-    for p in path.parts:
-        stem = p.removesuffix(".md")
-        if CARVE_OUT_RE.search(stem):
-            return True
-    return False
-
-
-def scan_file(path: Path) -> dict:
-    text = path.read_text(encoding="utf-8", errors="ignore")
-    lines = text.splitlines()
-    hits: dict[str, list[tuple[int, str, str]]] = {}
-    for category, patterns in LEAKAGE.items():
-        for pat in patterns:
-            rx = re.compile(pat)
-            for i, line in enumerate(lines, start=1):
-                if rx.search(line):
-                    hits.setdefault(category, []).append(
-                        (i, pat, line.strip()[:160])
-                    )
-    return hits
-
-
-def scan_dir(subdir: str) -> list[tuple[Path, dict]]:
-    target = ROOT / subdir
-    out = []
-    for f in sorted(target.rglob("*.md")):
-        if is_carve_out(f):
-            continue
-        if f.name.startswith("_"):
-            continue
-        hits = scan_file(f)
-        if hits:
-            out.append((f, hits))
-    return out
-
-
-def main():
-    for label, sub in [("SKILLS", "skills"), ("RULES", "rules"), ("COMMANDS", "commands")]:
-        print(f"\n===== {label} (generic, non-carve-out) =====")
-        results = scan_dir(sub)
-        if not results:
-            print("  (clean)")
-            continue
-        for path, hits in results:
-            total = sum(len(v) for v in hits.values())
-            print(f"\n  [{total:3d}] {path}")
-            for cat, items in hits.items():
-                print(f"      {cat}: {len(items)}")
-                for line_no, pat, snippet in items[:6]:
-                    print(f"        L{line_no:4d}  /{pat}/  {snippet}")
-                if len(items) > 6:
-                    print(f"        ... +{len(items) - 6} more")
-
-
-if __name__ == "__main__":
-    main()

package/src/scripts/adoption_report.py

@@ -1,195 +0,0 @@
-#!/usr/bin/env python3
-"""Roll up ``adoption-snapshots.jsonl`` into a Markdown trend report.
-
-Phase D Step 3 of ``road-to-adoption-proof-and-ci-green.md``.
-Reads the JSONL produced by ``scripts/adoption_snapshot.py`` and
-writes an ``agents/runtime/metrics/adoption-report.md`` snapshot
-covering an 8-week rolling window per signal.
-
-Mirrors the shape of ``scripts/skill_usage_report.py``: a single
-file, ≤ 200 LOC, no external deps. The report is regenerated on
-every invocation (idempotent for a given JSONL state).
-
-CLI:
-
-  scripts/adoption_report.py [--in <path>] [--out <path>] [--weeks 8]
-
-  --in                  JSONL input (default
-                        ``agents/runtime/metrics/adoption-snapshots.jsonl``).
-  --out                 Markdown output (default
-                        ``agents/runtime/metrics/adoption-report.md``).
-  --weeks               Window size (default 8).
-
-Exit codes:
-
-  0 — report written.
-  1 — IO failure on read or write.
-"""
-from __future__ import annotations
-
-import argparse
-import datetime as dt
-import json
-import sys
-from pathlib import Path
-from typing import Any
-
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-DEFAULT_IN = REPO_ROOT / "agents" / "runtime" / "metrics" / "adoption-snapshots.jsonl"
-DEFAULT_OUT = REPO_ROOT / "agents" / "runtime" / "metrics" / "adoption-report.md"
-
-
-def parse_jsonl(path: Path) -> list[dict[str, Any]]:
-    rows: list[dict[str, Any]] = []
-    if not path.exists():
-        return rows
-    for line in path.read_text(encoding="utf-8").splitlines():
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            rows.append(json.loads(line))
-        except json.JSONDecodeError:
-            continue
-    return rows
-
-
-def filter_window(rows: list[dict[str, Any]], weeks: int) -> list[dict[str, Any]]:
-    if not rows:
-        return rows
-    cutoff = dt.datetime.now(dt.timezone.utc) - dt.timedelta(weeks=weeks)
-    out: list[dict[str, Any]] = []
-    for r in rows:
-        ts = r.get("snapshot_at", "")
-        try:
-            when = dt.datetime.strptime(ts, "%Y-%m-%dT%H:%M:%SZ").replace(
-                tzinfo=dt.timezone.utc
-            )
-        except ValueError:
-            continue
-        if when >= cutoff:
-            out.append(r)
-    return out
-
-
-def render_section(title: str, lines: list[str]) -> str:
-    return f"## {title}\n\n" + "\n".join(lines) + "\n\n"
-
-
-def render_npm_downloads(rows: list[dict[str, Any]]) -> str:
-    lines = []
-    lines.append("| Snapshot | Last 7 days (npm installs) |")
-    lines.append("|---|---:|")
-    for r in rows:
-        signal = r.get("signals", {}).get("npm_downloads", {})
-        if "error" in signal:
-            cell = f"_(error: {signal['error'][:40]})_"
-        else:
-            cell = f"{signal.get('last_7_days', 0):,}"
-        lines.append(f"| `{r.get('snapshot_at', '?')}` | {cell} |")
-    return render_section("npm install count (last 7 days, weekly snapshot)", lines)
-
-
-def render_npm_version(rows: list[dict[str, Any]]) -> str:
-    lines = []
-    lines.append("| Snapshot | Latest version | Version count |")
-    lines.append("|---|---|---:|")
-    for r in rows:
-        signal = r.get("signals", {}).get("npm_version", {})
-        if "error" in signal:
-            lines.append(f"| `{r.get('snapshot_at', '?')}` | _(error)_ | _(error)_ |")
-        else:
-            latest = signal.get("latest", "?")
-            count = signal.get("version_count", 0)
-            lines.append(f"| `{r.get('snapshot_at', '?')}` | `{latest}` | {count} |")
-    return render_section("npm version distribution", lines)
-
-
-def render_github_stars(rows: list[dict[str, Any]]) -> str:
-    lines = []
-    lines.append("| Snapshot | Stars | Forks | Watchers |")
-    lines.append("|---|---:|---:|---:|")
-    for r in rows:
-        signal = r.get("signals", {}).get("github_stars", {})
-        if "error" in signal:
-            lines.append(f"| `{r.get('snapshot_at', '?')}` | _(error)_ | _(error)_ | _(error)_ |")
-        else:
-            lines.append(
-                f"| `{r.get('snapshot_at', '?')}` | "
-                f"{signal.get('stars', 0):,} | "
-                f"{signal.get('forks', 0):,} | "
-                f"{signal.get('watchers', 0):,} |"
-            )
-    return render_section("GitHub stars / forks / watchers", lines)
-
-
-def render_topic_rank(rows: list[dict[str, Any]]) -> str:
-    lines = []
-    lines.append("| Snapshot | `agent-skills` rank | `cinematic-ai-video` rank |")
-    lines.append("|---|---:|---:|")
-    for r in rows:
-        signal = r.get("signals", {}).get("topic_rank", {})
-        as_block = signal.get("agent-skills", {})
-        cav_block = signal.get("cinematic-ai-video", {})
-        as_rank = "_(error)_" if "error" in as_block else (as_block.get("rank") or "—")
-        cav_rank = "_(error)_" if "error" in cav_block else (cav_block.get("rank") or "—")
-        lines.append(
-            f"| `{r.get('snapshot_at', '?')}` | {as_rank} | {cav_rank} |"
-        )
-    return render_section("Topic-search rank (`agent-skills` + `cinematic-ai-video`)", lines)
-
-
-def render_report(rows: list[dict[str, Any]], weeks: int) -> str:
-    header = (
-        "# Adoption report — rolling trend\n\n"
-        f"> Generated by `scripts/adoption_report.py` from "
-        f"`agents/runtime/metrics/adoption-snapshots.jsonl`.\n"
-        f"> Window: rolling {weeks} weeks. Source contract: "
-        f"`docs/contracts/adoption-signal-floor.md`.\n\n"
-    )
-    if not rows:
-        header += (
-            "_No snapshots in the current window — run `python3 scripts/adoption_snapshot.py` "
-            "(scheduled weekly via the cron in `.github/workflows/`) to populate the trend._\n"
-        )
-        return header
-    return (
-        header
-        + render_npm_downloads(rows)
-        + render_npm_version(rows)
-        + render_github_stars(rows)
-        + render_topic_rank(rows)
-    )
-
-
-def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
-    p = argparse.ArgumentParser(prog="adoption_report")
-    p.add_argument("--in", dest="in_path", type=Path, default=DEFAULT_IN)
-    p.add_argument("--out", type=Path, default=DEFAULT_OUT)
-    p.add_argument("--weeks", type=int, default=8)
-    return p.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = parse_args(argv)
-    try:
-        rows = parse_jsonl(args.in_path)
-    except OSError as exc:
-        print(f"error: failed to read {args.in_path}: {exc}", file=sys.stderr)
-        return 1
-    rows = filter_window(rows, args.weeks)
-    rows.sort(key=lambda r: r.get("snapshot_at", ""))
-    report = render_report(rows, args.weeks)
-    try:
-        args.out.parent.mkdir(parents=True, exist_ok=True)
-        args.out.write_text(report, encoding="utf-8")
-    except OSError as exc:
-        print(f"error: failed to write {args.out}: {exc}", file=sys.stderr)
-        return 1
-    print(f"adoption_report: wrote {args.out} ({len(rows)} snapshot(s))")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/adoption_snapshot.py

@@ -1,219 +0,0 @@
-#!/usr/bin/env python3
-"""Pull the four public adoption signals into a single dated JSONL row.
-
-Phase D Step 2 of ``road-to-adoption-proof-and-ci-green.md``.
-Signals (per ``docs/contracts/adoption-signal-floor.md``):
-
-  1. npm install count          — last 7 days, full lifetime.
-  2. npm version distribution    — latest published version.
-  3. GitHub stars / forks        — current count.
-  4. Topic-search rank           — best-rank position for the two
-     project-scoped topics (`agent-skills`, `cinematic-ai-video`).
-
-Output: one JSONL row appended to
-``agents/runtime/metrics/adoption-snapshots.jsonl``. Each row carries
-an ISO-8601 ``snapshot_at`` timestamp + the four signal payloads.
-
-CLI:
-
-  scripts/adoption_snapshot.py [--out <path>] [--no-network]
-
-  --no-network          Skip the four HTTP calls; emit a row with
-                        ``error: "skipped"`` on each signal. Used by
-                        the pytest path so tests never hit the wire.
-  --out                 Override the output JSONL path (default:
-                        ``agents/runtime/metrics/adoption-snapshots.jsonl``).
-
-Exit codes:
-
-  0 — row appended successfully.
-  1 — IO failure writing the JSONL.
-  2 — every signal failed (network outage; the row is appended but
-      annotated, so trend reports can spot the outage).
-"""
-from __future__ import annotations
-
-import argparse
-import datetime as dt
-import json
-import os
-import sys
-from pathlib import Path
-from typing import Any
-from urllib.error import URLError, HTTPError
-from urllib.request import Request, urlopen
-
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-DEFAULT_OUT = REPO_ROOT / "agents" / "runtime" / "metrics" / "adoption-snapshots.jsonl"
-
-NPM_PACKAGE = "@event4u/agent-config"
-NPM_DOWNLOADS_URL = f"https://api.npmjs.org/downloads/range/last-week/{NPM_PACKAGE}"
-NPM_REGISTRY_URL = f"https://registry.npmjs.org/{NPM_PACKAGE.replace('/', '%2F')}"
-GH_REPO = "event4u-app/agent-config"
-GH_REPO_URL = f"https://api.github.com/repos/{GH_REPO}"
-GH_TOPICS = ("agent-skills", "cinematic-ai-video")
-GH_SEARCH_URL_TEMPLATE = "https://api.github.com/search/repositories?q=topic:{topic}&sort=stars&order=desc&per_page=100"
-
-TIMEOUT_S = 10
-
-
-def _utc_now_iso() -> str:
-    return dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-
-def _http_get_json(url: str, headers: dict[str, str] | None = None) -> dict[str, Any]:
-    req = Request(url, headers=headers or {})
-    with urlopen(req, timeout=TIMEOUT_S) as resp:
-        body = resp.read().decode("utf-8")
-    return json.loads(body)
-
-
-def fetch_npm_downloads() -> dict[str, Any]:
-    try:
-        data = _http_get_json(NPM_DOWNLOADS_URL)
-        downloads = data.get("downloads", [])
-        total_7d = sum(d.get("downloads", 0) for d in downloads if isinstance(d, dict))
-        return {"package": NPM_PACKAGE, "last_7_days": total_7d, "source": "npm"}
-    except (URLError, HTTPError, ValueError) as exc:
-        return {"package": NPM_PACKAGE, "error": str(exc)[:120], "source": "npm"}
-
-
-def fetch_npm_version() -> dict[str, Any]:
-    try:
-        data = _http_get_json(NPM_REGISTRY_URL)
-        latest = data.get("dist-tags", {}).get("latest", "")
-        versions = list(data.get("versions", {}).keys())
-        return {
-            "latest": latest,
-            "version_count": len(versions),
-            "source": "npm-registry",
-        }
-    except (URLError, HTTPError, ValueError) as exc:
-        return {"error": str(exc)[:120], "source": "npm-registry"}
-
-
-def fetch_github_stars() -> dict[str, Any]:
-    try:
-        headers = {"Accept": "application/vnd.github+json"}
-        token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
-        if token:
-            headers["Authorization"] = f"Bearer {token}"
-        data = _http_get_json(GH_REPO_URL, headers=headers)
-        return {
-            "repo": GH_REPO,
-            "stars": data.get("stargazers_count", 0),
-            "forks": data.get("forks_count", 0),
-            "watchers": data.get("watchers_count", 0),
-            "source": "github-repo",
-        }
-    except (URLError, HTTPError, ValueError) as exc:
-        return {"repo": GH_REPO, "error": str(exc)[:120], "source": "github-repo"}
-
-
-def fetch_topic_rank() -> dict[str, Any]:
-    out: dict[str, Any] = {"source": "github-search"}
-    for topic in GH_TOPICS:
-        try:
-            headers = {"Accept": "application/vnd.github+json"}
-            token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
-            if token:
-                headers["Authorization"] = f"Bearer {token}"
-            data = _http_get_json(GH_SEARCH_URL_TEMPLATE.format(topic=topic), headers=headers)
-            items = data.get("items", [])
-            rank = next(
-                (i + 1 for i, item in enumerate(items) if item.get("full_name") == GH_REPO),
-                None,
-            )
-            out[topic] = {
-                "rank": rank,
-                "total_results": data.get("total_count", 0),
-            }
-        except (URLError, HTTPError, ValueError) as exc:
-            out[topic] = {"error": str(exc)[:120]}
-    return out
-
-
-def collect_signals(skip_network: bool) -> dict[str, Any]:
-    if skip_network:
-        skipped = {"error": "skipped", "source": "skipped"}
-        return {
-            "npm_downloads": skipped,
-            "npm_version": skipped,
-            "github_stars": skipped,
-            "topic_rank": skipped,
-        }
-    return {
-        "npm_downloads": fetch_npm_downloads(),
-        "npm_version": fetch_npm_version(),
-        "github_stars": fetch_github_stars(),
-        "topic_rank": fetch_topic_rank(),
-    }
-
-
-def build_row(signals: dict[str, Any]) -> dict[str, Any]:
-    return {
-        "snapshot_at": _utc_now_iso(),
-        "schema": "adoption-snapshot/v0",
-        "signals": signals,
-    }
-
-
-def append_row(out_path: Path, row: dict[str, Any]) -> None:
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-    with out_path.open("a", encoding="utf-8") as fh:
-        fh.write(json.dumps(row) + "\n")
-
-
-def all_signals_failed(signals: dict[str, Any]) -> bool:
-    """True when every signal (or every topic in topic_rank) errored.
-
-    A signal block carries `error` when its HTTP call failed. For
-    `topic_rank`, the outer dict does NOT carry `error`; instead each
-    nested per-topic entry does. The outage predicate counts the
-    composite as a failure when every nested topic errored.
-    """
-    for name, value in signals.items():
-        if not isinstance(value, dict):
-            return False  # Unknown shape — treat as success to be conservative.
-        if name == "topic_rank":
-            # Outage when every nested topic errored.
-            nested = [v for k, v in value.items() if k != "source" and isinstance(v, dict)]
-            if not nested:
-                return False
-            if any("error" not in v for v in nested):
-                return False
-        else:
-            if "error" not in value:
-                return False
-    return True
-
-
-def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
-    p = argparse.ArgumentParser(prog="adoption_snapshot")
-    p.add_argument("--out", type=Path, default=DEFAULT_OUT, help="JSONL output path.")
-    p.add_argument(
-        "--no-network",
-        action="store_true",
-        help="Skip the four HTTP calls (used by the pytest path).",
-    )
-    return p.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = parse_args(argv)
-    signals = collect_signals(skip_network=args.no_network)
-    row = build_row(signals)
-    try:
-        append_row(args.out, row)
-    except OSError as exc:
-        print(f"error: failed to append snapshot: {exc}", file=sys.stderr)
-        return 1
-    print(f"appended snapshot @ {row['snapshot_at']} → {args.out}")
-    if not args.no_network and all_signals_failed(signals):
-        return 2
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())