@rigour-labs/core 6.8.1 → 6.9.0-rc.2

package/dist/review-learning/outcome-evidence.js

@@ -0,0 +1,72 @@
+import { lessonState } from './lessons.js';
+import { outcomeFor } from './outcomes.js';
+/** Lines either side of a point's own that count as its lines, and the most files a fixing commit may touch to say anything about one point. */
+const POINT_SLACK = 3;
+const MAX_FIX_FILES = 15;
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Adds the evidence the settled and unsettled records give, to `lessons` in place, once each (by its comment key), and
+ * recomputes their states. `applied` is, per pull request, the lessons a review of it recorded as applying.
+ */
+export function applyOutcomeEvidence(lessons, records, applied, options) {
+    const byPr = new Map(records.map(r => [r.pr, r]));
+    const result = { added: 0, suggested: [], demoted: [] };
+    for (const lesson of lessons) {
+        const before = lesson.state;
+        const add = (evidence) => {
+            if (lesson.evidence.some(e => e.comment === evidence.comment))
+                return false;
+            lesson.evidence.push(evidence);
+            result.added++;
+            return true;
+        };
+        const own = new Set(lesson.evidence.filter(e => (e.kind ?? 'point') === 'point').map(e => e.pr));
+        // For it: a point its pull request left alone, whose own lines a later fix inside the window changed.
+        for (const point of lesson.evidence.filter(e => (e.kind ?? 'point') === 'point' && e.actedOn === false)) {
+            const record = byPr.get(point.pr);
+            // Only where the record shows a fix on the file at all: following lines costs a git walk, done only then.
+            const fileFix = lesson.file ? record?.followUps.find(f => f.fix && f.files.includes(lesson.file)) : undefined;
+            if (!record || !fileFix)
+                continue;
+            const context = [record.ci === 'failure' ? 'CI regressed on the merge commit' : '', record.reverted ? `the pull request was reverted by ${record.reverted.sha.slice(0, 9)}` : ''].filter(Boolean).join('; ');
+            const inTime = options.deadline === undefined || Date.now() <= options.deadline;
+            const lines = options.git && options.mainRef && lesson.at && inTime
+                ? outcomeFor(options.git, lesson, { number: record.pr, mergeSha: record.mergeSha, mergedAt: record.mergedAt }, { mainRef: options.mainRef, until: record.windowEnd, slack: POINT_SLACK, maxFiles: MAX_FIX_FILES })
+                : undefined;
+            // Evidence for a person, never a promotion: a fix on the same lines is often unrelated work.
+            if (lines?.kind === 'outcome') {
+                const evidence = { ...lines, kind: 'lines', comment: `lines-${record.pr}-${lines.comment.replace(/^outcome-/, '')}`, detail: `${lines.detail}${context ? `; ${context}` : ''}` };
+                if (add(evidence) && !result.suggested.includes(lesson.id))
+                    result.suggested.push(lesson.id);
+            }
+            else {
+                add({ kind: 'followup', pr: record.pr, comment: `followup-${record.pr}-${fileFix.sha.slice(0, 12)}`, author: '', detail: `${lesson.file} fixed later by ${fileFix.sha.slice(0, 9)} "${fileFix.subject}", not on the point's lines${context ? `; ${context}` : ''}`, at: fileFix.at });
+            }
+        }
+        // Against it: later pull requests a review found repeating it, merged anyway, settled clean.
+        if (lesson.state === 'verified' && (lesson.promotedBy === 'outcome' || lesson.promotedBy === 'recurrence')) {
+            for (const [pr, ids] of applied) {
+                const record = byPr.get(pr);
+                if (own.has(pr) || !ids.has(lesson.id) || !record || !settledClean(record, lesson.file))
+                    continue;
+                add({ kind: 'against', pr, comment: `against-${pr}`, author: '', prAuthor: record.author, detail: `a review found #${pr} repeating it; merged ${record.mergedAt.slice(0, 10)}, CI passed, no fix on ${lesson.file || 'its files'} within the window, no revert`, at: record.mergedAt });
+            }
+            const against = lesson.evidence.filter(e => e.kind === 'against');
+            const authors = new Set(against.map(e => e.prAuthor).filter(Boolean)).size;
+            // Independent: more than one author, or merged at least a week apart (a span, never calendar buckets: two merges a day apart across a week boundary are not).
+            const times = against.map(e => Date.parse(e.at ?? '')).filter(Number.isFinite);
+            const apart = times.length > 1 && Math.max(...times) - Math.min(...times) >= WEEK_MS;
+            if (new Set(against.map(e => e.pr)).size >= options.demoteAfter && (authors > 1 || apart)) {
+                add({ kind: 'demoted', pr: against.at(-1).pr, comment: `demoted-${against.map(e => e.pr).sort((a, b) => a - b).join('-')}`, author: '', detail: `taken back: ${against.map(e => `#${e.pr}`).join(', ')} repeated it and settled clean`, at: new Date().toISOString() });
+            }
+        }
+        Object.assign(lesson, lessonState(lesson));
+        if (before === 'verified' && lesson.state === 'candidate')
+            result.demoted.push(lesson.id);
+    }
+    return result;
+}
+/** CI passed on the merge commit, no fix touched the file (any file, for a team standard) within the window, no revert. Settled only. */
+function settledClean(record, file) {
+    return record.settled && record.ci === 'success' && !record.reverted && !record.followUps.some(f => f.fix && (!file || f.files.includes(file)));
+}

package/dist/review-learning/outcomes.d.ts

@@ -7,6 +7,8 @@
  */
 import type { Git } from './acted-on.js';
 import type { LessonEvidence, ReviewLesson } from './lessons.js';
+/** Commit subjects that say the commit fixed something. */
+export declare const FIX: RegExp;
 export interface OutcomeOptions {
     /** The main branch the pull request merged into. */
     mainRef: string;
@@ -14,6 +16,10 @@ export interface OutcomeOptions {
     until?: string;
     /** How long unchanged lines must ship before that counts against the point. */
     windowDays?: number;
+    /** Lines either side of the point's own that count as its lines (outcome-evidence.ts: 3). */
+    slack?: number;
+    /** A fixing commit that touches more files than this is a sweep, and says nothing about one point: no verdict. */
+    maxFiles?: number;
 }
 export interface MergedAt {
     number: number;
@@ -24,3 +30,5 @@ export interface MergedAt {
 export declare function outcomeFor(git: Git, lesson: ReviewLesson, pr: MergedAt, options: OutcomeOptions): LessonEvidence | undefined;
 /** A revert of the pull request on main, before `until`: an outcome for every point it left unaddressed. */
 export declare function revertOf(git: Git, pr: MergedAt, options: OutcomeOptions): LessonEvidence | undefined;
+/** A commit subject that reverts the pull request: "Revert ..." naming its number or its merge commit. */
+export declare function revertsPr(subject: string, pr: Pick<MergedAt, 'number' | 'mergeSha'>): boolean;

package/dist/review-learning/outcomes.js

@@ -1,13 +1,14 @@
 import { changedHunks } from './acted-on.js';
 /** Commit subjects that say the commit fixed something. */
-const FIX = /\b(fix(e[sd])?|bug|hotfix|regression|revert|broke|broken)\b/i;
+export const FIX = /\b(fix(e[sd])?|bug|hotfix|regression|revert|broke|broken)\b/i;
 const DAY_MS = 24 * 60 * 60 * 1000;
 /** The outcome or counter evidence for an inline point the pull request did not act on, or undefined when there is none yet. */
 export function outcomeFor(git, lesson, pr, options) {
     const point = lesson.evidence.find(e => (e.kind ?? 'point') === 'point' && e.pr === pr.number);
     if (!point || point.actedOn || !lesson.at || !lesson.file || !pr.mergedAt)
         return undefined;
-    let range = shift(changedHunks(git, lesson.at.commit, pr.mergeSha, lesson.file), [lesson.at.start, lesson.at.end]);
+    const slack = options.slack ?? 0;
+    let range = shift(changedHunks(git, lesson.at.commit, pr.mergeSha, lesson.file), [Math.max(1, lesson.at.start - slack), lesson.at.end + slack]);
     if (!range)
         return undefined; // the pull request changed them after all
     const before = options.until ? [`--before=${options.until}`] : [];
@@ -26,8 +27,9 @@ export function outcomeFor(git, lesson, pr, options) {
             continue;
         }
         const [subject, date] = git(['log', '-1', '--format=%s%x09%cI', sha]).trim().split('\t');
-        // Changed by a commit that says it fixed something: the point was right. Changed otherwise: no verdict.
-        return FIX.test(subject) ? { kind: 'outcome', pr: pr.number, comment: `outcome-${sha.slice(0, 12)}`, author: '', detail: `fixed later by ${sha.slice(0, 9)} "${subject}"`, at: date } : undefined;
+        // Changed by a commit that says it fixed something, and is not a sweep across the codebase: the point was right. Changed otherwise: no verdict.
+        const sweep = options.maxFiles !== undefined && git(['show', '--name-only', '--format=', sha]).split('\n').filter(Boolean).length > options.maxFiles;
+        return FIX.test(subject) && !sweep ? { kind: 'outcome', pr: pr.number, comment: `outcome-${sha.slice(0, 12)}`, author: '', detail: `fixed later by ${sha.slice(0, 9)} "${subject}"`, at: date } : undefined;
     }
     const now = options.until ? Date.parse(options.until) : Date.now();
     const days = Math.floor((now - Date.parse(pr.mergedAt)) / DAY_MS);
@@ -46,12 +48,16 @@ export function revertOf(git, pr, options) {
     }
     for (const line of log.split('\n')) {
         const [sha, date, subject] = line.split('\t');
-        if (sha && /^revert\b/i.test(subject ?? '') && (subject.includes(`#${pr.number}`) || subject.includes(pr.mergeSha.slice(0, 7)))) {
+        if (sha && revertsPr(subject ?? '', pr)) {
             return { kind: 'outcome', pr: pr.number, comment: `revert-${sha.slice(0, 12)}`, author: '', detail: `the pull request was reverted by ${sha.slice(0, 9)} "${subject}"`, at: date };
         }
     }
     return undefined;
 }
+/** A commit subject that reverts the pull request: "Revert ..." naming its number or its merge commit. */
+export function revertsPr(subject, pr) {
+    return /^revert\b/i.test(subject) && (subject.includes(`#${pr.number}`) || subject.includes(pr.mergeSha.slice(0, 7)));
+}
 /** The range after a commit's hunks, or undefined when a hunk touched it. */
 function shift(hunks, [start, end]) {
     let offset = 0;

package/dist/settings.d.ts

@@ -32,6 +32,8 @@ export interface RigourSettings {
         verboseOutput?: boolean;
     };
     reviewer?: UserReviewerSettings;
+    goal?: boolean;
+    outcomes?: boolean;
     cursor?: {
         apiKey?: string;
     };