@kernaut/kernaut-resources 0.1.17-beta.1 → 0.1.18

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/scripts/refresh_candidate_ledger.py

@@ -1,246 +0,0 @@
-#!/usr/bin/env python3
-"""Refresh candidate ledgers and emit deterministic search-result artifacts.
-
-For each tracked repo (cutlass / sglang / vllm / flashinfer / pytorch /
-deepgemm), runs `gh search prs` with the keywords already documented in
-each ledger's `keywords_used` field, then:
-
-  - Updates `candidates/<repo>.yaml::searched_at` to today's date
-    (or the explicit `--cutoff` flag).
-  - Writes (or updates) `data/refresh-cutoff.yaml` with `cutoff_date`.
-  - Writes (or updates) `data/refresh-search-results.yaml` with per-repo
-    `pr_numbers_seen` (sorted) plus `last_pr_date_seen`.
-
-Outputs are byte-stable for identical inputs (deterministic ordering;
-tested by re-running the script twice and diffing).
-
-This script makes `gh` calls to GitHub Search API and is therefore NOT
-intended to be invoked by `validate.py` or `check_version_freshness.py`
-— those scripts must remain offline. It is a refresh-time utility,
-similar to `scripts/fetch_pr_diff.py` and `scripts/generate-pr-pages.py`.
-
-Usage:
-  python3 scripts/refresh_candidate_ledger.py --cutoff 2026-04-27
-  python3 scripts/refresh_candidate_ledger.py --cutoff 2026-04-27 --dry-run
-  python3 scripts/refresh_candidate_ledger.py --cutoff 2026-04-27 --repos cutlass,sglang
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import subprocess
-import sys
-from datetime import date
-from pathlib import Path
-
-import yaml
-
-REPO_ROOT = Path(__file__).parent.parent
-CANDIDATES_DIR = REPO_ROOT / "candidates"
-DATA_DIR = REPO_ROOT / "data"
-REFRESH_CUTOFF_PATH = DATA_DIR / "refresh-cutoff.yaml"
-REFRESH_RESULTS_PATH = DATA_DIR / "refresh-search-results.yaml"
-
-REPO_SLUG_TO_FULL = {
-    "cutlass": "NVIDIA/cutlass",
-    "sglang": "sgl-project/sglang",
-    "sgl-kernel-npu": "sgl-project/sgl-kernel-npu",
-    "vllm": "vllm-project/vllm",
-    "flashinfer": "flashinfer-ai/flashinfer",
-    "pytorch": "pytorch/pytorch",
-    "deepgemm": "deepseek-ai/DeepGEMM",
-}
-
-
-import time as _time
-
-
-def gh_search_prs(repo_full, keywords, cutoff_date, per_keyword_limit=30,
-                  sleep_between_kw=2.5):
-    """Run `gh search prs` once per keyword and union the results
-    (deduplicated by PR number). `gh search` does not support OR-joined
-    keyword queries reliably, so the script makes per-keyword calls.
-
-    GitHub Search API rate limit is 30/min. Sleeping ~2.5s between
-    keyword queries keeps the script comfortably under that ceiling.
-
-    Filters to merged PRs whose closedAt is on or before cutoff_date."""
-    if not keywords:
-        return []
-    cutoff_str = cutoff_date.isoformat()
-    seen = {}
-    for kw in keywords:
-        cmd = [
-            "gh", "search", "prs",
-            "--repo", repo_full,
-            "--state", "closed",
-            "--merged",
-            "--limit", str(per_keyword_limit),
-            "--json", "number,title,closedAt,url",
-            kw,
-        ]
-        try:
-            out = subprocess.check_output(cmd, text=True, timeout=60)
-        except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
-            print(f"WARN: gh search failed for {repo_full} kw={kw!r}: {e}", file=sys.stderr)
-            _time.sleep(sleep_between_kw)
-            continue
-        rows = json.loads(out)
-        for r in rows:
-            closed = (r.get("closedAt") or "")[:10]
-            if closed and closed <= cutoff_str:
-                num = r["number"]
-                if num not in seen:
-                    seen[num] = {
-                        "number": num,
-                        "title": r.get("title", ""),
-                        "closedAt": closed,
-                    }
-        _time.sleep(sleep_between_kw)
-    return list(seen.values())
-
-
-def update_ledger(ledger_path, cutoff_date, search_results):
-    """Update a candidates/<repo>.yaml file to set searched_at == cutoff_date
-    AND merge new PR numbers from search_results into the ledger as
-    `decision: defer` rows. Existing rows are not touched.
-
-    AC-5 negative test requires every `pr_numbers_seen` entry to appear in
-    the ledger's `prs[*].number` set after refresh. New entries land as
-    `decision: defer` to make later triage explicit.
-    """
-    data = yaml.safe_load(ledger_path.read_text(encoding="utf-8"))
-    if not isinstance(data, dict):
-        return
-    data["searched_at"] = cutoff_date.isoformat()
-    existing_nums = {row.get("number") for row in (data.get("prs") or [])
-                     if isinstance(row, dict)}
-    new_rows = []
-    for hit in search_results:
-        num = hit["number"]
-        if num in existing_nums:
-            continue
-        new_rows.append({
-            "number": num,
-            "title": hit.get("title", ""),
-            "date": hit.get("closedAt", ""),
-            "decision": "defer",
-            "reason": "from refresh search; needs-triage",
-            "files_changed": [],
-        })
-    if new_rows:
-        data["prs"] = (data.get("prs") or []) + new_rows
-        # Update top-level summary counts
-        new_inc = sum(1 for r in data["prs"] if str(r.get("decision","")).lower() == "include")
-        new_exc = sum(1 for r in data["prs"] if str(r.get("decision","")).lower() == "exclude")
-        new_def = sum(1 for r in data["prs"] if str(r.get("decision","")).lower() == "defer")
-        data["total_candidates"] = new_inc + new_exc + new_def
-        data["included"] = new_inc
-        data["excluded"] = new_exc
-        data["deferred"] = new_def
-    out = yaml.safe_dump(data, sort_keys=False, default_flow_style=False, width=200, allow_unicode=True)
-    ledger_path.write_text(out, encoding="utf-8")
-    return len(new_rows)
-
-
-def write_cutoff(cutoff_date):
-    out = (
-        "## Round-N refresh cutoff record. Schema: data/schemas.yaml ::\n"
-        "## refresh-cutoff. Updated by scripts/refresh_candidate_ledger.py.\n"
-        "##\n"
-        "## All candidates/*.yaml::searched_at fields must equal this date\n"
-        "## after a refresh round (per AC-5).\n"
-    )
-    out += yaml.safe_dump({"cutoff_date": cutoff_date.isoformat()}, sort_keys=False, default_flow_style=False)
-    REFRESH_CUTOFF_PATH.write_text(out, encoding="utf-8")
-
-
-def write_search_results(cutoff_date, per_repo):
-    """Write data/refresh-search-results.yaml byte-stably."""
-    repos = []
-    for repo_slug in sorted(per_repo.keys()):
-        rows = per_repo[repo_slug]
-        pr_numbers = sorted([r["number"] for r in rows])
-        last_pr_date = max([r["closedAt"] for r in rows], default="")
-        repos.append({
-            "repo_slug": repo_slug,
-            "searched_at": cutoff_date.isoformat(),
-            "cutoff_date_used": cutoff_date.isoformat(),
-            "pr_numbers_seen": pr_numbers,
-            "last_pr_date_seen": last_pr_date,
-        })
-    payload = {"cutoff_date": cutoff_date.isoformat(), "repos": repos}
-    out = (
-        "## AC-5 refresh search-results record. Schema: data/schemas.yaml ::\n"
-        "## refresh-search-results. Generated by\n"
-        "## scripts/refresh_candidate_ledger.py. Byte-stable for identical\n"
-        "## query inputs (pr_numbers_seen sorted ascending; repos keyed by\n"
-        "## repo_slug ascending).\n"
-    )
-    out += yaml.safe_dump(payload, sort_keys=False, default_flow_style=False, width=200, allow_unicode=True)
-    REFRESH_RESULTS_PATH.write_text(out, encoding="utf-8")
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--cutoff", required=True,
-                        help="Refresh cutoff date (YYYY-MM-DD).")
-    parser.add_argument("--repos", default=None,
-                        help="Comma-separated repo slugs to refresh "
-                             "(default: all from REPO_SLUG_TO_FULL).")
-    parser.add_argument("--dry-run", action="store_true",
-                        help="Don't write any files; print the search results.")
-    args = parser.parse_args()
-
-    cutoff_date = date.fromisoformat(args.cutoff)
-    repo_slugs = (args.repos.split(",") if args.repos
-                  else list(REPO_SLUG_TO_FULL.keys()))
-
-    per_repo = {}
-    for slug in repo_slugs:
-        repo_full = REPO_SLUG_TO_FULL.get(slug)
-        if not repo_full:
-            print(f"WARN: unknown repo slug {slug!r}", file=sys.stderr)
-            continue
-        ledger_path = CANDIDATES_DIR / f"{slug}.yaml"
-        if not ledger_path.is_file():
-            print(f"WARN: no ledger for {slug} at {ledger_path}", file=sys.stderr)
-            per_repo[slug] = []
-            continue
-        ledger_data = yaml.safe_load(ledger_path.read_text(encoding="utf-8")) or {}
-        keywords = ledger_data.get("keywords_used") or []
-        print(f"  {slug}: searching {repo_full} with {len(keywords)} keywords...")
-        rows = gh_search_prs(repo_full, keywords, cutoff_date)
-        per_repo[slug] = rows
-        print(f"    -> {len(rows)} merged PRs found within cutoff window")
-        if not args.dry_run:
-            added = update_ledger(ledger_path, cutoff_date, rows)
-            if added:
-                print(f"    -> +{added} new defer-rows merged into ledger")
-
-    if args.dry_run:
-        print("\nDry-run mode; no files written.")
-        return
-
-    # Merge with existing data/refresh-search-results.yaml so partial
-    # refreshes (e.g. --repos cutlass,sglang) accumulate instead of
-    # overwriting other repos' results.
-    if REFRESH_RESULTS_PATH.is_file():
-        existing = yaml.safe_load(REFRESH_RESULTS_PATH.read_text(encoding="utf-8")) or {}
-        for row in existing.get("repos", []) or []:
-            slug = row.get("repo_slug")
-            if slug and slug not in per_repo:
-                per_repo[slug] = [
-                    {"number": n, "title": "", "closedAt": row.get("last_pr_date_seen", "")}
-                    for n in row.get("pr_numbers_seen", []) or []
-                ]
-
-    write_cutoff(cutoff_date)
-    write_search_results(cutoff_date, per_repo)
-    print(f"\nWrote {REFRESH_CUTOFF_PATH.relative_to(REPO_ROOT)}")
-    print(f"Wrote {REFRESH_RESULTS_PATH.relative_to(REPO_ROOT)}")
-
-
-if __name__ == "__main__":
-    main()

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/scripts/refresh_gitcode_candidate_ledger.py

@@ -1,204 +0,0 @@
-#!/usr/bin/env python3
-"""Refresh a GitCode candidate ledger.
-
-This is a small provider-specific companion to refresh_candidate_ledger.py for
-repositories that live on gitcode.com instead of GitHub. It reads one ledger
-(e.g. candidates/triton-ascend.yaml), scans closed pull requests through the
-GitCode v5 API, filters by keywords and optional path_prefixes, and appends new
-PR rows as `decision: defer` for later human triage.
-
-Usage:
-  python3 scripts/refresh_gitcode_candidate_ledger.py candidates/triton-ascend.yaml --cutoff 2026-06-29 --dry-run
-  python3 scripts/refresh_gitcode_candidate_ledger.py candidates/triton-ascend.yaml --cutoff 2026-06-29 --max-pages 5
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-import time
-import urllib.parse
-import urllib.request
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import date
-from pathlib import Path
-
-import yaml
-
-REPO_ROOT = Path(__file__).parent.parent
-
-
-def api_get_json(url: str):
-    req = urllib.request.Request(url, headers={"Accept": "application/json"})
-    with urllib.request.urlopen(req, timeout=60) as resp:
-        return json.loads(resp.read().decode("utf-8"))
-
-
-def gitcode_api_url(repo: str, suffix: str, **query):
-    owner, name = repo.split("/", 1)
-    base = f"https://api.gitcode.com/api/v5/repos/{urllib.parse.quote(owner)}/{urllib.parse.quote(name)}/{suffix.lstrip('/')}"
-    if query:
-        return base + "?" + urllib.parse.urlencode(query)
-    return base
-
-
-def normalize_date(s: str) -> str:
-    return (s or "")[:10]
-
-
-def fetch_pull_files(repo: str, number: int):
-    url = gitcode_api_url(repo, f"pulls/{number}/files")
-    try:
-        rows = api_get_json(url)
-    except Exception as e:  # network / API shape errors are advisory during refresh
-        print(f"WARN: failed to fetch GitCode files for {repo}#{number}: {e}", file=sys.stderr)
-        return []
-    if not isinstance(rows, list):
-        return []
-    return [r.get("filename", "") for r in rows if isinstance(r, dict) and r.get("filename")]
-
-
-def row_matches(row, keywords, path_prefixes, files):
-    text = " ".join(str(row.get(k, "")) for k in ["title", "body"]).lower()
-    file_text = " ".join(files).lower()
-    kw_hit = any(str(k).lower() in text or str(k).lower() in file_text for k in keywords)
-    path_hit = any(any(f.startswith(prefix) for prefix in path_prefixes) for f in files)
-    # If the ledger was created from a GitCode tree URL, path_prefixes is the
-    # user's intended scope. Treat it as a hard filter; keyword hits outside the
-    # subtree are usually repo-wide compiler/docs noise.
-    if path_prefixes:
-        return path_hit
-    return kw_hit
-
-
-def load_existing_numbers(data):
-    return {r.get("number") for r in data.get("prs", []) or [] if isinstance(r, dict)}
-
-
-def recompute_counts(data):
-    prs = data.get("prs") or []
-    data["total_candidates"] = len(prs)
-    data["included"] = sum(1 for r in prs if str(r.get("decision", "")).lower() == "include")
-    data["excluded"] = sum(1 for r in prs if str(r.get("decision", "")).lower() == "exclude")
-    data["deferred"] = sum(1 for r in prs if str(r.get("decision", "")).lower() == "defer")
-
-
-def search_gitcode_pulls(repo, keywords, path_prefixes, cutoff_date, max_pages=5, per_page=50, sleep=0.5, workers=2, start_page=1):
-    cutoff = cutoff_date.isoformat()
-    hits = []
-    seen = set()
-    for page in range(start_page, start_page + max_pages):
-        url = gitcode_api_url(repo, "pulls", state="closed", per_page=per_page, page=page)
-        try:
-            rows = api_get_json(url)
-        except Exception as e:
-            print(f"WARN: GitCode pull list failed for {repo} page={page}: {e}", file=sys.stderr)
-            break
-        if not isinstance(rows, list) or not rows:
-            break
-        candidates = []
-        for row in rows:
-            if not isinstance(row, dict):
-                continue
-            num = row.get("number")
-            if not isinstance(num, int) or num in seen:
-                continue
-            closed = normalize_date(row.get("closed_at") or row.get("updated_at") or row.get("created_at"))
-            if closed and closed > cutoff:
-                continue
-            candidates.append((row, num, closed))
-
-        file_map = {}
-        with ThreadPoolExecutor(max_workers=max(1, workers)) as ex:
-            futs = {ex.submit(fetch_pull_files, repo, num): num for _row, num, _closed in candidates}
-            for fut in as_completed(futs):
-                num = futs[fut]
-                try:
-                    file_map[num] = fut.result()
-                except Exception as e:
-                    print(f"WARN: failed to fetch GitCode files for {repo}#{num}: {e}", file=sys.stderr)
-                    file_map[num] = []
-
-        for row, num, closed in candidates:
-            files = file_map.get(num, [])
-            if not row_matches(row, keywords, path_prefixes, files):
-                continue
-            seen.add(num)
-            hits.append({
-                "number": num,
-                "title": row.get("title", ""),
-                "closedAt": closed,
-                "url": row.get("html_url", ""),
-                "files": files,
-            })
-        time.sleep(sleep)
-    hits.sort(key=lambda r: r["number"])
-    return hits
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__.split("\n", 1)[0])
-    parser.add_argument("ledger", help="Path to candidates/<repo>.yaml with provider: gitcode")
-    parser.add_argument("--cutoff", required=True, help="Refresh cutoff date (YYYY-MM-DD)")
-    parser.add_argument("--start-page", type=int, default=1, help="First GitCode API page to scan (default: 1)")
-    parser.add_argument("--max-pages", type=int, default=5, help="Number of GitCode API pages to scan (default: 5)")
-    parser.add_argument("--per-page", type=int, default=50, help="GitCode API page size (default: 50)")
-    parser.add_argument("--workers", type=int, default=2, help="Concurrent GitCode file-list requests per page (default: 2; keep low to avoid 429)")
-    parser.add_argument("--sleep", type=float, default=0.5, help="Sleep seconds between GitCode list pages (default: 0.5)")
-    parser.add_argument("--dry-run", action="store_true", help="Print results without writing the ledger")
-    args = parser.parse_args()
-
-    ledger_path = Path(args.ledger)
-    if not ledger_path.is_absolute():
-        ledger_path = REPO_ROOT / ledger_path
-    data = yaml.safe_load(ledger_path.read_text(encoding="utf-8")) or {}
-    if data.get("provider") != "gitcode":
-        raise SystemExit(f"{ledger_path}: expected provider: gitcode")
-    repo = data.get("repo")
-    if not repo or "/" not in repo:
-        raise SystemExit(f"{ledger_path}: missing repo: owner/name")
-    cutoff_date = date.fromisoformat(args.cutoff)
-    keywords = data.get("keywords_used") or []
-    path_prefixes = data.get("path_prefixes") or []
-
-    print(f"  {ledger_path.name}: searching GitCode {repo} with {len(keywords)} keywords, {len(path_prefixes)} path prefixes...")
-    hits = search_gitcode_pulls(
-        repo, keywords, path_prefixes, cutoff_date,
-        max_pages=args.max_pages,
-        per_page=args.per_page,
-        sleep=args.sleep,
-        workers=args.workers,
-        start_page=args.start_page,
-    )
-    print(f"    -> {len(hits)} closed PRs found within cutoff window")
-    existing = load_existing_numbers(data)
-    new_rows = []
-    for h in hits:
-        marker = "existing" if h["number"] in existing else "new"
-        print(f"    [{marker}] #{h['number']} {h['closedAt']} {h['title']}")
-        if h["number"] in existing:
-            continue
-        new_rows.append({
-            "number": h["number"],
-            "title": h.get("title", ""),
-            "date": h.get("closedAt", ""),
-            "decision": "defer",
-            "reason": "from gitcode refresh; needs-triage",
-            "files_changed": h.get("files", [])[:50],
-        })
-
-    if args.dry_run:
-        print("\nDry-run mode; no files written.")
-        return
-
-    data["searched_at"] = cutoff_date.isoformat()
-    if new_rows:
-        data["prs"] = (data.get("prs") or []) + new_rows
-    recompute_counts(data)
-    ledger_path.write_text(yaml.safe_dump(data, sort_keys=False, default_flow_style=False, width=200, allow_unicode=True), encoding="utf-8")
-    print(f"    -> +{len(new_rows)} new defer-rows merged into {ledger_path.relative_to(REPO_ROOT)}")
-
-
-if __name__ == "__main__":
-    main()

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/scripts/repo_size_check.py

@@ -1,121 +0,0 @@
-#!/usr/bin/env python3
-"""Report repo working-tree size and file count; fail if active ceiling exceeded.
-
-Exclusion list: .git, .humanize, .codex, .cache, __pycache__, node_modules.
-
-Reads data/phase3-size-budget.yaml when present to get the active ceiling.
-If the budget file is absent, this script reports numbers but does not fail
-(intermediate commits before the pilot don't need the size gate).
-
-Exit codes:
-  0 — within ceiling (or no budget file present)
-  1 — active ceiling exceeded or file-count budget exceeded
-  2 — invocation error
-
-Usage:
-  scripts/repo_size_check.py             # print and assert
-  scripts/repo_size_check.py --ceiling-mib 60   # override active ceiling
-"""
-
-import argparse
-import sys
-from pathlib import Path
-import yaml
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-BUDGET_PATH = REPO_ROOT / "data" / "phase3-size-budget.yaml"
-ARTIFACTS_DIR = REPO_ROOT / "artifacts"
-
-EXCLUDE_TOP = {".git", ".humanize", ".codex", ".cache", "node_modules", ".venv", "venv", ".tox", ".pytest_cache", ".mypy_cache", ".ruff_cache"}
-EXCLUDE_ANY = {"__pycache__"}
-
-# Hard file-count budget (plan AC-10): 6000 under artifacts/
-FILE_COUNT_BUDGET = 6000
-
-
-def working_tree_bytes():
-    total = 0
-    count = 0
-    for p in REPO_ROOT.rglob("*"):
-        # Skip excluded top-level directories
-        try:
-            rel = p.relative_to(REPO_ROOT)
-        except ValueError:
-            continue
-        parts = rel.parts
-        if parts and parts[0] in EXCLUDE_TOP:
-            continue
-        if any(part in EXCLUDE_ANY for part in parts):
-            continue
-        if p.is_file():
-            try:
-                total += p.stat().st_size
-                count += 1
-            except OSError:
-                continue
-    return total, count
-
-
-def artifacts_file_count():
-    if not ARTIFACTS_DIR.is_dir():
-        return 0
-    c = 0
-    for p in ARTIFACTS_DIR.rglob("*"):
-        if p.is_file():
-            c += 1
-    return c
-
-
-def load_budget():
-    if not BUDGET_PATH.is_file():
-        return None
-    try:
-        return yaml.safe_load(BUDGET_PATH.read_text(encoding="utf-8")) or {}
-    except yaml.YAMLError:
-        return {}
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
-    parser.add_argument("--ceiling-mib", type=int, default=None,
-                        help="Override the working-tree size ceiling (MiB)")
-    args = parser.parse_args()
-
-    total, total_files = working_tree_bytes()
-    artifacts_files = artifacts_file_count()
-    mib = total / (1024 * 1024)
-
-    budget = load_budget()
-    if args.ceiling_mib is not None:
-        ceiling_mib = args.ceiling_mib
-        ceiling_src = "CLI override"
-    elif budget and "active_ceiling_mib" in budget:
-        ceiling_mib = budget["active_ceiling_mib"]
-        ceiling_src = "data/phase3-size-budget.yaml"
-    else:
-        ceiling_mib = None
-        ceiling_src = None
-
-    print(f"Working tree: {mib:.2f} MiB across {total_files} files "
-          f"(artifacts/: {artifacts_files} files)")
-
-    failed = False
-    if ceiling_mib is not None:
-        print(f"Active ceiling: {ceiling_mib} MiB (source: {ceiling_src})")
-        if mib > ceiling_mib:
-            print(f"FAIL: working tree {mib:.2f} MiB exceeds ceiling {ceiling_mib} MiB",
-                  file=sys.stderr)
-            failed = True
-    else:
-        print("Active ceiling: (no budget file present; skip size gate)")
-
-    if artifacts_files > FILE_COUNT_BUDGET:
-        print(f"FAIL: artifacts/ has {artifacts_files} files (> {FILE_COUNT_BUDGET} budget)",
-              file=sys.stderr)
-        failed = True
-
-    sys.exit(1 if failed else 0)
-
-
-if __name__ == "__main__":
-    main()