buddy-workbench 0.1.67 → 0.1.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.67",
+  "version": "0.1.68",
   "private": false,
   "type": "module",
   "bin": {

package/server/repositories/settings.js

@@ -95,6 +95,51 @@ export function saveClipboardDeduplicateMinutes(minutes) {
   return settingsStatus();
 }
 
+export function readPrReviewRules(defaultRules) {
+  const settings = readSettings();
+  const savedRules = settings.prReviewRules && typeof settings.prReviewRules === 'object' ? settings.prReviewRules : {};
+  return defaultRules.map((rule) => ({
+    ...rule,
+    enabled: savedRules[rule.id]?.enabled !== false,
+    severity: ['critical', 'warning', 'info'].includes(savedRules[rule.id]?.severity)
+      ? savedRules[rule.id].severity
+      : rule.severity
+  }));
+}
+
+export function readPrReviewCustomRules() {
+  const settings = readSettings();
+  return Array.isArray(settings.prReviewCustomRules) ? settings.prReviewCustomRules : [];
+}
+
+export function savePrReviewRules(rules, customRules, defaultRules) {
+  const settings = readSettings();
+  const allowed = new Map(defaultRules.map((rule) => [rule.id, rule]));
+  settings.prReviewRules = {};
+  for (const rule of Array.isArray(rules) ? rules : []) {
+    const defaultRule = allowed.get(rule?.id);
+    if (!defaultRule) continue;
+    settings.prReviewRules[defaultRule.id] = {
+      enabled: rule.enabled !== false,
+      severity: ['critical', 'warning', 'info'].includes(rule.severity) ? rule.severity : defaultRule.severity
+    };
+  }
+  settings.prReviewCustomRules = (Array.isArray(customRules) ? customRules : [])
+    .filter((rule) => rule && typeof rule.id === 'string' && typeof rule.name === 'string' && typeof rule.pattern === 'string' && rule.name.trim() && rule.pattern.trim())
+    .map((rule) => ({
+      id: rule.id.slice(0, 80),
+      name: rule.name.trim().slice(0, 120),
+      pattern: rule.pattern.slice(0, 500),
+      flags: typeof rule.flags === 'string' ? rule.flags.replace(/[^dgimsuvy]/g, '').slice(0, 8) : 'g',
+      message: typeof rule.message === 'string' && rule.message.trim() ? rule.message.trim().slice(0, 300) : 'Custom pattern matched.',
+      enabled: rule.enabled !== false,
+      severity: ['critical', 'warning', 'info'].includes(rule.severity) ? rule.severity : 'warning'
+    }));
+  mkdirSync(dirname(paths.settings), { recursive: true });
+  writeFileSync(paths.settings, JSON.stringify(settings, null, 2), { mode: 0o600 });
+  return { rules: readPrReviewRules(defaultRules), customRules: readPrReviewCustomRules() };
+}
+
 const accessTokenFields = {
   bitbucket: 'bitbucketAccessToken',
   jira: 'jiraAccessToken',

package/server/routes/pr-review.js

@@ -1,13 +1,52 @@
 import https from 'node:https';
 import axios from 'axios';
 import { Router } from 'express';
-import { readSettings } from '../repositories/settings.js';
+import { readSettings, readPrReviewCustomRules, readPrReviewRules, savePrReviewRules } from '../repositories/settings.js';
 import { recordApiError } from '../lib/api-errors.js';
 
 const router = Router();
 const previewLimit = 2000;
 let lastUsedHost = '';
 
+const PR_REVIEW_RULES = [
+  { id: 'lodash-get', name: 'Lodash Get Required', description: 'Prefer lodash/get for nested object property access.', pattern: String.raw`\b([a-zA-Z_$][\w$]*)\s*(\?\.|\.)\s*([a-zA-Z_$][\w$]*)\b(?!\s*\()`, severity: 'warning' },
+  { id: 'no-any', name: 'No Any Type', description: 'Disallow the TypeScript any type.', pattern: String.raw`:\s*any\b|:\s*any\[\]|as\s+any\b|<[^>]*?\bany\b[^>]*?>|\bany\[\]`, severity: 'critical' },
+  { id: 'no-hardcoded-strings', name: 'No Hardcoded Strings', description: 'Move hardcoded text into constants or i18n.', pattern: String.raw`(const|let|var)\s+[a-zA-Z_$][\w$]*\s*=\s*['"][^'"]+['"]`, severity: 'warning' },
+  { id: 'no-inline-styles', name: 'No Inline Styles', description: 'Use CSS classes or styled components instead of inline styles.', pattern: String.raw`\bstyle\s*=\s*\{\s*\{[\s\S]*?\}\s*\}|\bstyle\s*=\s*['"][\s\S]*?['"]`, severity: 'warning' },
+  { id: 'clickable-element-tag', name: 'Clickable Element Tag', description: 'Use button or anchor elements for clickable UI.', pattern: String.raw`<(div|span|p|li|tr|td|img|i|svg|section|article|header|footer|h[1-6]|label)\b[^>]*?\b(onClick|@click)\b[^>]*?>`, severity: 'warning' },
+  { id: 'no-relative-paths', name: 'No Relative Paths', description: 'Use absolute module imports or path aliases.', pattern: String.raw`import\s*(?:\{[^}]*\}|[^{'"\n]+)\s*from\s*['"]\.\.?\/*['"]|require\s*\(\s*['"]\.\.?\/*['"]\)`, severity: 'warning' },
+  { id: 'no-debugger', name: 'No Debugger', description: 'Disallow debugger statements in committed code.', pattern: String.raw`\bdebugger\b`, severity: 'critical' },
+  { id: 'no-console-log', name: 'No Console Log', description: 'Disallow leftover console.log statements.', pattern: String.raw`\bconsole\.log\b`, severity: 'critical' },
+  { id: 'no-array-index-key', name: 'No Array Index Key', description: 'Avoid array indexes as React list keys.', pattern: String.raw`\bkey\s*=\s*\{\s*(index|idx|i)\s*\}`, severity: 'warning' },
+  { id: 'no-nested-components', name: 'No Nested Components', description: 'Keep React component definitions outside component bodies.', pattern: String.raw`^\s*(const|function)\s+[A-Z][a-zA-Z0-9_$]*\s*=\s*\(|\bfunction\s+[A-Z][a-zA-Z0-9_$]*\s*\(`, severity: 'warning' },
+  { id: 'no-async-component', name: 'No Async Component', description: 'Disallow async client components.', pattern: String.raw`\b(const|function)\s+[A-Z][a-zA-Z0-9_$]*\s*=\s*async\b|\basync\s+function\s+[A-Z][a-zA-Z0-9_$]*`, severity: 'critical' },
+  { id: 'no-non-null-assertion', name: 'No Non-null Assertion', description: 'Prefer optional chaining and defensive null checks.', pattern: String.raw`[a-zA-Z0-9_$]!\s*(\.|\[)`, severity: 'warning' },
+  { id: 'no-direct-state-mutation', name: 'No Direct State Mutation', description: 'Use immutable updates for React state.', pattern: String.raw`\b(state|list|items|data)\.(push|pop|shift|unshift|splice|sort|reverse)\s*\(|\bstate\.[a-zA-Z0-9_$]+\s*=\s*`, severity: 'warning' },
+  { id: 'unhandled-async-event', name: 'Unhandled Async Event', description: 'Wrap async event handlers in try/catch.', pattern: String.raw`\bon[A-Z][a-zA-Z0-9_$]*\s*=\s*\{\s*async\b[\s\S]*?\}`, severity: 'warning' },
+  { id: 'no-magic-numbers', name: 'No Magic Numbers', description: 'Define named constants for business-logic numbers.', pattern: String.raw`(===|==|!==|!=)\s*([2-9]|\d{2,})\b|\bsetTimeout\s*\([^,]+,\s*([2-9]|\d{2,})\)`, severity: 'info' }
+];
+
+router.get('/rules', (_req, res) => res.json({ rules: readPrReviewRules(PR_REVIEW_RULES), customRules: readPrReviewCustomRules() }));
+router.put('/rules', (req, res) => {
+  if (!Array.isArray(req.body?.rules)) return res.status(400).json({ error: 'Rules must be an array.' });
+  res.json(savePrReviewRules(req.body.rules, req.body.customRules, PR_REVIEW_RULES));
+});
+
+function getRuleSettings() {
+  return Object.fromEntries(readPrReviewRules(PR_REVIEW_RULES).map((rule) => [rule.name, rule]));
+}
+
+function getCustomRuleSettings() {
+  return readPrReviewCustomRules().filter((rule) => rule.enabled !== false).map((rule) => {
+    try {
+      const flags = rule.flags || 'g';
+      return { ...rule, regex: new RegExp(rule.pattern, flags.includes('g') ? flags : `${flags}g`) };
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+
 const httpsAgent = new https.Agent({ rejectUnauthorized: false });
 const httpClient = axios.create({
   httpsAgent,
@@ -62,6 +101,8 @@ const isFiltered = (filePath) => {
 
 const analyzeDiff = (filePath, hunks) => {
   const issues = [];
+  const ruleSettings = getRuleSettings();
+  const customRules = getCustomRuleSettings();
 
   for (const hunk of hunks || []) {
     for (const segment of hunk.segments || []) {
@@ -94,10 +135,12 @@ const analyzeDiff = (filePath, hunks) => {
       };
 
       const addIssue = (severity, rule, message, charIndex, customCode) => {
+        const configuredRule = ruleSettings[rule];
+        if (configuredRule?.enabled === false) return;
         const { lineNum, text } = getLineInfo(charIndex);
         if (!issues.some(i => i.rule === rule && i.line === lineNum)) {
           issues.push({
-            severity,
+            severity: configuredRule?.severity || severity,
             rule,
             message,
             line: lineNum,
@@ -106,6 +149,13 @@ const analyzeDiff = (filePath, hunks) => {
         }
       };
 
+      for (const customRule of customRules) {
+        customRule.regex.lastIndex = 0;
+        for (const match of segmentText.matchAll(customRule.regex)) {
+          addIssue(customRule.severity, customRule.name, customRule.message, match.index, match[0]);
+        }
+      }
+
       // Rule 1: Object property extraction requires lodash.get
       const propAccessRegex = /\b([a-zA-Z_$][\w$]*)\s*(\?\.|\.)\s*([a-zA-Z_$][\w$]*)\b(?!\s*\()/g;
       for (const match of segmentText.matchAll(propAccessRegex)) {
@@ -153,16 +203,7 @@ const analyzeDiff = (filePath, hunks) => {
         }
       }
 
-      // Rule 4: useMemo and useCallback must specify dependencies (multiline regex)
-      const hookRegex = /\buse(Memo|Callback)\s*\(\s*(?:(?!,\s*\[).)*?\)/gs;
-      for (const match of segmentText.matchAll(hookRegex)) {
-        const matchedSnippet = match[0];
-        if (matchedSnippet.includes(', []') || !matchedSnippet.includes(', [')) {
-          addIssue('warning', 'Missing Hook Dependency', '`useMemo` and `useCallback` must specify dynamic dependencies (missing array or empty `[]` is prohibited).', match.index, matchedSnippet);
-        }
-      }
-
-      // Rule 5: No inline styles (multiline)
+      // Rule 4: No inline styles (multiline)
       const styleRegex = /\bstyle\s*=\s*\{\s*\{[\s\S]*?\}\s*\}|\bstyle\s*=\s*['"][\s\S]*?['"]/g;
       for (const match of segmentText.matchAll(styleRegex)) {
         addIssue('warning', 'No Inline Styles', 'Inline styles are strictly prohibited. Use CSS classes or styled components.', match.index);