@olegkoval/agent-skills 1.54.4 → 1.55.0

package/adapters/claude/olko-github-pr/skills/lekker-review/scripts/lint-findings.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+// eslint JSON report -> lekker-review findings, tagged botPredicted.
+//
+// Why this exists: the bot reviewers (Greptile, Gemini) spend most of their
+// budget restating what the repo's own eslint config already says, and they are
+// wrong about it more often than eslint is. On one observed PR three of four
+// predicted bot comments were eslint rules, and eslint OVERRULED the model's
+// guess (it had suggested `.forEach`, which that config bans). So the linter is
+// the authority for this class of finding, not an LLM.
+//
+// Usage:
+//   node lint-findings.mjs <eslint-json-file> <out-findings-json> [--max N] [--base <sha>]
+//
+// --base keeps only messages on lines the change added (git diff -U0 <sha> HEAD
+// in LEKKER_WORKTREE_PATH). eslint lints whole files, but bots comment on diff
+// lines, so standing debt elsewhere in a touched file is not a prediction and
+// must not reach fix mode. The dropped count is reported as summary.outOfDiff.
+//
+// Reads an `eslint -f json` report. Writes {"findings":[...], "summary": {...}}
+// where each finding matches the FINDINGS_SCHEMA shape used by workflow.js,
+// plus `botPredicted: true` and `rule: "LINT:<ruleId>"`.
+//
+// Findings are grouped by ruleId and file so a rule that fires 40 times in a
+// file produces one finding listing the other sites, not 40 findings that drown
+// the review. Per file, because fix mode routes each finding to its one file.
+
+import { execFileSync } from 'node:child_process';
+import { readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join, relative } from 'node:path';
+
+const [, , inPath, outPath, ...rest] = process.argv;
+
+if (!inPath || !outPath) {
+  console.error('usage: lint-findings.mjs <eslint-json-file> <out-json> [--max N] [--base <sha>]');
+  process.exit(2);
+}
+
+const maxIdx = rest.indexOf('--max');
+const MAX_FINDINGS = maxIdx === -1 ? 25 : Number(rest[maxIdx + 1]) || 25;
+const baseIdx = rest.indexOf('--base');
+const BASE = baseIdx === -1 ? null : rest[baseIdx + 1];
+
+// eslint severity 2 = error, 1 = warning.
+//
+// An error is something CI will reject and a bot will certainly comment on, so
+// it is `important`. A warning is style the team has chosen not to enforce, so
+// it lands in `idiomatic` where it cannot affect the verdict.
+function severityFor(eslintSeverity) {
+  return eslintSeverity === 2 ? 'important' : 'idiomatic';
+}
+
+// Write a zero-finding result whose status says why, then stop. A missing,
+// empty or malformed report is "unknown", never "clean", so the review header
+// cannot claim a green lint that never ran.
+function bail(status, why) {
+  writeFileSync(
+    outPath,
+    JSON.stringify({ findings: [], summary: { status, ruleCount: 0, messageCount: 0 } }, null, 2),
+  );
+  console.log(`lint-findings: ${why}, 0 findings`);
+  process.exit(0);
+}
+
+let report;
+try {
+  const raw = readFileSync(inPath, 'utf8').trim();
+  if (!raw) bail('empty-report', 'empty eslint report');
+  report = JSON.parse(raw);
+} catch (err) {
+  bail('unreadable: ' + err.message, `could not read eslint report (${err.message})`);
+}
+
+if (!Array.isArray(report)) bail('not-an-eslint-json-report', 'report is not an eslint JSON array');
+// eslint emits one entry per linted file, so [] means nothing was linted.
+if (report.length === 0) bail('empty-report', 'eslint report lists no files');
+
+// Resolve symlinks on both sides: on macOS /tmp is /private/tmp, so eslint's
+// filePath and the worktree path given here can spell the same dir differently.
+function real(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+
+const repoRoot = process.env.LEKKER_WORKTREE_PATH ? real(process.env.LEKKER_WORKTREE_PATH) : '';
+
+function relativize(p) {
+  if (!repoRoot || !isAbsolute(p)) return p;
+  const rel = relative(repoRoot, real(p));
+  return rel.startsWith('..') ? p : rel;
+}
+
+// repo-relative path -> Set of line numbers the change added, or null when no
+// --base was given or git could not answer (then nothing is filtered).
+function addedLines() {
+  if (!BASE || !repoRoot) return null;
+  let out;
+  try {
+    // Explicit prefixes: diff.noprefix / diff.mnemonicPrefix would otherwise
+    // change the "+++ b/" header the parser below slices.
+    const args = ['-C', repoRoot, 'diff', '-U0', '--no-color', '--no-ext-diff', '--src-prefix=a/', '--dst-prefix=b/', BASE, 'HEAD'];
+    out = execFileSync('git', args, {
+      encoding: 'utf8',
+      maxBuffer: 64 * 1024 * 1024,
+    });
+  } catch {
+    return null;
+  }
+  const added = new Map();
+  let file = null;
+  for (const line of out.split('\n')) {
+    if (line.startsWith('+++ ')) {
+      file = line === '+++ /dev/null' ? null : line.slice(6);
+      if (file && !added.has(file)) added.set(file, new Set());
+      continue;
+    }
+    const hunk = file && /^@@ -\S+ \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (!hunk) continue;
+    const start = Number(hunk[1]);
+    const count = hunk[2] === undefined ? 1 : Number(hunk[2]);
+    for (let i = 0; i < count; i++) added.get(file).add(start + i);
+  }
+  return added;
+}
+
+const added = addedLines();
+let outOfDiff = 0;
+
+// Group every message by ruleId. Parse errors arrive with ruleId null; they are
+// real and worth surfacing, so they get their own bucket.
+const byRule = new Map();
+let messageCount = 0;
+
+for (const file of report) {
+  const filePath = String(file?.filePath ?? '');
+  for (const m of file?.messages ?? []) {
+    // A message with no ruleId is a parse error only when eslint marks it
+    // fatal. The rest are notices such as "File ignored because of a matching
+    // ignore pattern", which flag nothing wrong with the code.
+    if (!m.ruleId && !m.fatal) continue;
+    const ruleId = m.ruleId ?? 'parse-error';
+    // A parse error breaks the whole file, so it counts wherever it lands.
+    if (added && ruleId !== 'parse-error' && !added.get(relativize(filePath))?.has(m.line)) {
+      outOfDiff++;
+      continue;
+    }
+    messageCount++;
+    const key = `${ruleId}\0${filePath}`;
+    if (!byRule.has(key)) {
+      byRule.set(key, { ruleId, severity: m.severity ?? 2, fixable: false, sites: [] });
+    }
+    const bucket = byRule.get(key);
+    // A rule reported at both levels keeps the louder one.
+    bucket.severity = Math.max(bucket.severity, m.severity ?? 2);
+    if (m.fix) {
+      bucket.fixable = true;
+    }
+    bucket.sites.push({
+      file: filePath,
+      line: m.line ?? 1,
+      column: m.column ?? 1,
+      message: String(m.message ?? '').trim(),
+    });
+  }
+}
+
+// Errors before warnings, then the rules that fire most - a rule hit 12 times
+// is a pattern the author is repeating, and worth more than a one-off.
+const ruleCount = new Set([...byRule.values()].map(b => b.ruleId)).size;
+const buckets = [...byRule.values()].sort((a, b) => {
+  if (b.severity !== a.severity) return b.severity - a.severity;
+  return b.sites.length - a.sites.length;
+});
+
+// The offending source line, so badCode is code and not a location string.
+function sourceLine(file, line) {
+  try {
+    const abs = isAbsolute(file) ? file : join(repoRoot, file);
+    const text = readFileSync(abs, 'utf8').split('\n')[line - 1];
+    if (text?.trim()) return text.trim();
+  } catch {
+    // unreadable file: fall back to the location
+  }
+  return null;
+}
+
+const findings = buckets.slice(0, MAX_FINDINGS).map(bucket => {
+  const first = bucket.sites[0];
+  const others = bucket.sites.slice(1);
+  const extra = others.length
+    ? ' Also at: ' + others.slice(0, 8).map(s => `${relativize(s.file)}:${s.line}`).join(', ') +
+      (others.length > 8 ? ` (+${others.length - 8} more)` : '') + '.'
+    : '';
+
+  return {
+    file: relativize(first.file),
+    line: first.line,
+    severity: severityFor(bucket.severity),
+    title: `${bucket.ruleId} (${bucket.sites.length} site${bucket.sites.length === 1 ? '' : 's'})`,
+    description:
+      `The repo's own eslint config reports \`${bucket.ruleId}\` on the changed files: ` +
+      `"${first.message}".${extra} ` +
+      `This is the repo's configured rule, not a preference - it is the single most likely ` +
+      `bot-reviewer comment on this diff, and CI enforces it.` +
+      (bucket.fixable ? ' eslint can fix this automatically (`eslint --fix`).' : ''),
+    badCode:
+      sourceLine(first.file, first.line) ?? `${relativize(first.file)}:${first.line}:${first.column}`,
+    fix: bucket.fixable
+      ? `Apply eslint's autofix for \`${bucket.ruleId}\` to the cited lines only, then re-read the hunk. ` +
+        `A file-wide \`eslint --fix\` also rewrites lines this change did not touch.`
+      : `Resolve \`${bucket.ruleId}\` as the config intends. Check what the rule permits before ` +
+        `substituting another form: a config that bans one idiom often bans its obvious replacement too.`,
+    rule: `LINT:${bucket.ruleId}`,
+    botPredicted: true,
+    lintFixable: bucket.fixable,
+    lintSiteCount: bucket.sites.length,
+    // Every site, so bot-precision can match a bot comment on any of them.
+    lintSites: bucket.sites.map(s => ({ file: relativize(s.file), line: s.line })),
+  };
+});
+
+const result = {
+  findings,
+  summary: {
+    status: messageCount === 0 ? 'clean' : 'issues',
+    ruleCount: ruleCount,
+    messageCount,
+    truncated: Math.max(0, buckets.length - findings.length),
+    outOfDiff,
+  },
+};
+
+writeFileSync(outPath, JSON.stringify(result, null, 2));
+console.log(
+  `lint-findings: ${messageCount} message(s) across ${ruleCount} rule(s) -> ` +
+    `${findings.length} finding(s)${result.summary.truncated ? ` (${result.summary.truncated} rule(s) truncated)` : ''}`,
+);

package/adapters/claude/olko-github-pr/skills/lekker-review/scripts/mine-bot-comments.sh

@@ -0,0 +1,280 @@
+#!/usr/bin/env bash
+# Mine real Greptile / Gemini review comments from a repo's newest PR review comments
+# and cluster them into the patterns worth pre-empting.
+#
+# Why this exists: predicting bot-reviewer comments from a model's intuition is
+# guesswork. The bots have already told us what they comment on - dozens of
+# times, in this exact repo, on this exact codebase. Mining that is free and it
+# is evidence, not a guess.
+#
+# Usage:
+#   mine-bot-comments.sh <repo-slug> [out-md] [--limit N]
+#
+#   repo-slug   e.g. acme/web-app
+#   out-md      default: $LEKKER_DATA_DIR/bot-patterns.md, where LEKKER_DATA_DIR
+#               defaults to ~/.cache/lekker-review (outside the skill dir, so a
+#               plugin update does not wipe the mined history)
+#   --limit N   max review comments to fetch, newest first (default 400);
+#               paging stops there, so a long history is never pulled whole
+#
+# Writes/replaces a "## <repo-slug>" section in out-md, leaving other repos'
+# sections alone, and prints a one-line summary. The section carries a
+# "<!-- mined: YYYY-MM-DD -->" marker that SKILL.md reads to decide staleness;
+# a repo with no bot comments still gets a section, so it is not re-mined on
+# every run.
+
+set -uo pipefail
+
+REPO_SLUG="${1:-}"
+if [[ -z "$REPO_SLUG" ]]; then
+    echo "usage: mine-bot-comments.sh <repo-slug> [out-md] [--limit N]" >&2
+    exit 2
+fi
+shift
+
+DATA_DIR="${LEKKER_DATA_DIR:-$HOME/.cache/lekker-review}"
+OUT_MD="$DATA_DIR/bot-patterns.md"
+LIMIT=400
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --limit) LIMIT="${2:-}"; shift; [[ $# -gt 0 ]] && shift ;;
+        *)       OUT_MD="$1"; shift ;;
+    esac
+done
+
+if ! [[ "$LIMIT" =~ ^[1-9][0-9]*$ ]]; then
+    echo "mine-bot-comments: --limit needs a positive integer, got '$LIMIT'" >&2
+    exit 2
+fi
+
+mkdir -p "$(dirname "$OUT_MD")"
+
+python3 - "$REPO_SLUG" "$OUT_MD" "$LIMIT" <<'PYEOF'
+import datetime, json, os, re, subprocess, sys
+from collections import defaultdict
+
+repo_slug, out_md, limit = sys.argv[1:4]
+limit = int(limit)
+
+# Review comments are the inline ones - the class the bots actually bill for.
+# Page by hand rather than `gh api --paginate`, which fetches the whole history
+# before LIMIT could apply.
+comments = []
+page = 1
+while len(comments) < limit:
+    res = subprocess.run(
+        ["gh", "api", "repos/%s/pulls/comments?per_page=100&sort=created&direction=desc&page=%d"
+         % (repo_slug, page)],
+        capture_output=True, text=True)
+    if res.returncode != 0:
+        print("mine-bot-comments: gh api failed for %s (auth? repo name?)" % repo_slug, file=sys.stderr)
+        sys.exit(1)
+    batch = json.loads(res.stdout or "[]")
+    if not isinstance(batch, list):
+        break
+    comments.extend(batch)
+    if len(batch) < 100:
+        break
+    page += 1
+comments = comments[:limit]
+
+BOT_RE = re.compile(r'gemini-code-assist|greptile|coderabbit', re.I)
+
+
+def is_bot(c):
+    # A reply in a bot's own thread ("Thanks, updated") is not a new finding.
+    # The account type too: a human login can contain a bot's name.
+    user = c.get("user") or {}
+    return (user.get("type") == "Bot" and bool(BOT_RE.search(user.get("login", "")))
+            and not c.get("in_reply_to_id"))
+
+
+bot_comments = [c for c in comments if is_bot(c)]
+
+
+def first_claim(body):
+    """The sentence that carries the finding, with the bot's chrome removed."""
+    text = body or ""
+    # Both bots lead with chrome: Gemini an image badge, Greptile an <a><img>
+    # priority pill. Neither is the claim.
+    text = re.sub(r'!\[[^\]]*\]\([^)]*\)', '', text)
+    text = re.sub(r'<!--.*?-->', '', text, flags=re.S)
+    text = re.sub(r'<[^>]+>', ' ', text)
+    # Fenced code is the suggestion, not the claim.
+    text = re.sub(r'```.*?```', ' ', text, flags=re.S)
+    text = re.sub(r'`[^`]*`', ' CODE ', text)
+    text = re.sub(r'^\s*[#>*\-]+\s*', '', text, flags=re.M)
+    text = re.sub(r'\s+', ' ', text).strip()
+    parts = re.split(r'(?<=[.!?])\s', text)
+    for p in parts:
+        if len(p.strip()) > 25:
+            return p.strip()[:400]
+    return text[:400]
+
+
+STOP = set("""a an and are as at be been but by can could does for from has have if in into is it
+its may not of on or should that the their them there these this to was were will with would you your
+we i be his her they code line file change changes when which what while also""".split())
+
+
+def signature(claim):
+    words = re.findall(r'[a-z]+', claim.lower())
+    words = [w for w in words if len(w) > 3 and w not in STOP]
+    # The 6 longest words are a good enough fingerprint at this scale: short
+    # common words carry little. Ties break alphabetically so wording order
+    # does not split one pattern into two clusters.
+    return tuple(sorted(set(words), key=lambda w: (-len(w), w))[:6])
+
+
+# A curated taxonomy on top of the free-text clustering. Fingerprint clustering
+# splits one concern across several wordings ("casting violates policy", "the use
+# of CODE is a type cast", "TypeScript casts bypass checks" are one comment the
+# bots make three ways), and the CATEGORY is what a reviewer can act on before
+# the bot ever runs.
+CATEGORIES = [
+    ("type cast / any",        r'\btype (cast|assertion)|\bcasting\b|\bas unknown\b|\bany\b type|\bnon-null assertion'),
+    ("null / undefined guard", r'\bnull\b|\bundefined\b|optional chain|\bmissing (a )?check'),
+    ("error handling",         r'\berror (handling|is swallowed)|silently (fail|ignor)|catch block|\bthrow\b|unhandled'),
+    ("pagination",             r'\bpaginat|\bpageInfo\b|\bhasNextPage\b|\bcursor\b|page size'),
+    ("await / concurrency",    r'\bawait\b|floating promise|not awaited|\brace\b|concurren|fire.and.forget'),
+    ("unused / dead code",     r'\bunused\b|not used|dead code|\bunreachable\b|never referenced'),
+    ("debug / logging",        r'\bconsole\.|debug(ging)? (statement|log)|log(ging)? (noise|level)|should be removed before'),
+    ("hardcoded / magic value",r'\bhardcoded\b|magic (number|string)|should be (a )?constant|configurable'),
+    ("naming",                 r'\bnaming\b|\brename\b|\bmisleading name|the name CODE'),
+    ("comment / docs",         r'\bcomment (is|does|adds)|\bredundant comment|\bjsdoc\b|\btypo\b'),
+    ("test coverage",          r'\btest (coverage|case)|\bnot (covered|tested)|missing (a )?test'),
+    ("performance / N+1",      r'\bN\+1\b|\bin a loop\b|inefficien|\bperformance\b|every (run|iteration)|batch'),
+    ("schedule / config",      r'\bcron\b|\bschedul|\benv (var|variable)|\byaml\b|\bvalues\.'),
+    ("SQL / query",            r'\bSQL\b|\bquery uses\b|\bwhere clause\b|\bindex\b|\btransaction\b'),
+]
+
+
+def categorize(body):
+    text = body or ""
+    hits = [name for name, rx in CATEGORIES if re.search(rx, text, re.I)]
+    return hits or ["other"]
+
+
+PRIORITY_RE = re.compile(r'badges/(p[0-9])\.svg|\b(P[0-9])\b')
+
+
+def priority(body):
+    m = PRIORITY_RE.search(body or "")
+    if not m:
+        return None
+    return (m.group(1) or m.group(2) or "").upper()
+
+
+category_counts = defaultdict(int)
+category_priority = defaultdict(list)
+for c in bot_comments:
+    prio = priority(c.get("body", ""))
+    for name in categorize(c.get("body", "")):
+        category_counts[name] += 1
+        if prio:
+            category_priority[name].append(prio)
+
+clusters = defaultdict(list)
+for c in bot_comments:
+    claim = first_claim(c.get("body", ""))
+    if not claim:
+        continue
+    clusters[signature(claim)].append((claim, c))
+
+# Merge clusters that share most of their fingerprint - one pattern phrased two
+# ways should not read as two patterns with a count of 1 each.
+merged = []
+for sig, items in sorted(clusters.items(), key=lambda kv: -len(kv[1])):
+    for m in merged:
+        shared = len(set(sig) & set(m["sig"]))
+        if sig and m["sig"] and shared / max(len(set(sig) | set(m["sig"])), 1) >= 0.5:
+            m["items"].extend(items)
+            break
+    else:
+        merged.append({"sig": sig, "items": list(items)})
+
+merged.sort(key=lambda m: -len(m["items"]))
+
+lines = []
+lines.append("## %s" % repo_slug)
+lines.append("<!-- mined: %s -->" % datetime.date.today().isoformat())
+lines.append("")
+if not bot_comments:
+    lines.append("No bot review comments in the newest %d review comment(s)." % len(comments))
+    lines.append("")
+else:
+    lines.append("Mined from %d bot review comment(s) (%s). Counts are how many times the "
+                 "bots have raised that pattern in THIS repo - the higher the count, the more "
+                 "certain it is to come back on the next PR."
+                 % (len(bot_comments), ", ".join(sorted({(c.get("user") or {}).get("login", "?")
+                                                         for c in bot_comments}))))
+    lines.append("")
+    lines.append("### Categories, most-raised first")
+    lines.append("")
+    lines.append("| times raised | category | typical priority |")
+    lines.append("|---|---|---|")
+    for name, count in sorted(category_counts.items(), key=lambda kv: -kv[1]):
+        prios = category_priority.get(name, [])
+        typical = min(prios) if prios else "-"
+        lines.append("| %d | %s | %s |" % (count, name, typical))
+    lines.append("")
+    lines.append("A comment can land in more than one category, so the column sums above the")
+    lines.append("comment total. Read the categories as priors: on a diff that touches one of")
+    lines.append("them, assume the bots will raise it and settle it before opening the PR.")
+    lines.append("")
+    lines.append("### Concrete comments, most-repeated first")
+    lines.append("")
+
+    for m in merged:
+        if len(m["items"]) < 2 and len(merged) > 12:
+            continue
+        claim, c = m["items"][0]
+        count = len(m["items"])
+        path = c.get("path") or "?"
+        lines.append("- **x%d** - %s" % (count, claim))
+        lines.append("  - e.g. `%s` ([comment](%s))" % (path, c.get("html_url", "")))
+
+    lines.append("")
+
+body = "\n".join(lines)
+
+# The file is shared by every repo, so two reviews mining at once must not
+# lose each other's sections: hold a lock across read-modify-write, and replace
+# the file atomically so a reader never sees half of it.
+import fcntl, tempfile
+lock = open(out_md + ".lock", "w")
+fcntl.flock(lock, fcntl.LOCK_EX)
+
+existing = ""
+if os.path.exists(out_md):
+    with open(out_md) as f:
+        existing = f.read()
+
+header = ("# Bot reviewer patterns\n\n"
+          "What Greptile / Gemini / CodeRabbit have actually commented on, per repo, mined\n"
+          "from review-comment history by `scripts/mine-bot-comments.sh`. This is evidence,\n"
+          "not prediction: every line below is a comment a bot really left.\n\n"
+          "Delivered to the review agents as `botPatternsFile`. Regenerate per repo with\n"
+          "`scripts/mine-bot-comments.sh <repo-slug>`.\n\n")
+
+if not existing.startswith("# Bot reviewer patterns"):
+    existing = header + existing
+
+# Replace this repo's section in place; leave every other repo alone.
+pattern = re.compile(r'^## %s$.*?(?=^## |\Z)' % re.escape(repo_slug), re.M | re.S)
+if pattern.search(existing):
+    # A function replacement, so backslashes in mined bot text are literal.
+    existing = pattern.sub(lambda _: body, existing)
+else:
+    existing = existing.rstrip() + "\n\n" + body
+
+fd, tmp = tempfile.mkstemp(dir=os.path.dirname(os.path.abspath(out_md)), prefix=".bot-patterns.")
+with os.fdopen(fd, "w") as f:
+    f.write(existing)
+os.replace(tmp, out_md)
+fcntl.flock(lock, fcntl.LOCK_UN)
+
+print("mine-bot-comments: %d bot comment(s) -> %d pattern(s) -> %s"
+      % (len(bot_comments), len(merged), out_md))
+PYEOF