buddy-workbench 0.1.74 → 0.1.76

package/server/routes/pr-review.js

@@ -1,12 +1,14 @@
 import https from 'node:https';
+import { randomUUID } from 'node:crypto';
 import axios from 'axios';
 import { Router } from 'express';
-import { readSettings, readPrReviewCustomRules, readPrReviewRules, savePrReviewRules } from '../repositories/settings.js';
+import { readSettings, readPrReviewCustomRules, readPrReviewFileFilters, readPrReviewRules, savePrReviewRules } from '../repositories/settings.js';
 import { recordApiError } from '../lib/api-errors.js';
 
 const router = Router();
 const previewLimit = 2000;
 let lastUsedHost = '';
+const aiReviewJobs = new Map();
 
 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' },
@@ -26,10 +28,10 @@ const PR_REVIEW_RULES = [
   { 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.get('/rules', (_req, res) => res.json({ rules: readPrReviewRules(PR_REVIEW_RULES), customRules: readPrReviewCustomRules(), fileFilters: readPrReviewFileFilters() }));
 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));
+  res.json(savePrReviewRules(req.body.rules, req.body.customRules, req.body.fileFilters, PR_REVIEW_RULES));
 });
 
 function getRuleSettings() {
@@ -53,6 +55,123 @@ const httpClient = axios.create({
   validateStatus: () => true
 });
 
+const getChangePath = (change) => {
+  if (typeof change?.path === 'string') return change.path;
+  return change?.path?.toString || '';
+};
+
+async function fetchFullFileContent({ host, projectKey, repositorySlug, filePath, commit, headers }) {
+  if (!commit || !filePath) return null;
+  const url = `https://${host}/rest/api/latest/projects/${projectKey}/repos/${repositorySlug}/raw/${filePath}?at=${encodeURIComponent(commit)}`;
+  const response = await httpClient.get(url, { headers, responseType: 'text' });
+  if (response.status < 200 || response.status >= 300) {
+    recordApiError({
+      source: 'Bitbucket API (PR Review file content)',
+      method: 'GET',
+      url,
+      status: response.status,
+      message: `Bitbucket raw file API returned ${response.status}: ${response.statusText || 'Failed to retrieve file content'}`
+    });
+    return null;
+  }
+  return String(response.data ?? '');
+}
+
+function aiCompletionUrl(host) {
+  const normalizedHost = String(host || '').replace(/\/+$/, '');
+  return /\/chat\/completions$/i.test(normalizedHost) ? normalizedHost : `${normalizedHost}/chat/completions`;
+}
+
+function getAiMessageContent(data) {
+  const content = data?.choices?.[0]?.message?.content;
+  if (Array.isArray(content)) return content.map((part) => part?.text || '').join('');
+  return typeof content === 'string' ? content : '';
+}
+
+function parseAiReview(content) {
+  const candidate = String(content || '').replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim();
+  try {
+    const parsed = JSON.parse(candidate);
+    return {
+      summary: typeof parsed.summary === 'string' ? parsed.summary : '',
+      findings: Array.isArray(parsed.findings) ? parsed.findings
+        .filter((finding) => finding && typeof finding.file === 'string' && finding.file.trim())
+        .map((finding) => ({
+          file: finding.file.trim(),
+          line: finding.line == null || finding.line === '' || !Number.isFinite(Number(finding.line)) ? null : Number(finding.line),
+          severity: ['critical', 'warning', 'info'].includes(finding.severity) ? finding.severity : 'warning',
+          title: typeof finding.title === 'string' && finding.title.trim() ? finding.title.trim() : 'AI finding',
+          explanation: typeof finding.explanation === 'string' ? finding.explanation.trim() : '',
+          recommendation: typeof finding.recommendation === 'string' ? finding.recommendation.trim() : ''
+        })) : []
+    };
+  } catch {
+    return { summary: content, findings: [] };
+  }
+}
+
+async function runAiReview({ aiApiHost, pr, files }) {
+  if (!aiApiHost) return { configured: false, status: 'skipped' };
+  if (!files.length) return { configured: true, status: 'completed', reviewedFiles: 0, content: 'No eligible files were available for AI review.' };
+
+  const prompt = [
+    'Review the complete contents of the changed files in this pull request.',
+    'Focus on correctness, security, reliability, maintainability, and regressions introduced by the change.',
+    'Report only actionable findings. For each finding include severity (critical, warning, or info), file, line if identifiable, title, explanation, and a concrete recommendation.',
+    'If there are no actionable findings, use an empty findings array and say LGTM in the summary.',
+    'Return only valid JSON in this exact shape: {"summary":"...","findings":[{"severity":"warning","file":"path/to/file","line":12,"title":"...","explanation":"...","recommendation":"..."}]}',
+    'Do not invent files, code, or line numbers. Use null for line when a precise line cannot be identified.',
+    '',
+    `Pull request: ${pr.title || ''}`,
+    `Description: ${pr.description || ''}`,
+    `Branches: ${pr.sourceBranch || ''} -> ${pr.targetBranch || ''}`,
+    '',
+    'Changed files (complete current file contents):',
+    ...files.map((file) => [
+      `--- FILE: ${file.filePath} (${file.type || 'MODIFY'}) ---`,
+      file.content,
+      `--- END FILE: ${file.filePath} ---`
+    ].join('\n'))
+  ].join('\n');
+
+  try {
+    const response = await httpClient.post(aiCompletionUrl(aiApiHost), {
+      model: 'gpt-5.5',
+      messages: [
+        { role: 'system', content: 'You are a careful senior code reviewer. Be precise and evidence-based.' },
+        { role: 'user', content: prompt }
+      ]
+    }, {
+      headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+      timeout: 120000
+    });
+
+    if (response.status < 200 || response.status >= 300) {
+      const detail = response.data?.error?.message || response.statusText || `HTTP ${response.status}`;
+      recordApiError({ source: 'AI API (PR Review)', method: 'POST', url: aiCompletionUrl(aiApiHost), status: response.status, message: detail });
+      return { configured: true, status: 'error', reviewedFiles: files.length, error: `AI review failed: ${detail}` };
+    }
+
+    const content = getAiMessageContent(response.data);
+    if (!content.trim()) return { configured: true, status: 'error', reviewedFiles: files.length, error: 'AI review returned an empty response.' };
+    const parsed = parseAiReview(content);
+    return { configured: true, status: 'completed', reviewedFiles: files.length, content, ...parsed };
+  } catch (error) {
+    recordApiError({ source: 'AI API (PR Review)', method: 'POST', url: aiCompletionUrl(aiApiHost), message: error.message });
+    return { configured: true, status: 'error', reviewedFiles: files.length, error: `AI review failed: ${error.message}` };
+  }
+}
+
+function startAiReviewJob({ files, runner }) {
+  const jobId = randomUUID();
+  aiReviewJobs.set(jobId, { configured: true, status: 'loading', jobId, reviewedFiles: files.length });
+  Promise.resolve()
+    .then(runner)
+    .then((result) => aiReviewJobs.set(jobId, { ...result, jobId }))
+    .catch((error) => aiReviewJobs.set(jobId, { configured: true, status: 'error', jobId, reviewedFiles: files.length, error: `AI review failed: ${error.message}` }));
+  return { configured: true, status: 'loading', jobId, reviewedFiles: files.length };
+}
+
 function getBitbucketHost() {
   if (lastUsedHost) return lastUsedHost;
   const settings = readSettings();
@@ -92,11 +211,280 @@ function parseBitbucketPrUrl(url) {
   return null;
 }
 
-const isFiltered = (filePath) => {
+const globToRegExp = (pattern) => {
+  let source = '';
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === '*' && pattern[index + 1] === '*') {
+      if (pattern[index + 2] === '/') {
+        index += 2;
+        source += '(?:.*\\/)?';
+      } else {
+        index += 1;
+        source += '.*';
+      }
+    } else if (char === '*') {
+      source += '[^/]*';
+    } else if (char === '?') {
+      source += '[^/]';
+    } else {
+      source += char.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+    }
+  }
+  return new RegExp(`^${source}$`, 'i');
+};
+
+const matchesFileFilter = (filePath, pattern) => {
+  let normalizedPattern = String(pattern || '').trim().replaceAll('\\', '/');
+  if (!normalizedPattern || normalizedPattern.startsWith('#')) return false;
+  if (normalizedPattern.startsWith('!')) return false;
+  normalizedPattern = normalizedPattern.replace(/^\/+/, '');
+  const directoryPattern = normalizedPattern.endsWith('/');
+  normalizedPattern = normalizedPattern.replace(/\/+$/, '');
+  if (!normalizedPattern) return false;
+  if (directoryPattern) normalizedPattern += '/**';
+
+  const hasSlash = normalizedPattern.includes('/');
+  const expression = globToRegExp(normalizedPattern);
+  if (hasSlash) return expression.test(filePath);
+  return expression.test(filePath) || expression.test(filePath.split('/').pop());
+};
+
+const isFiltered = (filePath, fileFilters = []) => {
   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;
+  return fileFilters.some((pattern) => matchesFileFilter(filePath, pattern));
+};
+
+const getDiffLineMetadata = (hunks) => (hunks || []).flatMap((hunk) => (hunk.segments || []).flatMap((segment) => (segment.lines || []).map((line) => ({
+  type: segment.type,
+  oldLine: line.source ?? line.sourceLine ?? null,
+  newLine: line.destination ?? line.destinationLine ?? null
+}))));
+
+const demoCodeTemplates = {
+  'src/components/UserProfile.tsx': `import React, { useCallback, useMemo, useState } from 'react';
+import { Card, Spinner, Text, Button } from '@acme/ui';
+import { getUser, updateUser } from '../api/users';
+import type { User, UserStats } from '../types';
+
+type UserProfileProps = {
+  userId: string;
+  onSaved?: (user: User) => void;
+};
+
+const emptyStats: UserStats = { posts: 0, followers: 0, following: 0 };
+
+export function UserProfile({ userId, onSaved }: UserProfileProps) {
+  const [user, setUser] = useState<User | null>(null);
+  const [stats, setStats] = useState<UserStats>(emptyStats);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [isSaving, setIsSaving] = useState(false);
+
+  const userName = user.profile.name;
+  const displayName = useMemo(() => user?.profile?.name || 'Unknown user', [user]);
+  const canEdit = user?.permissions.includes('edit') === true;
+
+  const handleData = (payload: any): void => {
+    if (payload?.stats) setStats(payload.stats);
+  };
+
+  const title = "User Profile Settings";
+  const saveProfile = useCallback(async () => {
+    if (!user) return;
+    setIsSaving(true);
+    try {
+      const savedUser = await updateUser(user.id, user);
+      setUser(savedUser);
+      onSaved?.(savedUser);
+    } finally {
+      setIsSaving(false);
+    }
+  }, [onSaved, user]);
+
+  const loadProfile = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await getUser(userId);
+      setUser(response.user);
+      handleData(response);
+    } catch (requestError) {
+      setError(requestError instanceof Error ? requestError.message : 'Unable to load user');
+    } finally {
+      setLoading(false);
+    }
+  }, [userId]);
+
+  React.useEffect(() => { void loadProfile(); }, [loadProfile]);
+
+  if (loading) return <Spinner label="Loading profile" />;
+  if (error) return <Text role="alert">{error}</Text>;
+  if (!user) return <Text>No profile found.</Text>;
+
+  const UserCard = () => <Card title={displayName}><Text>{user.email}</Text></Card>;
+  const userId = response!.data!.id;
+
+  return (
+    <Card title={title}>
+      <UserCard />
+      <Text>{stats.posts} posts · {stats.followers} followers</Text>
+      {canEdit && <Button loading={isSaving} onClick={saveProfile}>Save</Button>}
+    </Card>
+  );
+}
+`,
+  'src/hooks/useUserStats.ts': `import { useCallback, useEffect, useState } from 'react';
+import { getUserStats } from '../api/users';
+import type { UserStats } from '../types';
+
+type UseUserStatsResult = {
+  data: UserStats | null;
+  loading: boolean;
+  error: string | null;
+  refresh: () => Promise<void>;
+};
+
+const initialStats: UserStats = { posts: 0, followers: 0, following: 0 };
+
+export function useUserStats(userId: string): UseUserStatsResult {
+  const [data, setData] = useState<UserStats | null>(initialStats);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const nextStats = await getUserStats(userId);
+      setData(nextStats);
+    } catch (requestError) {
+      setError(requestError instanceof Error ? requestError.message : 'Unable to load stats');
+    } finally {
+      setLoading(false);
+    }
+  }, [userId]);
+
+  useEffect(() => { void refresh(); }, [refresh]);
+
+  const memoizedValue = useMemo(() => calculateStats(data), []);
+  const addRecentItem = (newItem: string) => {
+    state.list.push(newItem);
+    setData((current) => current ? { ...current, recent: [...(current.recent || []), newItem] } : current);
+  };
+
+  return { data, loading, error, refresh };
+}
+`,
+  'src/pages/Dashboard.tsx': `import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { Button, Card, EmptyState, Page, Section, Spinner } from '@acme/ui';
+import { fetchDashboard, saveDashboardPreferences } from '../api/dashboard';
+import { UserCard } from '../components/UserCard';
+import { ActivityList } from '../components/ActivityList';
+import type { DashboardData } from '../types';
+
+export default function Dashboard() {
+  const [data, setData] = useState<DashboardData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const loadDashboard = useCallback(async () => {
+    setLoading(true);
+    try {
+      setData(await fetchDashboard());
+    } catch (requestError) {
+      setError(requestError instanceof Error ? requestError.message : 'Unable to load dashboard');
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { void loadDashboard(); }, [loadDashboard]);
+  const visibleItems = useMemo(() => data?.items || [], [data]);
+  const handleSave = async () => {
+    setSaving(true);
+    await saveDashboardPreferences({ compact: true });
+    setSaving(false);
+  };
+
+  if (loading) return <Page><Spinner label="Loading dashboard" /></Page>;
+  if (error) return <Page><EmptyState title={error} action={<Button onClick={loadDashboard}>Retry</Button>} /></Page>;
+  if (!data) return <Page><EmptyState title="No dashboard data" /></Page>;
+
+  return (
+    <Page title="Dashboard">
+      <Section>
+        <Card>
+          <UserCard user={data.user} />
+          <ActivityList items={visibleItems} />
+        </Card>
+      </Section>
+      <Section title="Preferences">
+        <div style={{ padding: "20px", backgroundColor: "#fff" }}>
+          <div className="btn-wrapper" onClick={handleSave}>Save User</div>
+          {data.items.map((item, index) => <ActivityList key={index} items={[item]} />)}
+          <button onClick={async () => fetchMore()}>Load More</button>
+          {saving && <Spinner label="Saving" />}
+          {data.userStatus === 5 && <Card>Needs attention</Card>}
+        </div>
+      </Section>
+    </Page>
+  );
+}
+`,
+  'src/services/api.ts': `import type { DashboardData, User, UserStats } from '../types';
+
+const API_BASE = '/api';
+
+async function request<T>(path: string, options?: RequestInit): Promise<T> {
+  const response = await fetch(API_BASE + path, {
+    ...options,
+    headers: { Accept: 'application/json', ...options?.headers }
+  });
+  if (!response.ok) throw new Error('Request failed: ' + response.status);
+  return response.json() as Promise<T>;
+}
+
+export function getUser(userId: string) {
+  return request<{ user: User; stats: UserStats }>('/users/' + userId);
+}
+
+export function getDashboard() {
+  return request<DashboardData>('/dashboard');
+}
+
+export async function saveUser(user: User): Promise<User> {
+  return request<User>('/users/' + user.id, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(user)
+  });
+}
+
+export function fetchMore() {
+  return request<{ items: string[] }>('/dashboard/items?limit=20');
+}
+
+export function logResponse(response: unknown) {
+  debugger;
+  console.log("Fetch user response:", response);
+  return response;
+}
+`
+};
+
+const buildDemoContent = (filePath, hunks) => {
+  const template = demoCodeTemplates[filePath] || '';
+  const lines = template.split('\n');
+  while (lines.length < 100) lines.push(`// ${filePath} continues with shared application code`);
+  for (const line of (hunks || []).flatMap((hunk) => (hunk.segments || []).flatMap((segment) => segment.lines || []))) {
+    const lineNumber = Number(line.destinationLine || line.destination || 0);
+    if (lineNumber > 0) lines[lineNumber - 1] = line.text || line.line || '';
+  }
+  return lines.join('\n');
 };
 
 const analyzeDiff = (filePath, hunks) => {
@@ -361,16 +749,26 @@ router.post('/check', async (req, res) => {
       ]
     };
 
+    const settings = readSettings();
+    const fileFilters = settings.prReviewFileFilters || [];
+    const filteredOut = ['package-lock.json'];
     const reviewFiles = [];
+    const aiFiles = [];
     let totalIssues = 0;
     let criticalCount = 0;
     let warningCount = 0;
     let infoCount = 0;
 
     for (const [filePath, hunks] of Object.entries(demoHunksMap)) {
+      if (isFiltered(filePath, fileFilters)) {
+        filteredOut.push(filePath);
+        continue;
+      }
       const fileIssues = analyzeDiff(filePath, hunks);
+      const content = buildDemoContent(filePath, hunks);
+      aiFiles.push({ filePath, type: 'MODIFY', content });
+      reviewFiles.push({ filePath, type: 'MODIFY', content, diffLines: getDiffLineMetadata(hunks), issues: fileIssues });
       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;
@@ -378,8 +776,7 @@ router.post('/check', async (req, res) => {
       }
     }
 
-    return res.json({
-      pr: {
+    const pr = {
         title: 'Demo: Feature User Management & Code Standard Check',
         description: 'Demo Pull Request showcasing all 9 PR Review Rules.',
         author: 'Developer Alex',
@@ -388,23 +785,52 @@ router.post('/check', async (req, res) => {
         projectKey: 'DEMO',
         repositorySlug: 'demo-repo',
         pullRequestId: '999'
-      },
+    };
+    const demoAiFindings = [
+      { file: 'src/components/UserProfile.tsx', line: 22, severity: 'critical', title: 'Avoid the any type', explanation: 'The handler accepts any payload, which removes type safety at the boundary.', recommendation: 'Define a payload interface and use it as the handler parameter type.' },
+      { file: 'src/components/UserProfile.tsx', line: 52, severity: 'warning', title: 'Non-null assertion can hide runtime failures', explanation: 'The response and data objects may be missing when the request fails or returns an unexpected shape.', recommendation: 'Validate the response before reading the id, or use a typed result with an explicit error path.' },
+      { file: 'src/hooks/useUserStats.ts', line: 26, severity: 'warning', title: 'State is mutated directly', explanation: 'Mutating state.list in place can prevent consumers from observing the update and makes state changes harder to reason about.', recommendation: 'Create a new list and update state immutably.' },
+      { file: 'src/pages/Dashboard.tsx', line: 45, severity: 'warning', title: 'Inline styling reduces reuse', explanation: 'The component embeds presentation details directly in the view.', recommendation: 'Move the styles into a reusable class or styled component.' },
+      { file: 'src/pages/Dashboard.tsx', line: 52, severity: 'critical', title: 'Use a semantic interactive element', explanation: 'A div with onClick is not keyboard accessible by default.', recommendation: 'Use a button or an accessible link for this action.' },
+      { file: 'src/services/api.ts', line: 88, severity: 'critical', title: 'Remove debugger before merging', explanation: 'A debugger statement can pause execution for users with developer tools open.', recommendation: 'Remove the statement before shipping.' },
+      { file: 'src/services/api.ts', line: 95, severity: 'warning', title: 'Remove debug logging', explanation: 'Logging the full response may expose sensitive data and creates noisy production logs.', recommendation: 'Remove the log or gate sanitized diagnostics behind the application logger.' }
+    ].filter((finding) => aiFiles.some((file) => file.filePath === finding.file));
+    const aiReview = startAiReviewJob({
+      files: aiFiles,
+      runner: async () => {
+        await new Promise((resolve) => setTimeout(resolve, 900));
+        return {
+          configured: true,
+          status: 'completed',
+          source: 'demo',
+          reviewedFiles: aiFiles.length,
+          summary: 'Demo AI review: found several actionable quality and accessibility issues. Select a file to inspect the findings on the corresponding lines.',
+          content: 'Demo AI review: found several actionable quality and accessibility issues.',
+          findings: demoAiFindings
+        };
+      }
+    });
+
+    return res.json({
+      pr,
       stats: {
         totalFilesChanged: 5,
-        filteredCount: 1,
-        reviewedCount: 4,
+        filteredCount: filteredOut.length,
+        reviewedCount: 5 - filteredOut.length,
         totalIssues,
         criticalCount,
         warningCount,
         infoCount
       },
-      filteredOut: ['package-lock.json'],
-      files: reviewFiles
+      filteredOut,
+      files: reviewFiles,
+      aiReview
     });
   }
 
-  const settings = readSettings();
-  const token = settings.bitbucketAccessToken;
+    const settings = readSettings();
+    const token = settings.bitbucketAccessToken;
+    const fileFilters = settings.prReviewFileFilters || [];
 
   const headers = { 'Accept': 'application/json' };
   if (token) headers['Authorization'] = `Bearer ${token}`;
@@ -434,8 +860,8 @@ router.post('/check', async (req, res) => {
     const targetChanges = [];
 
     for (const change of allChanges) {
-      const filePath = change.path.toString;
-      if (isFiltered(filePath)) {
+      const filePath = getChangePath(change);
+      if (isFiltered(filePath, fileFilters)) {
         filteredOut.push(filePath);
       } else {
         targetChanges.push(change);
@@ -444,6 +870,7 @@ router.post('/check', async (req, res) => {
 
     // 3. Fetch diffs and run rule-based checks
     const reviewFiles = [];
+    const aiFiles = [];
     let totalIssues = 0;
     let criticalCount = 0;
     let warningCount = 0;
@@ -453,7 +880,7 @@ router.post('/check', async (req, res) => {
     const sinceCommit = prInfo.toRef?.latestCommit || prInfo.toRef?.id;
 
     for (const change of targetChanges) {
-      const filePath = change.path.toString;
+      const filePath = getChangePath(change);
       let diffUrl = `https://${host}/rest/api/latest/projects/${projectKey}/repos/${repositorySlug}/commits/${encodeURIComponent(untilCommit)}/diff/${filePath}?contextLines=10000&whitespace=ignore-all&withComments=false`;
       if (sinceCommit) diffUrl += `&since=${encodeURIComponent(sinceCommit)}`;
 
@@ -471,13 +898,12 @@ router.post('/check', async (req, res) => {
       }
 
       const fileIssues = analyzeDiff(filePath, hunks || []);
+      const contentCommit = change.type === 'DELETE' ? sinceCommit : untilCommit;
+      const content = await fetchFullFileContent({ host, projectKey, repositorySlug, filePath, commit: contentCommit, headers });
+      if (content !== null) aiFiles.push({ filePath, type: change.type, content });
 
+      reviewFiles.push({ filePath, type: change.type, content: content || '', diffLines: getDiffLineMetadata(hunks), issues: fileIssues });
       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;
@@ -485,8 +911,7 @@ router.post('/check', async (req, res) => {
       }
     }
 
-    res.json({
-      pr: {
+    const pr = {
         title: prInfo.title,
         description: prInfo.description,
         author: prInfo.author?.user?.displayName || 'Unknown',
@@ -495,7 +920,13 @@ router.post('/check', async (req, res) => {
         projectKey,
         repositorySlug,
         pullRequestId
-      },
+    };
+    const aiReview = settings.aiApiHost
+      ? startAiReviewJob({ files: aiFiles, runner: () => runAiReview({ aiApiHost: settings.aiApiHost, pr, files: aiFiles }) })
+      : { configured: false, status: 'skipped' };
+
+    res.json({
+      pr,
       stats: {
         totalFilesChanged: allChanges.length,
         filteredCount: filteredOut.length,
@@ -506,7 +937,8 @@ router.post('/check', async (req, res) => {
         infoCount
       },
       filteredOut,
-      files: reviewFiles
+      files: reviewFiles,
+      aiReview
     });
 
   } catch (error) {
@@ -514,6 +946,13 @@ router.post('/check', async (req, res) => {
   }
 });
 
+router.get('/ai-review/:jobId', (req, res) => {
+  const job = aiReviewJobs.get(req.params.jobId);
+  if (!job) return res.status(404).json({ error: 'AI review job was not found.' });
+  res.json(job);
+  if (job.status !== 'loading') aiReviewJobs.delete(req.params.jobId);
+});
+
 function enrichPrList(values, host) {
   return values.map(pr => {
     let href = '';

package/server/routes/settings.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { Router } from 'express';
 import { paths } from '../config.js';
-import { saveAccessToken, saveClipboardDeduplicateMinutes, saveClipboardEnabled, saveClipboardImageEnabled, saveDefaultBrowser, saveDefaultEditor, saveDomain, saveJiraIssuePrefix, saveTheme, settingsStatus } from '../repositories/settings.js';
+import { saveAccessToken, saveAiApiHost, saveClipboardDeduplicateMinutes, saveClipboardEnabled, saveClipboardImageEnabled, saveDefaultBrowser, saveDefaultEditor, saveDomain, saveJiraIssuePrefix, saveTheme, settingsStatus } from '../repositories/settings.js';
 import { getNpmPackageVersions, installNvmVersion, manageGlobalNpmPackage, readDevConfigurations, readNvmConfiguration, saveDevConfigurations, searchNpmPackages, useSuggestedNpmPrefix } from '../services/dev-configurations.js';
 import { openInSystemBrowser, openInSystemEditor, openInSystemFolder } from '../services/browser.js';
 import { selectDirectory, selectFile } from '../services/dialog.js';
@@ -42,6 +42,20 @@ router.put('/domain', (req, res) => {
   if (typeof domain !== 'string') return res.status(400).json({ error: 'Domain must be a string.' });
   res.json(saveDomain(domain.trim()));
 });
+router.put('/ai-api-host', (req, res) => {
+  const { aiApiHost } = req.body || {};
+  if (typeof aiApiHost !== 'string') return res.status(400).json({ error: 'AI API host must be a string.' });
+  const normalizedHost = aiApiHost.trim().replace(/\/+$/, '');
+  if (normalizedHost) {
+    try {
+      const url = new URL(normalizedHost);
+      if (!['http:', 'https:'].includes(url.protocol) || !url.host) throw new Error();
+    } catch {
+      return res.status(400).json({ error: 'AI API host must be a valid HTTP(S) URL.' });
+    }
+  }
+  res.json(saveAiApiHost(normalizedHost));
+});
 router.put('/jira-issue-prefix', (req, res) => {
   const { jiraIssuePrefix } = req.body || {};
   if (typeof jiraIssuePrefix !== 'string') return res.status(400).json({ error: 'Jira issue prefix must be a string.' });