initial commit

Signed-off-by: NotAShelf <raf@notashelf.dev>
Change-Id: Ic08e7c4b5b4f4072de9e2f9a701e977b6a6a6964

src/engine/quality.ts

@@ -0,0 +1,179 @@
+import type {
+  AnalysisResult,
+  EngineBackend,
+  QualityBackendConfig,
+  WebhookEvent,
+} from '../types.js';
+
+// Conventional commit prefixes
+const CONVENTIONAL_COMMIT =
+  /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?!?:\s/i;
+
+const WIP_PATTERN = /\b(wip|work.in.progress|do.not.merge|don't.merge|draft)\b/i;
+const BREAKING_PATTERN = /\b(breaking.change|BREAKING)\b/i;
+const TODO_PATTERN = /\b(TODO|FIXME|HACK|XXX|TEMP)\b/;
+
+export class QualityBackend implements EngineBackend {
+  name = 'quality';
+
+  constructor(private config: QualityBackendConfig) {}
+
+  async analyze(event: WebhookEvent): Promise<AnalysisResult> {
+    const body = event.body.trim();
+    const title = event.title.trim();
+    const signals: { name: string; positive: boolean; weight: number }[] = [];
+
+    // --- Title analysis ---
+
+    if (title.length < 10) {
+      signals.push({ name: 'very short title', positive: false, weight: 1.2 });
+    } else if (title.length > 200) {
+      signals.push({ name: 'excessively long title', positive: false, weight: 0.5 });
+    }
+
+    if (CONVENTIONAL_COMMIT.test(title)) {
+      signals.push({ name: 'conventional commit format', positive: true, weight: 1 });
+    }
+
+    if (WIP_PATTERN.test(title) || WIP_PATTERN.test(body)) {
+      signals.push({ name: 'marked as work-in-progress', positive: false, weight: 1.5 });
+    }
+
+    // --- Body analysis ---
+
+    if (body.length === 0) {
+      signals.push({ name: 'empty description', positive: false, weight: 2 });
+    } else if (body.length < this.config.minBodyLength) {
+      signals.push({ name: `short description (${body.length} chars)`, positive: false, weight: 1.2 });
+    } else if (body.length >= this.config.minBodyLength) {
+      signals.push({ name: 'adequate description', positive: true, weight: 1 });
+      if (body.length > 300) {
+        signals.push({ name: 'thorough description', positive: true, weight: 0.5 });
+      }
+    }
+
+    if (/```[\s\S]*?```/.test(body)) {
+      signals.push({ name: 'has code blocks', positive: true, weight: 0.7 });
+    }
+
+    if (/^#{1,6}\s/m.test(body)) {
+      signals.push({ name: 'has section headers', positive: true, weight: 0.8 });
+    }
+
+    // Checklists
+    const checklistItems = body.match(/^[\s]*-\s*\[[ x]\]/gm);
+    if (checklistItems) {
+      const checked = checklistItems.filter((i) => /\[x\]/i.test(i)).length;
+      const total = checklistItems.length;
+      if (total > 0 && checked === total) {
+        signals.push({ name: `checklist complete (${total}/${total})`, positive: true, weight: 1 });
+      } else if (total > 0) {
+        signals.push({ name: `checklist incomplete (${checked}/${total})`, positive: false, weight: 0.8 });
+      }
+    }
+
+    // Breaking changes
+    if (BREAKING_PATTERN.test(title) || BREAKING_PATTERN.test(body)) {
+      // Not inherently positive or negative, but we flag it for visibility.
+      // If there's a description of the breaking change, it's better.
+      if (body.length > 100 && BREAKING_PATTERN.test(body)) {
+        signals.push({ name: 'breaking change documented', positive: true, weight: 0.8 });
+      } else {
+        signals.push({ name: 'breaking change mentioned but not detailed', positive: false, weight: 0.8 });
+      }
+    }
+
+    // TODOs/FIXMEs in description suggest unfinished work
+    const todoMatches = body.match(TODO_PATTERN);
+    if (todoMatches) {
+      signals.push({ name: `unfinished markers in description (${todoMatches.length})`, positive: false, weight: 0.6 });
+    }
+
+    // --- Type-specific signals ---
+
+    if (event.type === 'issue') {
+      if (/\b(steps?\s+to\s+reproduce|reproduction|repro\s+steps?)\b/i.test(body)) {
+        signals.push({ name: 'has reproduction steps', positive: true, weight: 1.3 });
+      }
+
+      if (/\b(expected|actual)\s+(behavior|behaviour|result|output)\b/i.test(body)) {
+        signals.push({ name: 'has expected/actual behavior', positive: true, weight: 1.2 });
+      }
+
+      if (/\b(version|environment|os|platform|browser|node|python|java|rust|go)\s*[:\d]/i.test(body)) {
+        signals.push({ name: 'has environment details', positive: true, weight: 1 });
+      }
+
+      if (/\b(stack\s*trace|traceback|error|exception|panic)\b/i.test(body)) {
+        signals.push({ name: 'includes error output', positive: true, weight: 0.8 });
+      }
+
+      // Template usage detection (common issue template markers)
+      if (/\b(describe the bug|feature request|is your feature request related to)\b/i.test(body)) {
+        signals.push({ name: 'uses issue template', positive: true, weight: 0.6 });
+      }
+    }
+
+    if (event.type === 'pull_request') {
+      if (/\b(fix(es)?|clos(es|ing)|resolv(es|ing))\s+#\d+/i.test(body)) {
+        signals.push({ name: 'links to issue', positive: true, weight: 1.3 });
+      }
+
+      if (/\b(test\s*(plan|strategy|coverage)|how\s+to\s+test|testing|tested\s+by)\b/i.test(body)) {
+        signals.push({ name: 'has test plan', positive: true, weight: 1.2 });
+      }
+
+      // Migration or upgrade guide
+      if (/\b(migration|upgrade|breaking).*(guide|instruction|step)/i.test(body)) {
+        signals.push({ name: 'has migration guide', positive: true, weight: 1 });
+      }
+
+      // Before/after comparison
+      if (/\b(before|after)\b/i.test(body) && /\b(before|after)\b/gi.test(body)) {
+        const beforeAfter = body.match(/\b(before|after)\b/gi);
+        if (beforeAfter && beforeAfter.length >= 2) {
+          signals.push({ name: 'has before/after comparison', positive: true, weight: 0.7 });
+        }
+      }
+    }
+
+    // Shared: references to other issues/PRs
+    const refs = body.match(/#\d+/g);
+    if (refs && refs.length > 0) {
+      signals.push({ name: `references ${refs.length} issue(s)/PR(s)`, positive: true, weight: 0.6 });
+    }
+
+    // Screenshots or images
+    if (/!\[.*\]\(.*\)/.test(body) || /<img\s/i.test(body)) {
+      signals.push({ name: 'has images/screenshots', positive: true, weight: 0.8 });
+    }
+
+    // --- Weighted scoring ---
+
+    if (signals.length === 0) {
+      return { impact: 'neutral', confidence: 0.1, reasoning: 'No quality signals detected.' };
+    }
+
+    const positiveWeight = signals.filter((s) => s.positive).reduce((s, x) => s + x.weight, 0);
+    const negativeWeight = signals.filter((s) => !s.positive).reduce((s, x) => s + x.weight, 0);
+
+    let impact: AnalysisResult['impact'];
+    if (positiveWeight > negativeWeight * 1.2) {
+      impact = 'positive';
+    } else if (negativeWeight > positiveWeight * 1.2) {
+      impact = 'negative';
+    } else {
+      impact = 'neutral';
+    }
+
+    const totalWeight = positiveWeight + negativeWeight;
+    const confidence = Math.min(
+      1,
+      Math.abs(positiveWeight - negativeWeight) / Math.max(totalWeight, 1) * 0.5 + 0.2
+    );
+
+    const reasoning = `Quality: ${signals.map((s) => `${s.positive ? '+' : '-'} ${s.name}`).join(', ')}.`;
+
+    return { impact, confidence, reasoning };
+  }
+}