buddy-workbench 0.1.0

package/server/routes/pr-review.js

@@ -0,0 +1,378 @@
+import { Router } from 'express';
+import { readSettings } from '../repositories/settings.js';
+
+const router = Router();
+const previewLimit = 2000;
+let lastUsedHost = '';
+
+function getBitbucketHost() {
+  if (lastUsedHost) return lastUsedHost;
+  const settings = readSettings();
+  const domain = settings.domain || '';
+  if (!domain) return '';
+  if (domain.includes('bitbucket')) return domain;
+  return `bitbucket.${domain}`;
+}
+
+function parseBitbucketPrUrl(url) {
+  const match = url.match(/https?:\/\/([^/]+)\/projects\/([^/]+)\/repos\/([^/]+)\/pull-requests\/(\d+)/i);
+  if (match) {
+    return {
+      host: match[1],
+      projectKey: match[2],
+      repositorySlug: match[3],
+      pullRequestId: match[4]
+    };
+  }
+  const userMatch = url.match(/https?:\/\/([^/]+)\/users\/([^/]+)\/repos\/([^/]+)\/pull-requests\/(\d+)/i);
+  if (userMatch) {
+    return {
+      host: userMatch[1],
+      projectKey: `~${userMatch[2]}`,
+      repositorySlug: userMatch[3],
+      pullRequestId: userMatch[4]
+    };
+  }
+  return null;
+}
+
+const isFiltered = (filePath) => {
+  const name = filePath.split('/').pop();
+  if (name === 'bd.json' || name === 'package-lock.json') return true;
+  if (/\.spec\.[^.]+$/.test(name) || /\.test\.[^.]+$/.test(name)) return true;
+  return false;
+};
+
+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 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
+            });
+          }
+        }
+        
+        // Rule 5: Console log
+        if (/\bconsole\.log\(/.test(text)) {
+          issues.push({
+            severity: 'warning',
+            rule: 'No Console Log',
+            message: 'Consider removing `console.log` statements before merging.',
+            line: lineNum,
+            code: text
+          });
+        }
+        
+        // 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 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
+          });
+        }
+
+        // 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 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 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 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
+          });
+        }
+      }
+    }
+  }
+  return issues;
+};
+
+router.post('/check', async (req, res) => {
+  const { prLink } = req.body || {};
+  if (!prLink) return res.status(400).json({ error: 'PR Link is required.' });
+
+  const parsed = parseBitbucketPrUrl(prLink);
+  if (!parsed) return res.status(400).json({ error: 'Invalid Bitbucket Pull Request URL.' });
+
+  const { host, projectKey, repositorySlug, pullRequestId } = parsed;
+  lastUsedHost = host;
+  const settings = readSettings();
+  const token = settings.bitbucketAccessToken;
+
+  const headers = { 'Accept': 'application/json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  try {
+    // 1. Fetch Pull Request details to show basic info
+    const prUrl = `https://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${pullRequestId}`;
+    const prRes = await fetch(prUrl, { headers });
+    if (!prRes.ok) {
+      if (prRes.status === 401) {
+        return res.status(401).json({ error: 'Unauthorized. Please check your Bitbucket Access Token in Settings.' });
+      }
+      return res.status(prRes.status).json({ error: `Failed to fetch PR info: ${prRes.statusText}` });
+    }
+    const prInfo = await prRes.json();
+
+    // 2. Fetch changes
+    const changesUrl = `https://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${pullRequestId}/changes?limit=1000`;
+    const changesRes = await fetch(changesUrl, { headers });
+    if (!changesRes.ok) {
+      return res.status(changesRes.status).json({ error: `Failed to fetch PR changes: ${changesRes.statusText}` });
+    }
+    const changesData = await changesRes.json();
+
+    const allChanges = changesData.values || [];
+    const filteredOut = [];
+    const targetChanges = [];
+
+    for (const change of allChanges) {
+      const filePath = change.path.toString;
+      if (isFiltered(filePath)) {
+        filteredOut.push(filePath);
+      } else {
+        targetChanges.push(change);
+      }
+    }
+
+    // 3. Fetch diffs and run rule-based checks
+    const reviewFiles = [];
+    let totalIssues = 0;
+    let criticalCount = 0;
+    let warningCount = 0;
+    let infoCount = 0;
+
+    for (const change of targetChanges) {
+      const filePath = change.path.toString;
+      const diffUrl = `https://${host}/rest/api/1.0/projects/${projectKey}/repos/${repositorySlug}/pull-requests/${pullRequestId}/diff/${encodeURIComponent(filePath)}?context=0`;
+      const diffRes = await fetch(diffUrl, { headers });
+      if (!diffRes.ok) continue; // skip file if diff cannot be retrieved
+
+      const diffData = await diffRes.json();
+      const fileIssues = analyzeDiff(filePath, diffData.hunks);
+
+      if (fileIssues.length > 0) {
+        reviewFiles.push({
+          filePath,
+          type: change.type,
+          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;
+      }
+    }
+
+    res.json({
+      pr: {
+        title: prInfo.title,
+        description: prInfo.description,
+        author: prInfo.author?.user?.displayName || 'Unknown',
+        sourceBranch: prInfo.fromRef?.displayId || 'Unknown',
+        targetBranch: prInfo.toRef?.displayId || 'Unknown',
+        projectKey,
+        repositorySlug,
+        pullRequestId
+      },
+      stats: {
+        totalFilesChanged: allChanges.length,
+        filteredCount: filteredOut.length,
+        reviewedCount: targetChanges.length,
+        totalIssues,
+        criticalCount,
+        warningCount,
+        infoCount
+      },
+      filteredOut,
+      files: reviewFiles
+    });
+
+  } catch (error) {
+    res.status(500).json({ error: `Internal error: ${error.message}` });
+  }
+});
+
+function enrichPrList(values, host) {
+  return values.map(pr => {
+    let href = '';
+    if (Array.isArray(pr.links?.self)) {
+      href = pr.links.self[0]?.href || '';
+    } else if (pr.links?.self?.href) {
+      href = pr.links.self.href;
+    }
+    if (!href && pr.toRef?.repository?.project?.key && pr.toRef?.repository?.slug && pr.id) {
+      const proj = pr.toRef.repository.project.key;
+      const repo = pr.toRef.repository.slug;
+      const isPersonal = proj.startsWith('~');
+      const projectPath = isPersonal ? `users/${proj.slice(1)}` : `projects/${proj}`;
+      href = `https://${host}/${projectPath}/repos/${repo}/pull-requests/${pr.id}`;
+    }
+    return {
+      ...pr,
+      reviewUrl: href
+    };
+  });
+}
+
+router.get('/my-prs', async (req, res) => {
+  const host = getBitbucketHost();
+  if (!host) return res.json({ values: [] });
+
+  const settings = readSettings();
+  const token = settings.bitbucketAccessToken;
+  const headers = { 'Accept': 'application/json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  try {
+    const url = `https://${host}/rest/api/1.0/dashboard/pull-requests?role=author&state=OPEN&limit=100`;
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      if (response.status === 401) {
+        return res.status(401).json({ error: 'Unauthorized. Please check your Bitbucket Token.' });
+      }
+      return res.status(response.status).json({ error: `Bitbucket API error: ${response.statusText}` });
+    }
+    const data = await response.json();
+    const values = data.values || [];
+
+    const sorted = values.sort((a, b) => {
+      const aDraft = a.draft === true;
+      const bDraft = b.draft === true;
+      if (aDraft !== bDraft) return aDraft ? 1 : -1;
+      return (b.updatedDate || 0) - (a.updatedDate || 0);
+    });
+
+    res.json({ values: enrichPrList(sorted, host) });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.get('/review-prs', async (req, res) => {
+  const host = getBitbucketHost();
+  if (!host) return res.json({ values: [] });
+
+  const settings = readSettings();
+  const token = settings.bitbucketAccessToken;
+  const headers = { 'Accept': 'application/json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  try {
+    const url = `https://${host}/rest/api/1.0/dashboard/pull-requests?role=reviewer&state=OPEN&limit=100`;
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      if (response.status === 401) {
+        return res.status(401).json({ error: 'Unauthorized. Please check your Bitbucket Token.' });
+      }
+      return res.status(response.status).json({ error: `Bitbucket API error: ${response.statusText}` });
+    }
+    const data = await response.json();
+    const values = data.values || [];
+
+    const sorted = values.sort((a, b) => (b.updatedDate || 0) - (a.updatedDate || 0));
+
+    res.json({ values: enrichPrList(sorted, host) });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+export default router;

package/server/routes/settings.js

@@ -0,0 +1,18 @@
+import { Router } from 'express';
+import { saveAccessToken, saveDomain, settingsStatus } from '../repositories/settings.js';
+
+const router = Router();
+
+router.get('/', (_req, res) => res.json(settingsStatus()));
+router.put('/domain', (req, res) => {
+  const { domain } = req.body || {};
+  if (typeof domain !== 'string') return res.status(400).json({ error: 'Domain must be a string.' });
+  res.json(saveDomain(domain.trim()));
+});
+router.put('/:service-access-token', (req, res) => {
+  const { token } = req.body || {};
+  if (typeof token !== 'string') return res.status(400).json({ error: 'Token must be a string.' });
+  try { res.json(saveAccessToken(req.params.service, token.trim())); } catch (error) { res.status(400).json({ error: error.message }); }
+});
+
+export default router;

package/server/services/clipboard-history.js

@@ -0,0 +1,85 @@
+import { execFile } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+import { paths } from '../config.js';
+
+const execFileAsync = promisify(execFile);
+const previewLimit = 2000;
+let lastValue = '';
+
+function today() { return new Intl.DateTimeFormat('en-CA').format(new Date()); }
+function dayFile(date) { const [year, month, day] = date.split('-'); return join(paths.clipboardDir, year, month, `${day}.json`); }
+function readJson(file, fallback) { try { return existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : fallback; } catch { return fallback; } }
+function writeJson(file, data) { mkdirSync(dirname(file), { recursive: true }); writeFileSync(file, JSON.stringify(data, null, 2)); }
+
+export function clipboardDates() {
+  if (!existsSync(paths.clipboardDir)) return [];
+  return readdirSync(paths.clipboardDir, { withFileTypes: true }).filter((year) => year.isDirectory() && /^\d{4}$/.test(year.name)).flatMap((year) => readdirSync(join(paths.clipboardDir, year.name), { withFileTypes: true }).filter((month) => month.isDirectory() && /^\d{2}$/.test(month.name)).flatMap((month) => readdirSync(join(paths.clipboardDir, year.name, month.name), { withFileTypes: true }).filter((day) => day.isFile() && /^\d{2}\.json$/.test(day.name)).map((day) => `${year.name}-${month.name}-${day.name.slice(0, 2)}`))).sort().reverse();
+}
+
+function dayItems(date) { return readJson(dayFile(date), []); }
+export function clipboardItems(date = today()) { return dayItems(date).map((item) => item.contentFile ? { ...item, editorUrl: `vscode://file${encodeURI(join(paths.clipboardDir, 'content', item.contentFile))}` } : item); }
+export function clipboardOriginal(date, id) { const item = dayItems(date).find((entry) => entry.id === id); if (!item?.contentFile) return item?.text || null; try { return readFileSync(join(paths.clipboardDir, 'content', item.contentFile), 'utf8'); } catch { return null; } }
+export function deleteClipboardItem(date, id) {
+  const items = dayItems(date); const item = items.find((entry) => entry.id === id);
+  if (!item) return false;
+  writeJson(dayFile(date), items.filter((entry) => entry.id !== id));
+  if (item.contentFile) {
+    const contentPath = join(paths.clipboardDir, 'content', item.contentFile);
+    if (existsSync(contentPath)) unlinkSync(contentPath);
+  }
+  return true;
+}
+
+export async function captureClipboard() {
+  if (process.platform !== 'darwin') return;
+  try {
+    const { stdout } = await execFileAsync('pbpaste'); const text = stdout.trim();
+    if (!text || text === lastValue) return;
+    lastValue = text;
+    
+    const now = Date.now();
+    const limit = now - 60 * 60 * 1000;
+    const date = today();
+    const items = dayItems(date);
+    
+    let recentItems = [...items];
+    const yesterdayDate = new Intl.DateTimeFormat('en-CA').format(new Date(now - 24 * 60 * 60 * 1000));
+    if (date !== yesterdayDate) {
+      recentItems = [...recentItems, ...dayItems(yesterdayDate)];
+    }
+    
+    const oneHourItems = recentItems.filter(item => {
+      const itemTime = new Date(item.createdAt).getTime();
+      return itemTime >= limit;
+    });
+    
+    const alreadyExists = oneHourItems.some(item => {
+      if (item.text !== undefined) {
+        return item.text === text;
+      }
+      if (item.contentFile) {
+        const prefix = item.preview.slice(0, -1);
+        if (text.startsWith(prefix)) {
+          try {
+            const fullText = readFileSync(join(paths.clipboardDir, 'content', item.contentFile), 'utf8');
+            return fullText === text;
+          } catch {
+            return false;
+          }
+        }
+      }
+      return false;
+    });
+    
+    if (alreadyExists) return;
+    
+    const id = crypto.randomUUID(); const isLong = text.length > previewLimit;
+    if (isLong) { mkdirSync(join(paths.clipboardDir, 'content'), { recursive: true }); writeFileSync(join(paths.clipboardDir, 'content', `${id}.txt`), text, 'utf8'); }
+    const item = isLong ? { id, preview: `${text.slice(0, previewLimit)}…`, contentFile: `${id}.txt`, createdAt: new Date().toISOString() } : { id, text, createdAt: new Date().toISOString() };
+    writeJson(dayFile(date), [item, ...items].slice(0, 200));
+  } catch {}
+}
+
+export function startClipboardCapture() { captureClipboard(); const timer = setInterval(captureClipboard, 1000); timer.unref(); }

package/server/services/git.js

@@ -0,0 +1,14 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export async function currentGitBranch(folder) {
+  if (!folder) return null;
+  try {
+    const { stdout } = await execFileAsync('git', ['branch', '--show-current'], { cwd: folder, timeout: 1500 });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}

package/server/services/package-scripts.js

@@ -0,0 +1,11 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function readPackageScripts(folder) {
+  const packageFile = join(folder, 'package.json');
+  if (!existsSync(packageFile)) return [];
+  try {
+    const { scripts = {} } = JSON.parse(readFileSync(packageFile, 'utf8'));
+    return Object.entries(scripts).map(([name, command]) => ({ id: `package:${name}`, name, command: String(command) }));
+  } catch { return []; }
+}

package/server/services/plugins.js

@@ -0,0 +1,15 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { paths } from '../config.js';
+
+export function listPlugins() {
+  if (!existsSync(paths.plugins)) return [];
+  return readdirSync(paths.plugins, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+    const manifest = join(paths.plugins, entry.name, 'plugin.json');
+    if (!existsSync(manifest)) return [];
+    try {
+      const plugin = JSON.parse(readFileSync(manifest, 'utf8'));
+      return [{ id: entry.name, name: plugin.name || entry.name, icon: plugin.icon || '▦', view: plugin.view ? `/plugins/${encodeURIComponent(entry.name)}/${plugin.view}` : '' }];
+    } catch { return []; }
+  });
+}