buddy-workbench 0.1.21 → 0.1.23

package/package.json

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

package/server/config.js

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'node:url';
 
 export const root = dirname(dirname(fileURLToPath(import.meta.url)));
 export const paths = {
+  dataDir: join(root, 'data'),
   launchers: join(root, 'data', 'launchers.json'),
   portHistory: join(root, 'data', 'port-history.json'),
   groupTasks: join(root, 'data', 'group-tasks.json'),

package/server/repositories/settings.js

@@ -20,7 +20,8 @@ export function settingsStatus() {
     isMac: process.platform === 'darwin',
     clipboardEnabled: settings.clipboardEnabled !== false,
     clipboardImageEnabled: settings.clipboardImageEnabled !== false,
-    clipboardDeduplicateMinutes: typeof settings.clipboardDeduplicateMinutes === 'number' && !isNaN(settings.clipboardDeduplicateMinutes) ? settings.clipboardDeduplicateMinutes : 60
+    clipboardDeduplicateMinutes: typeof settings.clipboardDeduplicateMinutes === 'number' && !isNaN(settings.clipboardDeduplicateMinutes) ? settings.clipboardDeduplicateMinutes : 60,
+    dataDir: paths.dataDir
   };
 }
 

package/server/routes/pr-review.js

@@ -23,6 +23,14 @@ function getBitbucketHost() {
 }
 
 function parseBitbucketPrUrl(url) {
+  if (url && (url.toLowerCase().includes('demo') || url.toLowerCase().includes('mock'))) {
+    return {
+      host: 'bitbucket.example.com',
+      projectKey: 'DEMO',
+      repositorySlug: 'demo-repo',
+      pullRequestId: '999'
+    };
+  }
   const match = url.match(/https?:\/\/([^/]+)\/projects\/([^/]+)\/repos\/([^/]+)\/pull-requests\/(\d+)/i);
   if (match) {
     return {
@@ -53,142 +61,184 @@ const isFiltered = (filePath) => {
 
 const analyzeDiff = (filePath, hunks) => {
   const issues = [];
+
   for (const hunk of hunks || []) {
     for (const segment of hunk.segments || []) {
       if (segment.type !== 'ADDED') continue;
-      for (const line of segment.lines || []) {
+      const lines = segment.lines || [];
+      if (lines.length === 0) continue;
+
+      // Build combined segment text & line index mapping to handle multiline formatting/line breaks
+      let segmentText = '';
+      const charToLineMap = [];
+
+      for (const line of lines) {
         const text = line.text || '';
         const lineNum = line.destinationLine;
-        
-        // Rule 1: No debugger
-        if (/\bdebugger\b/.test(text)) {
-          issues.push({
-            severity: 'critical',
-            rule: 'No Debugger',
-            message: 'Avoid leaving `debugger;` statements in production code.',
-            line: lineNum,
-            code: text
-          });
-        }
-        
-        // Rule 2: Conflict Markers
-        if (/^<<<<<<<|^=======|^>>>>>>>/.test(text)) {
-          issues.push({
-            severity: 'critical',
-            rule: 'Conflict Markers',
-            message: 'Unresolved git conflict markers found.',
-            line: lineNum,
-            code: text
-          });
-        }
-        
-        // Rule 3: Focused tests
-        if (/\.(only|skip)\(/.test(text) && /\.(test|spec)\./i.test(filePath)) {
-          issues.push({
-            severity: 'critical',
-            rule: 'Focused/Skipped Test',
-            message: 'Do not commit focused (`.only`) or skipped (`.skip`) tests.',
-            line: lineNum,
-            code: text
-          });
-        }
-        
-        // Rule 4: Secrets
-        if (/(password|passwd|secret|token|api_key|apikey|private_key|auth_token)\s*[:=]\s*['"`][a-zA-Z0-9_\-+=/]{16,}['"`]/i.test(text)) {
-          if (!text.trim().startsWith('//') && !text.includes('placeholder') && !text.includes('dummy')) {
-            issues.push({
-              severity: 'critical',
-              rule: 'Hardcoded Secret',
-              message: 'Potential hardcoded token, password, or key detected.',
-              line: lineNum,
-              code: text
-            });
+        const startIdx = segmentText.length;
+        segmentText += text + '\n';
+        const endIdx = segmentText.length;
+        charToLineMap.push({ startIdx, endIdx, lineNum, text });
+      }
+
+      const getLineInfo = (charIndex) => {
+        for (const item of charToLineMap) {
+          if (charIndex >= item.startIdx && charIndex < item.endIdx) {
+            return { lineNum: item.lineNum, text: item.text };
           }
         }
-        
-        // Rule 5: Console log
-        if (/\bconsole\.log\(/.test(text)) {
+        return { lineNum: lines[0]?.destinationLine || 1, text: lines[0]?.text || '' };
+      };
+
+      const addIssue = (severity, rule, message, charIndex, customCode) => {
+        const { lineNum, text } = getLineInfo(charIndex);
+        if (!issues.some(i => i.rule === rule && i.line === lineNum)) {
           issues.push({
-            severity: 'warning',
-            rule: 'No Console Log',
-            message: 'Consider removing `console.log` statements before merging.',
+            severity,
+            rule,
+            message,
             line: lineNum,
-            code: text
+            code: (customCode || text).trim()
           });
         }
-        
-        // Rule 6: TODO/FIXME
-        if (/\b(TODO|FIXME)\b/i.test(text)) {
-          issues.push({
-            severity: 'info',
-            rule: 'Pending Task',
-            message: 'Track open TODO or FIXME items.',
-            line: lineNum,
-            code: text
-          });
+      };
+
+      // 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)) {
+        const objName = match[1];
+        const propName = match[2];
+        const matchIdx = match.index;
+
+        if (objName === 'row' && propName === 'original') continue;
+        if (objName === 'original' && matchIdx >= 4 && segmentText.slice(matchIdx - 4, matchIdx).includes('row.')) continue;
+
+        const globalNamespaces = [
+          'Math', 'Object', 'Array', 'JSON', 'Promise', 'Reflect', 'Symbol', 'Date',
+          'Number', 'String', 'Boolean', 'React', 'process', 'e', 'evt', 'event',
+          'console', 'window', 'document', 'history', 'location', 'styles', 'style'
+        ];
+        if (globalNamespaces.includes(objName)) continue;
+
+        const lineText = getLineInfo(matchIdx).text.trim();
+        if (/^\s*(import|export|type|interface)\b/.test(lineText)) continue;
+        if (/\b(lodash\.)?get\s*\(/.test(lineText)) continue;
+
+        addIssue('warning', 'Lodash Get Required', 'Object property better use `lodash/get`: `get(obj, ...)`', matchIdx);
+      }
+
+      // Rule 2: TS cannot use 'any' type
+      const anyRegex = /:\s*any\b|:\s*any\[\]|as\s+any\b|<[^>]*?\bany\b[^>]*?>|\bany\[\]/g;
+      for (const match of segmentText.matchAll(anyRegex)) {
+        addIssue('critical', 'No Any Type', 'TypeScript strictly prohibits using the `any` type.', match.index);
+      }
+
+      // Rule 3: No hardcoded text / strings
+      const hardcodedVarRegex = /(const|let|var)\s+[a-zA-Z_$][\w$]*\s*=\s*['"`][^'"`]+['"`]/g;
+      for (const match of segmentText.matchAll(hardcodedVarRegex)) {
+        const lineText = getLineInfo(match.index).text.trim();
+        if (!/^\s*(import|export)\b/.test(lineText) && !/\brequire\s*\(/.test(lineText)) {
+          addIssue('warning', 'No Hardcoded Strings', 'Do not use hardcoded string literals (e.g., `const a = "aa"` or `attr="111"`). Use constants or i18n.', match.index);
         }
-        
-        // Rule 7: IP Addresses
-        const ipMatch = text.match(/\b(192\.168\.\d{1,3}\.\d{1,3}|10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3})\b/);
-        if (ipMatch) {
-          issues.push({
-            severity: 'warning',
-            rule: 'Hardcoded IP Address',
-            message: `Avoid hardcoding internal/private IP addresses (${ipMatch[0]}).`,
-            line: lineNum,
-            code: text
-          });
+      }
+      const hardcodedAttrRegex = /\b(?!className\b|type\b|key\b|name\b|rel\b|target\b|method\b)[a-zA-Z_$][\w$-]*\s*=\s*['"`][^'"`]+['"`]/g;
+      for (const match of segmentText.matchAll(hardcodedAttrRegex)) {
+        const lineText = getLineInfo(match.index).text.trim();
+        if (!/^\s*(import|export)\b/.test(lineText) && !/\brequire\s*\(/.test(lineText)) {
+          addIssue('warning', 'No Hardcoded Strings', 'Do not use hardcoded string literals (e.g., `const a = "aa"` or `attr="111"`). Use constants or i18n.', match.index);
         }
+      }
 
-        // Rule 8: Hardcoded user-facing text (Chinese / Non-ascii characters)
-        if (/[\u4e00-\u9fa5]+/.test(text)) {
-          if (!text.trim().startsWith('//') && !text.trim().startsWith('*')) {
-            issues.push({
-              severity: 'warning',
-              rule: 'Hardcoded Text',
-              message: 'Avoid hardcoding user-facing text strings directly; consider using internationalization (i18n).',
-              line: lineNum,
-              code: text
-            });
-          }
+      // 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 9: Deep object access without optional chaining (a.b.c)
-        const deepAccessRegex = /\b(?!(?:process\.env|e\.target|event\.target|res\.data|response\.data)\b)[a-zA-Z_$][\w$]*\.[a-zA-Z_$][\w$]*\.[a-zA-Z_$][\w$]*\b/;
-        if (deepAccessRegex.test(text)) {
-          issues.push({
-            severity: 'warning',
-            rule: 'Deep Object Access',
-            message: 'Deep object property access (depth > 1) can cause runtime crashes if intermediate properties are nullish. Consider using optional chaining (?.).',
-            line: lineNum,
-            code: text
-          });
+      // Rule 5: 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);
+      }
+
+      // Rule 6: Clickable elements must be button or a (multiline JSX opening tag)
+      const nonClickableTagRegex = /<(div|span|p|li|tr|td|img|i|svg|section|article|header|footer|h[1-6]|label)\b[^>]*?\b(onClick|@click)\b[^>]*?>/gis;
+      for (const match of segmentText.matchAll(nonClickableTagRegex)) {
+        addIssue('warning', 'Clickable Element Tag', 'Clickable elements must use `<button>` or `<a>` tags (or Button/Link components). Do not bind onClick to non-clickable tags like div/span.', match.index, match[0]);
+      }
+
+      // Rule 7: No relative paths (multiline import)
+      const relativeImportRegex = /(import\s*(?:\{[^}]*\}|[^{'"\n]+)\s*from\s*['"]\.\.?\/*['"]|require\s*\(\s*['"]\.\.?\/*['"]\))/gs;
+      for (const match of segmentText.matchAll(relativeImportRegex)) {
+        addIssue('warning', 'No Relative Paths', 'Relative module imports (`./` or `../`) are prohibited. Use absolute paths or path aliases.', match.index, match[0]);
+      }
+
+      // Rule 8: No debugger
+      const debuggerRegex = /\bdebugger\b/g;
+      for (const match of segmentText.matchAll(debuggerRegex)) {
+        addIssue('critical', 'No Debugger', 'Do not leave `debugger;` statements in code.', match.index);
+      }
+
+      // Rule 9: No console.log
+      const consoleRegex = /\bconsole\.log\b/g;
+      for (const match of segmentText.matchAll(consoleRegex)) {
+        addIssue('critical', 'No Console Log', 'Do not leave `console.log` statements in code.', match.index);
+      }
+
+      // Rule 10: No array index key
+      const keyIndexRegex = /\bkey\s*=\s*\{\s*(index|idx|i)\s*\}/g;
+      for (const match of segmentText.matchAll(keyIndexRegex)) {
+        addIssue('warning', 'No Array Index Key', 'Avoid using array index (e.g., `key={index}`) as a React key in list rendering.', match.index);
+      }
+
+      // Rule 11: No nested components
+      const nestedCompRegex = /^\s*(const|function)\s+[A-Z][a-zA-Z0-9_$]*\s*=\s*\(|\bfunction\s+[A-Z][a-zA-Z0-9_$]*\s*\(/gm;
+      for (const match of segmentText.matchAll(nestedCompRegex)) {
+        const lineText = getLineInfo(match.index).text.trim();
+        if (!/^\s*(export|import)\b/.test(lineText)) {
+          addIssue('warning', 'No Nested Components', 'Do not define React components inside another component body. Move component definitions outside.', match.index);
         }
+      }
 
-        // Rule 10: useMemo/useCallback with empty dependency array []
-        if (/\buse(Memo|Callback)\b.*,\s*\[\s*\]/.test(text)) {
-          issues.push({
-            severity: 'warning',
-            rule: 'Static Hook Dependency',
-            message: 'useMemo/useCallback has an empty dependency array []. Consider declaring the function or value outside the component if it has no dynamic scope dependencies.',
-            line: lineNum,
-            code: text
-          });
+      // Rule 12: No async client component
+      const asyncCompRegex = /\b(const|function)\s+[A-Z][a-zA-Z0-9_$]*\s*=\s*async\b|\basync\s+function\s+[A-Z][a-zA-Z0-9_$]*/g;
+      for (const match of segmentText.matchAll(asyncCompRegex)) {
+        addIssue('critical', 'No Async Component', 'React client components must not be async functions.', match.index);
+      }
+
+      // Rule 13: No non-null assertions (!.)
+      const nonNullRegex = /[a-zA-Z0-9_$]!\s*(\.|\[)/g;
+      for (const match of segmentText.matchAll(nonNullRegex)) {
+        addIssue('warning', 'No Non-null Assertion', 'Avoid using TypeScript non-null assertions (`!.`). Use optional chaining (`?.`) or defensive null checks instead.', match.index);
+      }
+
+      // Rule 14: No direct state mutation
+      const stateMutationRegex = /\b(state|list|items|data)\.(push|pop|shift|unshift|splice|sort|reverse)\s*\(|\bstate\.[a-zA-Z0-9_$]+\s*=\s*/g;
+      for (const match of segmentText.matchAll(stateMutationRegex)) {
+        addIssue('warning', 'No Direct State Mutation', 'Do not mutate React state directly. Use immutable data patterns.', match.index);
+      }
+
+      // Rule 15: Unhandled async event
+      const unhandledAsyncRegex = /\bon[A-Z][a-zA-Z0-9_$]*\s*=\s*\{\s*async\b[\s\S]*?\}/g;
+      for (const match of segmentText.matchAll(unhandledAsyncRegex)) {
+        if (!match[0].includes('try')) {
+          addIssue('warning', 'Unhandled Async Event', 'Async event handlers must wrap asynchronous calls in a try...catch block to handle errors.', match.index, match[0]);
         }
+      }
 
-        // Rule 11: variant="primary" (often a Bootstrap/MUI style leak instead of Button type="primary")
-        if (/\bvariant\s*=\s*['"`]primary['"`]/i.test(text)) {
-          issues.push({
-            severity: 'warning',
-            rule: 'Incorrect Button Variant',
-            message: '`variant="primary"` is the default variant.',
-            line: lineNum,
-            code: text
-          });
+      // Rule 16: No magic numbers
+      const magicNumberRegex = /(===|==|!==|!=)\s*([2-9]|\d{2,})\b|\bsetTimeout\s*\([^,]+,\s*([2-9]|\d{2,})\)/g;
+      for (const match of segmentText.matchAll(magicNumberRegex)) {
+        if (!/\b(200|201|204|400|401|403|404|500)\b/.test(match[0])) {
+          addIssue('info', 'No Magic Numbers', 'Avoid magic numbers in business logic. Define named constants or enums instead.', match.index);
         }
       }
     }
   }
+
   return issues;
 };
 
@@ -201,6 +251,113 @@ router.post('/check', async (req, res) => {
 
   const { host, projectKey, repositorySlug, pullRequestId } = parsed;
   lastUsedHost = host;
+
+  if (projectKey === 'DEMO' && repositorySlug === 'demo-repo') {
+    const demoHunksMap = {
+      'src/components/UserProfile.tsx': [
+        {
+          segments: [
+            {
+              type: 'ADDED',
+              lines: [
+                { destinationLine: 14, text: 'const userName = user.profile.name;' },
+                { destinationLine: 22, text: 'const handleData = (payload: any): void => {' },
+                { destinationLine: 30, text: 'const title = "User Profile Settings";' },
+                { destinationLine: 38, text: 'const SubCard = () => <div>Sub Card</div>;' },
+                { destinationLine: 45, text: 'const UserCard = async () => {' },
+                { destinationLine: 52, text: 'const userId = response!.data!.id;' }
+              ]
+            }
+          ]
+        }
+      ],
+      'src/hooks/useUserStats.ts': [
+        {
+          segments: [
+            {
+              type: 'ADDED',
+              lines: [
+                { destinationLine: 3, text: 'import { formatUser } from "../utils/format";' },
+                { destinationLine: 18, text: 'const memoizedValue = useMemo(() => calculateStats(data), []);' },
+                { destinationLine: 26, text: 'state.list.push(newItem);' }
+              ]
+            }
+          ]
+        }
+      ],
+      'src/pages/Dashboard.tsx': [
+        {
+          segments: [
+            {
+              type: 'ADDED',
+              lines: [
+                { destinationLine: 45, text: '<div style={{ padding: "20px", backgroundColor: "#fff" }}>' },
+                { destinationLine: 52, text: '<div className="btn-wrapper" onClick={handleSave}>Save User</div>' },
+                { destinationLine: 60, text: '{items.map((item, index) => <Item key={index} data={item} />)}' },
+                { destinationLine: 68, text: '<button onClick={async () => fetchMore()}>Load More</button>' },
+                { destinationLine: 75, text: 'if (userStatus === 5) {' }
+              ]
+            }
+          ]
+        }
+      ],
+      'src/services/api.ts': [
+        {
+          segments: [
+            {
+              type: 'ADDED',
+              lines: [
+                { destinationLine: 88, text: 'debugger;' },
+                { destinationLine: 95, text: 'console.log("Fetch user response:", response.data);' }
+              ]
+            }
+          ]
+        }
+      ]
+    };
+
+    const reviewFiles = [];
+    let totalIssues = 0;
+    let criticalCount = 0;
+    let warningCount = 0;
+    let infoCount = 0;
+
+    for (const [filePath, hunks] of Object.entries(demoHunksMap)) {
+      const fileIssues = analyzeDiff(filePath, hunks);
+      if (fileIssues.length > 0) {
+        reviewFiles.push({ filePath, type: 'MODIFY', issues: fileIssues });
+        totalIssues += fileIssues.length;
+        criticalCount += fileIssues.filter(i => i.severity === 'critical').length;
+        warningCount += fileIssues.filter(i => i.severity === 'warning').length;
+        infoCount += fileIssues.filter(i => i.severity === 'info').length;
+      }
+    }
+
+    return res.json({
+      pr: {
+        title: 'Demo: Feature User Management & Code Standard Check',
+        description: 'Demo Pull Request showcasing all 9 PR Review Rules.',
+        author: 'Developer Alex',
+        sourceBranch: 'feature/user-management',
+        targetBranch: 'main',
+        projectKey: 'DEMO',
+        repositorySlug: 'demo-repo',
+        pullRequestId: '999'
+      },
+      stats: {
+        totalFilesChanged: 5,
+        filteredCount: 1,
+        reviewedCount: 4,
+        totalIssues,
+        criticalCount,
+        warningCount,
+        infoCount
+      },
+      filteredOut: ['package-lock.json'],
+      files: reviewFiles
+    });
+  }
+
   const settings = readSettings();
   const token = settings.bitbucketAccessToken;
 

package/server/routes/settings.js

@@ -1,6 +1,8 @@
+import { existsSync, mkdirSync } from 'node:fs';
 import { Router } from 'express';
+import { paths } from '../config.js';
 import { saveAccessToken, saveClipboardDeduplicateMinutes, saveClipboardEnabled, saveClipboardImageEnabled, saveDefaultBrowser, saveDefaultEditor, saveDomain, saveJiraIssuePrefix, settingsStatus } from '../repositories/settings.js';
-import { openInSystemBrowser, openInSystemEditor } from '../services/browser.js';
+import { openInSystemBrowser, openInSystemEditor, openInSystemFolder } from '../services/browser.js';
 import { selectDirectory } from '../services/dialog.js';
 
 const router = Router();
@@ -38,6 +40,23 @@ router.post('/open-editor', (req, res) => {
   openInSystemEditor(path.trim(), location ? String(location).trim() : '');
   res.json({ success: true });
 });
+router.post('/open-folder', (req, res) => {
+  const { path } = req.body || {};
+  const targetPath = (typeof path === 'string' && path.trim()) ? path.trim() : paths.dataDir;
+  if (!existsSync(targetPath)) {
+    mkdirSync(targetPath, { recursive: true });
+  }
+  openInSystemFolder(targetPath);
+  res.json({ success: true });
+});
+router.post('/open-data-dir', (req, res) => {
+  const targetPath = paths.dataDir;
+  if (!existsSync(targetPath)) {
+    mkdirSync(targetPath, { recursive: true });
+  }
+  openInSystemFolder(targetPath);
+  res.json({ success: true });
+});
 router.post('/select-directory', async (_req, res) => {
   try {
     const result = await selectDirectory();

package/server/services/browser.js

@@ -96,3 +96,15 @@ export function openInSystemEditor(path, location = '') {
     }
   }
 }
+
+export function openInSystemFolder(targetPath) {
+  if (!targetPath || typeof targetPath !== 'string') return;
+  if (process.platform === 'darwin') {
+    execFile('open', [targetPath]);
+  } else if (process.platform === 'win32') {
+    execFile('cmd', ['/c', 'start', '', targetPath]);
+  } else {
+    execFile('xdg-open', [targetPath]);
+  }
+}
+