@in-the-loop-labs/pair-review 1.4.4 → 1.5.0

package/src/routes/analysis.js

@@ -11,7 +11,7 @@
  */
 
 const express = require('express');
-const { query, queryOne, withTransaction, RepoSettingsRepository, ReviewRepository, CommentRepository, AnalysisRunRepository, PRMetadataRepository } = require('../database');
+const { query, queryOne, withTransaction, RepoSettingsRepository, ReviewRepository, CommentRepository, AnalysisRunRepository, PRMetadataRepository, CouncilRepository } = require('../database');
 const { GitWorktreeManager } = require('../git/worktree');
 const Analyzer = require('../ai/analyzer');
 const { v4: uuidv4 } = require('uuid');
@@ -23,18 +23,22 @@ const { normalizeRepository } = require('../utils/paths');
 const {
   activeAnalyses,
   prToAnalysisId,
+  localReviewToAnalysisId,
   progressClients,
   localReviewDiffs,
   getPRKey,
+  getLocalReviewKey,
   getModel,
   determineCompletionInfo,
   broadcastProgress,
   killProcesses,
   isAnalysisCancelled,
   CancellationError,
-  createProgressCallback
+  createProgressCallback,
+  parseEnabledLevels
 } = require('./shared');
 const { generateLocalDiff, computeLocalDiffDigest } = require('../local-review');
+const { validateCouncilConfig, normalizeCouncilConfig } = require('./councils');
 
 const router = express.Router();
 
@@ -47,7 +51,7 @@ router.post('/api/analyze/:owner/:repo/:pr', async (req, res) => {
     const prNumber = parseInt(pr);
 
     // Extract optional provider, model, tier, customInstructions and skipLevel3 from request body
-    const { provider: requestProvider, model: requestModel, tier: requestTier, customInstructions: rawInstructions, skipLevel3: requestSkipLevel3 } = req.body || {};
+    const { provider: requestProvider, model: requestModel, tier: requestTier, customInstructions: rawInstructions, skipLevel3: requestSkipLevel3, enabledLevels: requestEnabledLevels } = req.body || {};
 
     // Trim and validate custom instructions
     const MAX_INSTRUCTIONS_LENGTH = 5000;
@@ -156,6 +160,7 @@ router.post('/api/analyze/:owner/:repo/:pr', async (req, res) => {
 
     // Create DB analysis_runs record immediately so it's queryable for polling
     const analysisRunRepo = new AnalysisRunRepository(db);
+    const levelsConfig = parseEnabledLevels(requestEnabledLevels, requestSkipLevel3);
     await analysisRunRepo.create({
       id: runId,
       reviewId: review.id,
@@ -163,7 +168,9 @@ router.post('/api/analyze/:owner/:repo/:pr', async (req, res) => {
       model,
       repoInstructions,
       requestInstructions,
-      headSha: prMetadata.head_sha || null
+      headSha: prMetadata.head_sha || null,
+      configType: 'single',
+      levelsConfig
     });
 
     // Store analysis status with separate tracking for each level
@@ -176,9 +183,9 @@ router.post('/api/analyze/:owner/:repo/:pr', async (req, res) => {
       progress: 'Starting analysis...',
       // Track each level separately for parallel execution
       levels: {
-        1: { status: 'running', progress: 'Starting...' },
-        2: { status: 'running', progress: 'Starting...' },
-        3: requestSkipLevel3 ? { status: 'skipped', progress: 'Skipped' } : { status: 'running', progress: 'Starting...' },
+        1: levelsConfig[1] ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
+        2: levelsConfig[2] ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
+        3: levelsConfig[3] ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
         4: { status: 'pending', progress: 'Pending' }
       },
       filesAnalyzed: 0,
@@ -214,7 +221,7 @@ router.post('/api/analyze/:owner/:repo/:pr', async (req, res) => {
     const progressCallback = createProgressCallback(analysisId);
 
     // Start analysis asynchronously (skipRunCreation since we created the record above; tier for prompt selection, skipLevel3 flag)
-    analyzer.analyzeLevel1(review.id, worktreePath, prMetadata, progressCallback, { repoInstructions, requestInstructions }, null, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: requestSkipLevel3 })
+    analyzer.analyzeLevel1(review.id, worktreePath, prMetadata, progressCallback, { repoInstructions, requestInstructions }, null, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: requestSkipLevel3, enabledLevels: levelsConfig })
       .then(async result => {
         logger.section('Analysis Results');
         logger.success(`Analysis complete for PR #${prNumber}`);
@@ -587,10 +594,11 @@ router.get('/api/pr/:owner/:repo/:number/has-ai-suggestions', async (req, res) =
     }
 
     // Check if any AI suggestions exist for this PR using review.id
+    // Exclude raw council voice suggestions (is_raw=1) — only count final/consolidated suggestions
     const result = await queryOne(db, `
       SELECT EXISTS(
         SELECT 1 FROM comments
-        WHERE review_id = ? AND source = 'ai'
+        WHERE review_id = ? AND source = 'ai' AND (is_raw = 0 OR is_raw IS NULL)
       ) as has_suggestions
     `, [review.id]);
 
@@ -772,6 +780,7 @@ router.get('/api/pr/:owner/:repo/:number/ai-suggestions', async (req, res) => {
         AND source = 'ai'
         AND ${levelFilter}
         AND status IN ('active', 'dismissed', 'adopted', 'draft', 'submitted')
+        AND (is_raw = 0 OR is_raw IS NULL)
         AND ${runIdFilter}
       ORDER BY
         CASE
@@ -863,7 +872,10 @@ router.get('/api/analysis-runs/:reviewId', async (req, res) => {
     const analysisRunRepo = new AnalysisRunRepository(db);
     const runs = await analysisRunRepo.getByReviewId(parseInt(reviewId, 10));
 
-    res.json({ runs });
+    res.json({ runs: runs.map(r => ({
+      ...r,
+      levels_config: r.levels_config ? JSON.parse(r.levels_config) : null
+    })) });
   } catch (error) {
     logger.error('Error fetching analysis runs:', error);
     res.status(500).json({ error: 'Failed to fetch analysis runs' });
@@ -1087,4 +1099,477 @@ router.post('/api/analysis-results', async (req, res) => {
   }
 });
 
+/**
+ * Launch a council analysis, shared by both PR and local mode.
+ *
+ * This helper encapsulates all the common logic: council config resolution/validation,
+ * analysis run record creation, progress tracking setup, async analyzer invocation,
+ * completion/failure status broadcasting, and tracking map cleanup.
+ *
+ * Mode-specific differences are injected via the `modeContext` parameter.
+ *
+ * @param {Object} db - Database handle
+ * @param {Object} modeContext - Mode-specific values:
+ *   @param {number} modeContext.reviewId - Review record ID
+ *   @param {string} modeContext.worktreePath - Path to the worktree or local directory
+ *   @param {Object} modeContext.prMetadata - PR metadata (from DB for PR mode, synthetic for local mode)
+ *   @param {Array|null} modeContext.changedFiles - Changed files list (null for PR mode)
+ *   @param {string} modeContext.repository - Repository identifier (e.g., "owner/repo")
+ *   @param {string} modeContext.headSha - HEAD SHA for the analysis run record
+ *   @param {Object} modeContext.trackingMap - Map instance for tracking (prToAnalysisId or localReviewToAnalysisId)
+ *   @param {string} modeContext.trackingKey - Key for the tracking map (getPRKey() or getLocalReviewKey())
+ *   @param {string} modeContext.logLabel - Human-readable label for logs (e.g., "PR #42" or "local review #7")
+ *   @param {Object} [modeContext.initialStatusExtra] - Extra fields merged into the initial status object
+ *   @param {Array<string>} [modeContext.extraBroadcastKeys] - Additional SSE keys to broadcast completion to
+ *   @param {Function} [modeContext.onSuccess] - Optional async callback invoked after successful completion
+ *     with signature (result, analysisRunRepo, runId). Used for mode-specific side effects like saving
+ *     summary to the review record.
+ *   @param {Object} [modeContext.runUpdateExtra] - Extra fields merged into the analysisRunRepo.update call on success
+ * @param {Object} councilConfig - Validated council configuration
+ * @param {string} councilId - Council ID (for the model field in analysis_runs), or null for inline config
+ * @param {Object} instructions - { repoInstructions, requestInstructions }
+ * @returns {{ analysisId: string, runId: string }} IDs for the caller to return in the response
+ */
+/**
+ * Check if a level is enabled in a council config, handling both formats:
+ * - Voice-centric: levels values are booleans (e.g. { '1': true })
+ * - Advanced: levels values are objects (e.g. { '1': { enabled: true, voices: [...] } })
+ */
+function isLevelEnabled(councilConfig, levelKey) {
+  const val = councilConfig.levels?.[levelKey];
+  if (typeof val === 'boolean') return val;
+  return val?.enabled === true;
+}
+
+async function launchCouncilAnalysis(db, modeContext, councilConfig, councilId, instructions, configType = 'advanced') {
+  const {
+    reviewId,
+    worktreePath,
+    prMetadata,
+    changedFiles,
+    repository,
+    headSha,
+    trackingMap,
+    trackingKey,
+    logLabel,
+    initialStatusExtra,
+    extraBroadcastKeys,
+    onSuccess,
+    runUpdateExtra
+  } = modeContext;
+
+  const { repoInstructions, requestInstructions } = instructions;
+
+  // Determine if voice-centric mode
+  const isVoiceCentric = configType === 'council';
+
+  // Create run/analysis ID
+  const runId = uuidv4();
+  const analysisId = runId;
+
+  // Compute levelsConfig for the run record
+  let levelsConfig = null;
+  if (isVoiceCentric && councilConfig.levels) {
+    levelsConfig = councilConfig.levels;
+  } else if (councilConfig.levels) {
+    levelsConfig = {};
+    for (const [key, val] of Object.entries(councilConfig.levels)) {
+      levelsConfig[key] = val?.enabled !== false;
+    }
+  }
+
+  // Create DB analysis_runs record
+  const analysisRunRepo = new AnalysisRunRepository(db);
+  await analysisRunRepo.create({
+    id: runId,
+    reviewId,
+    provider: 'council',
+    model: councilId || 'inline-config',
+    repoInstructions,
+    requestInstructions,
+    headSha: headSha || null,
+    configType,
+    levelsConfig
+  });
+
+  // Touch council MRU timestamp (if using a saved council, not inline-config)
+  if (councilId) {
+    const councilRepo = new CouncilRepository(db);
+    councilRepo.touchLastUsedAt(councilId).catch(err => {
+      logger.warn(`Failed to update council last_used_at: ${err.message}`);
+    });
+  }
+
+  // Setup progress tracking
+  const initialStatus = {
+    id: analysisId,
+    repository,
+    status: 'running',
+    startedAt: new Date().toISOString(),
+    progress: 'Starting council analysis...',
+    levels: {
+      1: isLevelEnabled(councilConfig, '1') ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
+      2: isLevelEnabled(councilConfig, '2') ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
+      3: isLevelEnabled(councilConfig, '3') ? { status: 'running', progress: 'Starting...' } : { status: 'skipped', progress: 'Skipped' },
+      4: { status: 'pending', progress: 'Pending' }
+    },
+    isCouncil: true,
+    councilConfig,
+    configType,
+    filesAnalyzed: 0,
+    filesRemaining: 0,
+    ...initialStatusExtra
+  };
+  activeAnalyses.set(analysisId, initialStatus);
+
+  // Store tracking map entry
+  trackingMap.set(trackingKey, analysisId);
+
+  broadcastProgress(analysisId, initialStatus);
+
+  // Create analyzer (provider/model don't matter for council — voices have their own)
+  const analyzer = new Analyzer(db, 'council', 'council');
+
+  logger.section(`Council Analysis Request (${configType}) - ${logLabel}`);
+  logger.log('API', `Repository: ${repository}`, 'magenta');
+  logger.log('API', `Analysis ID: ${analysisId}`, 'magenta');
+  logger.log('API', `Config type: ${configType}`, 'magenta');
+
+  const progressCallback = createProgressCallback(analysisId);
+
+  // Route to voice-centric or level-centric council based on configType
+  const reviewContext = {
+    reviewId,
+    worktreePath,
+    prMetadata,
+    changedFiles,
+    instructions: { repoInstructions, requestInstructions }
+  };
+
+  const analysisPromise = isVoiceCentric
+    ? analyzer.runReviewerCentricCouncil(reviewContext, councilConfig, { analysisId, runId, progressCallback })
+    : analyzer.runCouncilAnalysis(reviewContext, councilConfig, { analysisId, runId, progressCallback });
+
+  analysisPromise
+    .then(async result => {
+      logger.success(`Council analysis complete for ${logLabel}: ${result.suggestions.length} suggestions`);
+
+      // Update analysis run record
+      try {
+        await analysisRunRepo.update(runId, {
+          status: 'completed',
+          summary: result.summary,
+          totalSuggestions: result.suggestions.length,
+          ...runUpdateExtra
+        });
+      } catch (updateError) {
+        logger.warn(`Failed to update analysis_run: ${updateError.message}`);
+      }
+
+      // Mode-specific success callback (e.g., saving summary to review)
+      if (onSuccess) {
+        try {
+          await onSuccess(result, analysisRunRepo, runId);
+        } catch (callbackError) {
+          logger.warn(`Council onSuccess callback failed: ${callbackError.message}`);
+        }
+      }
+
+      // Use robust fallback: if activeAnalyses entry was removed (e.g. by cancel), use empty object
+      const currentStatus = activeAnalyses.get(analysisId);
+      if (!currentStatus) return;
+
+      const completedStatus = {
+        ...currentStatus,
+        status: 'completed',
+        completedAt: new Date().toISOString(),
+        progress: `Council analysis complete — ${result.suggestions.length} suggestions`,
+        suggestionsCount: result.suggestions.length,
+        levels: {
+          ...currentStatus.levels,
+          4: { status: 'completed', progress: 'Results finalized' }
+        }
+      };
+      // Mark all enabled levels as completed
+      for (const levelKey of ['1', '2', '3']) {
+        if (currentStatus.levels?.[levelKey]?.status === 'running') {
+          completedStatus.levels[levelKey] = { status: 'completed', progress: 'Complete' };
+        }
+      }
+      activeAnalyses.set(analysisId, completedStatus);
+      broadcastProgress(analysisId, completedStatus);
+
+      // Broadcast to additional SSE keys (e.g., local mode broadcasts to `local-${reviewId}`)
+      if (extraBroadcastKeys) {
+        for (const key of extraBroadcastKeys) {
+          broadcastProgress(key, { ...completedStatus, source: 'council' });
+        }
+      }
+    })
+    .catch(error => {
+      if (error.isCancellation) {
+        logger.info(`Council analysis cancelled for ${logLabel}`);
+        return;
+      }
+      logger.error(`Council analysis failed for ${logLabel}: ${error.message}`);
+
+      // Use robust fallback: if activeAnalyses entry was removed, use empty object
+      // This prevents orphaned DB records in "running" status
+      const failedStatus = {
+        ...(activeAnalyses.get(analysisId) || {}),
+        status: 'failed',
+        completedAt: new Date().toISOString(),
+        error: error.message,
+        progress: 'Council analysis failed'
+      };
+      activeAnalyses.set(analysisId, failedStatus);
+      broadcastProgress(analysisId, failedStatus);
+
+      // Update analysis run record
+      analysisRunRepo.update(runId, { status: 'failed' }).catch(() => {});
+    })
+    .finally(() => {
+      // Clean up tracking map entry (always runs regardless of success/failure)
+      trackingMap.delete(trackingKey);
+    });
+
+  return { analysisId, runId };
+}
+
+/**
+ * Trigger council analysis for a PR
+ * Uses multiple voices/providers across configurable levels
+ */
+router.post('/api/analyze/council/:owner/:repo/:pr', async (req, res) => {
+  try {
+    const { owner, repo, pr } = req.params;
+    const prNumber = parseInt(pr);
+    const { councilId, councilConfig: inlineConfig, customInstructions: rawInstructions, configType: requestConfigType } = req.body || {};
+
+    if (isNaN(prNumber) || prNumber <= 0) {
+      return res.status(400).json({ error: 'Invalid pull request number' });
+    }
+
+    if (!councilId && !inlineConfig) {
+      return res.status(400).json({ error: 'Either councilId or councilConfig is required' });
+    }
+
+    const repository = normalizeRepository(owner, repo);
+    const db = req.app.get('db');
+
+    // Resolve council config and determine config type
+    // Priority: request body configType > saved council type > default 'advanced'
+    let councilConfig;
+    let configType;
+    if (councilId) {
+      const councilRepo = new CouncilRepository(db);
+      const council = await councilRepo.getById(councilId);
+      if (!council) {
+        return res.status(404).json({ error: 'Council not found' });
+      }
+      councilConfig = council.config;
+      configType = requestConfigType || council.type || 'advanced';
+    } else {
+      councilConfig = inlineConfig;
+      configType = requestConfigType || 'advanced';
+    }
+
+    // Normalize config to voice-centric format if needed (handles DB-stored legacy formats)
+    councilConfig = normalizeCouncilConfig(councilConfig, configType);
+
+    // Validate council config (saved configs are validated on save; inline configs need runtime validation)
+    const configError = validateCouncilConfig(councilConfig, configType);
+    if (configError) {
+      return res.status(400).json({ error: `Invalid council config: ${configError}` });
+    }
+
+    // Get PR metadata
+    const prMetadataRepo = new PRMetadataRepository(db);
+    const prMetadata = await prMetadataRepo.getByPR(prNumber, repository);
+    if (!prMetadata) {
+      return res.status(404).json({ error: `Pull request #${prNumber} not found. Please load the PR first.` });
+    }
+
+    // Get worktree path
+    const worktreeManager = new GitWorktreeManager(db);
+    const worktreePath = await worktreeManager.getWorktreePath({ owner, repo, number: prNumber });
+    if (!await worktreeManager.worktreeExists({ owner, repo, number: prNumber })) {
+      return res.status(404).json({ error: 'Worktree not found for this PR. Please reload the PR.' });
+    }
+
+    // Resolve instructions
+    const reviewRepo = new ReviewRepository(db);
+    const repoSettingsRepo = new RepoSettingsRepository(db);
+    const repoSettings = await repoSettingsRepo.getRepoSettings(repository);
+    const repoInstructions = repoSettings?.default_instructions || null;
+    const requestInstructions = rawInstructions?.trim() || null;
+
+    // Get or create review record
+    const review = await reviewRepo.getOrCreate({ prNumber, repository });
+
+    // Save custom instructions to the review record (same as single-model endpoint)
+    if (requestInstructions) {
+      await reviewRepo.upsertCustomInstructions(prNumber, repository, requestInstructions);
+    }
+
+    const { analysisId, runId } = await launchCouncilAnalysis(
+      db,
+      {
+        reviewId: review.id,
+        worktreePath,
+        prMetadata,
+        changedFiles: null,
+        repository,
+        headSha: prMetadata.head_sha,
+        trackingMap: prToAnalysisId,
+        trackingKey: getPRKey(owner, repo, prNumber),
+        logLabel: `PR #${prNumber}`,
+        initialStatusExtra: { prNumber },
+        extraBroadcastKeys: null,
+        onSuccess: async (result) => {
+          if (result.summary) {
+            await reviewRepo.upsertSummary(prNumber, repository, result.summary);
+          }
+        }
+      },
+      councilConfig,
+      councilId,
+      { repoInstructions, requestInstructions },
+      configType
+    );
+
+    res.json({
+      analysisId,
+      runId,
+      status: 'started',
+      message: 'Council analysis started in background',
+      isCouncil: true
+    });
+  } catch (error) {
+    logger.error('Error starting council analysis:', error);
+    res.status(500).json({ error: 'Failed to start council analysis' });
+  }
+});
+
+/**
+ * Trigger council analysis for a local review
+ */
+router.post('/api/local/:reviewId/analyze/council', async (req, res) => {
+  try {
+    const { reviewId } = req.params;
+    const { councilId, councilConfig: inlineConfig, customInstructions: rawInstructions, configType: requestConfigType } = req.body || {};
+
+    if (!councilId && !inlineConfig) {
+      return res.status(400).json({ error: 'Either councilId or councilConfig is required' });
+    }
+
+    const db = req.app.get('db');
+
+    // Get review record
+    const review = await queryOne(db, 'SELECT * FROM reviews WHERE id = ? AND review_type = ?', [reviewId, 'local']);
+    if (!review) {
+      return res.status(404).json({ error: 'Local review not found' });
+    }
+
+    // Resolve council config and determine config type
+    // Priority: request body configType > saved council type > default 'advanced'
+    let councilConfig;
+    let configType;
+    if (councilId) {
+      const councilRepo = new CouncilRepository(db);
+      const council = await councilRepo.getById(councilId);
+      if (!council) {
+        return res.status(404).json({ error: 'Council not found' });
+      }
+      councilConfig = council.config;
+      configType = requestConfigType || council.type || 'advanced';
+    } else {
+      councilConfig = inlineConfig;
+      configType = requestConfigType || 'advanced';
+    }
+
+    // Normalize config to voice-centric format if needed (handles DB-stored legacy formats)
+    councilConfig = normalizeCouncilConfig(councilConfig, configType);
+
+    // Validate council config (saved configs are validated on save; inline configs need runtime validation)
+    const configError = validateCouncilConfig(councilConfig, configType);
+    if (configError) {
+      return res.status(400).json({ error: `Invalid council config: ${configError}` });
+    }
+
+    const localPath = review.local_path;
+
+    // Build metadata for local mode
+    const prMetadata = {
+      reviewType: 'local',
+      repository: review.repository,
+      title: review.name || 'Local changes',
+      description: '',
+      head_sha: review.local_head_sha
+    };
+
+    // Get changed files
+    const analyzer = new Analyzer(db, 'council', 'council');
+    const changedFiles = await analyzer.getLocalChangedFiles(localPath);
+
+    // Generate and cache diff so the web UI can display it (same as regular analysis endpoint)
+    try {
+      const diffResult = await generateLocalDiff(localPath);
+      const digest = await computeLocalDiffDigest(localPath);
+      localReviewDiffs.set(reviewId, { diff: diffResult.diff, stats: diffResult.stats, digest });
+    } catch (diffError) {
+      logger.warn(`Could not generate diff for local council review ${reviewId}: ${diffError.message}`);
+    }
+
+    // Resolve instructions
+    const repoSettingsRepo = new RepoSettingsRepository(db);
+    const reviewRepo = new ReviewRepository(db);
+    const repoSettings = await repoSettingsRepo.getRepoSettings(review.repository);
+    const repoInstructions = repoSettings?.default_instructions || null;
+    const requestInstructions = rawInstructions?.trim() || null;
+
+    const parsedReviewId = parseInt(reviewId, 10);
+
+    // Save custom instructions to the review record (same as single-model endpoint)
+    if (requestInstructions) {
+      await reviewRepo.updateReview(parsedReviewId, {
+        customInstructions: requestInstructions
+      });
+    }
+
+    const { analysisId, runId } = await launchCouncilAnalysis(
+      db,
+      {
+        reviewId: parsedReviewId,
+        worktreePath: localPath,
+        prMetadata,
+        changedFiles,
+        repository: review.repository,
+        headSha: review.local_head_sha,
+        trackingMap: localReviewToAnalysisId,
+        trackingKey: getLocalReviewKey(reviewId),
+        logLabel: `local review #${reviewId}`,
+        initialStatusExtra: { reviewId: parsedReviewId, reviewType: 'local' },
+        extraBroadcastKeys: [`local-${reviewId}`],
+        runUpdateExtra: { filesAnalyzed: changedFiles.length }
+      },
+      councilConfig,
+      councilId,
+      { repoInstructions, requestInstructions },
+      configType
+    );
+
+    res.json({
+      analysisId,
+      runId,
+      status: 'started',
+      message: 'Council analysis started in background',
+      isCouncil: true
+    });
+  } catch (error) {
+    logger.error('Error starting local council analysis:', error);
+    res.status(500).json({ error: 'Failed to start council analysis' });
+  }
+});
+
 module.exports = router;