SESSION 112: Integrate V9GroupedReportFormatter, deprecate V9ReportFormatterFinal

Key changes:
- V9AnalysisService now uses V9GroupedReportFormatter exclusively
- V9ReportFormatterFinal moved to analyzers/deprecated/ folder
- Updated v9-base-analyzer, v9-integrated-analyzer, v9-report-compiler
- Removed useGroupedReport option (always uses grouped formatter)
- Session 112 enhancements now active: progressHistory, tier support, IDE fix files

The V9GroupedReportFormatter provides:
- Progress history tracking for score trends
- User tier support (basic/pro/enterprise)
- Better issue grouping
- IDE integration files (LSP, SARIF)
- Community impact tracking
- XP/achievements system

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: alpsla

docs/sample-reports/v9-session112-basic-report.md

@@ -75,8 +75,10 @@ export { V9KotlinAnalyzer } from './two-branch/analyzers/v9-kotlin-analyzer';
 export * from './two-branch/analyzers/v9-types';
 
 // Export report formatters
-export { V9ReportFormatterFinal } from './two-branch/analyzers/v9-report-formatter';
+// SESSION 112: V9GroupedReportFormatter is the primary formatter
 export { V9GroupedReportFormatter } from './two-branch/analyzers/v9-grouped-report-formatter';
+// NOTE: V9ReportFormatterFinal has been deprecated and moved to analyzers/deprecated/
+// If you need it for backward compatibility, import directly from that path
 
 // Export other working modules
 export * from './standard/utils';

packages/agents/src/index.ts

@@ -1,6 +1,21 @@
 /**
- * V9 Report Formatter - Final Production Version
- * 
+ * @deprecated SESSION 112 - This formatter has been replaced by V9GroupedReportFormatter
+ *
+ * ARCHIVED: 2026-01-19
+ * REASON: V9GroupedReportFormatter provides:
+ *   - Progress history tracking
+ *   - User tier support (basic/pro/enterprise)
+ *   - Better issue grouping
+ *   - IDE integration files
+ *   - Community impact tracking
+ *   - XP/achievements system
+ *
+ * DO NOT USE FOR NEW CODE - Use V9GroupedReportFormatter instead
+ * Location: ../v9-grouped-report-formatter.ts
+ *
+ * ---
+ * V9 Report Formatter - Final Production Version (DEPRECATED)
+ *
  * This formatter generates the complete V9 report with all improvements:
  * - Summary statistics
  * - Proper category breakdown

…-branch/analyzers/v9-report-formatter.ts …lyzers/deprecated/v9-report-formatter.tspackages/agents/src/two-branch/analyzers/v9-report-formatter.ts renamed to packages/agents/src/two-branch/analyzers/deprecated/v9-report-formatter.ts packages/agents/src/two-branch/analyzers/v9-report-formatter.ts renamed to packages/agents/src/two-branch/analyzers/deprecated/v9-report-formatter.ts

@@ -22,9 +22,11 @@
 // Factory - ALWAYS use this to create analyzers
 export { V9AnalyzerFactory, type SupportedLanguage } from './v9-analyzer-factory';
 
-// Report Generation - Use the MAIN formatter (formerly v9-report-formatter-final)
-export { V9ReportFormatterFinal as V9ReportFormatter } from './v9-report-formatter';
+// Report Generation - SESSION 112: V9GroupedReportFormatter is now the primary formatter
+export { V9GroupedReportFormatter as V9ReportFormatter } from './v9-grouped-report-formatter';
+export { V9GroupedReportFormatter } from './v9-grouped-report-formatter';
 export { V9PRCommentGenerator } from './v9-pr-comment-generator';
+// NOTE: V9ReportFormatterFinal has been deprecated and moved to deprecated/v9-report-formatter.ts
 
 // Core Types
 export * from './v9-types';

packages/agents/src/two-branch/analyzers/index.ts

@@ -32,7 +32,8 @@ import { V9ScoringCalculator } from './v9-scoring-calculator';
 import { V9IssueComparator } from './v9-issue-comparator';
 import { V9EducationalResources } from './v9-educational-resources';
 import { V9BusinessImpact } from './v9-business-impact';
-import { V9ReportFormatterFinal as V9ReportFormatter } from './v9-report-formatter';
+// SESSION 112: Use V9GroupedReportFormatter as the primary formatter
+import { V9GroupedReportFormatter as V9ReportFormatter } from './v9-grouped-report-formatter';
 
 // Import utilities
 import { getRepoManager, getFileSelector } from '../utils/repository-utils-factory';
@@ -261,8 +262,42 @@ export abstract class V9BaseAnalyzer {
         analyzedAt: timestamp
       };
 
-      const report = await this.reportFormatter.generateCompleteReport(result, completeMetadata, config.name);
-      await this.saveReport(report, prNumber);
+      // SESSION 112: Use V9GroupedReportFormatter.generateGroupedReport
+      // Convert AnalysisResult issues to EnrichedIssue format for the grouped formatter
+      const convertToEnrichedIssue = (i: Issue, cat: string) => ({
+        file: i.file,
+        line: i.line,
+        column: undefined,
+        rule: i.rule || i.title,
+        tool: i.tool,
+        severity: i.severity as 'critical' | 'high' | 'medium' | 'low',
+        message: i.description || i.title,
+        category: cat,
+        detectedCategory: i.category as string,
+        snippet: i.codeSnippet
+      });
+
+      const allIssues = [
+        ...newIssues.map(i => convertToEnrichedIssue(i, 'NEW')),
+        ...existingIssues.map(i => convertToEnrichedIssue(i, 'EXISTING_REST')),
+        ...resolvedIssues.map(i => convertToEnrichedIssue(i, 'RESOLVED'))
+      ];
+
+      // Import groupIssues to create groups
+      const { groupIssues } = await import('../utils/issue-grouping');
+      const groupingResult = groupIssues(allIssues);
+
+      // Generate grouped report
+      const reportOutput = await this.reportFormatter.generateGroupedReport(
+        allIssues,
+        groupingResult.groups,
+        {
+          ...completeMetadata,
+          decision: result.decision,
+          blockingCount: blockingIssues.length
+        }
+      );
+      await this.saveReport(reportOutput.markdown, prNumber);
 
       this.logger.log('✅ Analysis complete!');
 

packages/agents/src/two-branch/analyzers/v9-base-analyzer.ts

@@ -5,8 +5,8 @@
 
 import { RedisToolOutputManager, ToolOutput } from '../utils/redis-tool-output-manager';
 import { KubernetesRepositoryManager } from '../utils/kubernetes-repository-manager';
-import { V9ReportFormatterFinal } from './v9-report-formatter';
-import { V9GroupedReportFormatter } from './v9-grouped-report-formatter';  // Phase B+C: Cost-optimized reports
+// SESSION 112: V9ReportFormatterFinal deprecated, use V9GroupedReportFormatter only
+import { V9GroupedReportFormatter } from './v9-grouped-report-formatter';
 import { DynamicModelSelector } from '../services/dynamic-model-selector';
 import { SkillScoreManager } from './v9-skill-score-manager';  // Moved to V9 core
 import { V9CleanupService } from '../services/v9-cleanup-service';  // Automatic cleanup after analysis
@@ -42,8 +42,8 @@ interface AIInsight {
 export class V9IntegratedAnalyzer {
   private redisManager: RedisToolOutputManager;
   private repoManager: KubernetesRepositoryManager;
-  private reportFormatter: V9ReportFormatterFinal;
-  private groupedFormatter: V9GroupedReportFormatter;  // Phase B+C: Cost-optimized formatter
+  // SESSION 112: Unified to single formatter
+  private reportFormatter: V9GroupedReportFormatter;
   private modelSelector: DynamicModelSelector;
   private cleanupService: V9CleanupService;  // Automatic cleanup service
   private aiClient = getResilientAIClient();
@@ -53,21 +53,13 @@ export class V9IntegratedAnalyzer {
   private detectedLanguage = 'unknown';
   private detectedRepoSize: 'small' | 'medium' | 'large' | 'enterprise' = 'medium';
 
-  // Phase B+C: Report format configuration
-  private useGroupedReport = true;  // Default to grouped (99.8% cost savings)
+  // SESSION 112: Unified formatter (V9GroupedReportFormatter replaces V9ReportFormatterFinal)
 
-  constructor(options?: { useGroupedReport?: boolean }) {
+  constructor() {
     this.redisManager = new RedisToolOutputManager();
     this.repoManager = new KubernetesRepositoryManager();
-    this.reportFormatter = new V9ReportFormatterFinal();
-    this.groupedFormatter = new V9GroupedReportFormatter();  // Phase B+C: Initialize grouped formatter
-    
-    // Allow override via options or environment variable
-    if (options?.useGroupedReport !== undefined) {
-      this.useGroupedReport = options.useGroupedReport;
-    } else if (process.env.V9_USE_FULL_REPORT === 'true') {
-      this.useGroupedReport = false;
-    }
+    // SESSION 112: Use only V9GroupedReportFormatter
+    this.reportFormatter = new V9GroupedReportFormatter();
 
     // Use the existing DynamicModelSelector that fetches from Supabase
     this.modelSelector = new DynamicModelSelector(process.env.OPENROUTER_API_KEY);
@@ -468,7 +460,7 @@ and actionable recommendations. Focus on business value and team productivity.`;
         aiInsights: data.aiInsights
       },
       {
-        useGroupedReport: this.useGroupedReport,
+        // SESSION 112: useGroupedReport is deprecated (always true now)
         modelConfigResolver: this.modelConfigResolver,
         detectedLanguage: this.detectedLanguage,
         detectedRepoSize: this.detectedRepoSize,
@@ -529,7 +521,7 @@ and actionable recommendations. Focus on business value and team productivity.`;
         parallelExecution: true,
         parallelFixGeneration: true,
         fixGenerationTime: `${(result.completeMetadata.fixGenerationTime / 1000).toFixed(2)}s`,
-        reportType: this.useGroupedReport ? 'grouped' : 'full',
+        reportType: 'grouped', // SESSION 112: Always grouped
         agentMetrics: (result.completeMetadata.agentsUsed || []).map((a: any) => ({
           agent: a.agentName,
           issues: a.issuesFound,
@@ -543,7 +535,8 @@ and actionable recommendations. Focus on business value and team productivity.`;
         }))
       },
 
-      ...(this.useGroupedReport && result.attachments ? {
+      // SESSION 112: Always include attachments (grouped report is always used)
+      ...(result.attachments ? {
         attachments: result.attachments.locationAttachments,
         ideFixFiles: result.attachments.ideFixFiles,
         issueGroupMapping: result.attachments.mapping

packages/agents/src/two-branch/analyzers/v9-integrated-analyzer.ts

@@ -37,7 +37,7 @@ import {
 } from '../utils/security-utils';
 import { SpecializedAgentFactory } from '../agents/specialized-agents';
 import { V9EducationalResources } from '../analyzers/v9-educational-resources';
-import { V9ReportFormatterFinal } from '../analyzers/v9-report-formatter';
+import { V9GroupedReportFormatter } from '../analyzers/v9-grouped-report-formatter';
 import { ModelConfigResolver } from '../../standard/orchestrator/model-config-resolver';
 import { CodeSnippetExtractor } from '../utils/code-snippet-extractor';
 import { groupIssues, prioritizeGroups, generateGroupingSummary } from '../utils/issue-grouping';
@@ -879,51 +879,78 @@ export class V9AnalysisService {
       console.log(`[Report] Scanner guidance saved`);
     }
 
-    // Generate main markdown report using existing formatter
+    // SESSION 112: Use V9GroupedReportFormatter (with progressHistory, tier support)
+    // Replaces V9ReportFormatterFinal for all new reports
     try {
-      const formatter = new V9ReportFormatterFinal();
-
-      // SESSION 92: Split issues by category for formatter
-      // V9ReportFormatterFinal expects newIssues, existingIssues, resolvedIssues arrays
-      const newIssues = issues.filter(i => i.category === 'NEW');
-      const existingModifiedIssues = issues.filter(i => i.category === 'EXISTING_MODIFIED');
-      const existingRestIssues = issues.filter(i => i.category === 'EXISTING_REST');
-      const resolvedIssues = issues.filter(i => i.category === 'RESOLVED');
-
-      // Build result object for formatter with proper structure
-      const analysisResult: any = {
-        issues,
-        newIssues,
-        existingIssues: [...existingModifiedIssues, ...existingRestIssues],
-        resolvedIssues,
+      const formatter = new V9GroupedReportFormatter();
+
+      // Generate issue groups for the formatter
+      const groupingResult = groupIssues(issues);
+
+      // Build metadata object for grouped formatter
+      const reportMetadata = {
+        repository: metadata.repository,
+        repoUrl: metadata.repoUrl,
+        repoPath: metadata.repoPath,
+        prNumber: metadata.prNumber,
+        prTitle: metadata.prTitle,
+        branch: metadata.branch || metadata.prBranch,
+        baseBranch: metadata.baseBranch,
+        prAuthor: metadata.prAuthor,
+        prAuthorEmail: metadata.prAuthorEmail,
+        organizationName: metadata.organizationName,
+        totalFiles: metadata.totalFiles || 0,
+        totalLinesOfCode: metadata.totalLinesOfCode,
+        filesModified: metadata.filesModified,
+        linesAdded: metadata.linesAdded,
+        linesDeleted: metadata.linesDeleted,
+        languageBreakdown: metadata.languageBreakdown,
         decision,
-        score: Math.max(0, 100 - (blockingIssues.length * 10) - (newIssues.length * 0.5)),
-        categoryScores: {},
-        duration: 0,
-        cost: 0
+        blockingCount: blockingIssues.length,
+        totalDuration: metadata.totalDuration || 0,
+        cloneTime: metadata.cloneTime,
+        analysisTime: metadata.analysisTime,
+        reportGenerationTime: metadata.reportGenerationTime,
+        analyzedAt: new Date().toISOString(),
+        analyzerVersion: metadata.analyzerVersion || '9.0.0',
+        toolPerformance: metadata.toolPerformance || [],
+        agentPerformance: metadata.agentPerformance,
+        modelsUsed: metadata.modelsUsed,
+        userTier: metadata.userTier || 'basic'
       };
 
-      // Build metadata object for formatter
-      const reportMetadata: any = {
-        ...metadata,
-        analysisTimestamp: new Date().toISOString(),
-        totalDuration: 0
-      };
-
-      const report = await formatter.generateCompleteReport(
-        analysisResult,
-        reportMetadata,
-        metadata.language
+      // Generate grouped report with all Session 112 enhancements
+      const reportOutput = await formatter.generateGroupedReport(
+        issues,
+        groupingResult.groups,
+        reportMetadata
       );
 
       // lgtm[js/path-injection] - outputDir is internally computed, 'report.md' is hardcoded
       const markdownPath = path.join(outputDir, 'report.md');
-      fs.writeFileSync(markdownPath, report); // lgtm[js/path-injection]
+      fs.writeFileSync(markdownPath, reportOutput.markdown); // lgtm[js/path-injection]
       console.log(`[Report] Markdown saved`);
 
+      // Save IDE fix files if available
+      if (reportOutput.ideFixFiles && reportOutput.ideFixFiles.length > 0) {
+        for (const fixFile of reportOutput.ideFixFiles) {
+          const fixPath = path.join(outputDir, fixFile.filename);
+          fs.writeFileSync(fixPath, JSON.stringify(fixFile.content, null, 2));
+        }
+        console.log(`[Report] ${reportOutput.ideFixFiles.length} IDE fix files saved`);
+      }
+
+      // Save group mapping for API consumers
+      if (reportOutput.mapping) {
+        const mappingPath = path.join(outputDir, 'issue-groups.json');
+        fs.writeFileSync(mappingPath, JSON.stringify(reportOutput.mapping, null, 2));
+        console.log(`[Report] Issue group mapping saved`);
+      }
+
       return { markdown: markdownPath };
     } catch (error: any) {
       console.log(`   ⚠️  Report generation error: ${error.message}`);
+      console.error(error);
       return {};
     }
   }

packages/agents/src/two-branch/api/v9-analysis-service.ts

@@ -16,8 +16,8 @@
 
 import { groupIssues } from '../utils/issue-grouping';
 import { SkillScoreManager } from '../analyzers/v9-skill-score-manager';
+// SESSION 112: V9GroupedReportFormatter is now the only formatter
 import { V9GroupedReportFormatter } from '../analyzers/v9-grouped-report-formatter';
-import { V9ReportFormatterFinal } from '../analyzers/v9-report-formatter';
 import { ModelConfigResolver } from '../../standard/orchestrator/model-config-resolver';
 import { enrichIssuesWithAI } from '../report/ai-enrichment';
 
@@ -42,6 +42,7 @@ export interface CompileReportInput {
 }
 
 export interface CompileReportOptions {
+  /** @deprecated SESSION 112: Always uses grouped report now */
   useGroupedReport?: boolean;
   modelConfigResolver?: ModelConfigResolver;
   detectedLanguage?: string;
@@ -93,7 +94,8 @@ export async function compileV9Report(
   console.log(`[DEBUG-PR#] ======================================\n`);
 
   const {
-    useGroupedReport = true,
+    // SESSION 112: useGroupedReport is deprecated, always true
+    useGroupedReport: _useGroupedReportDeprecated = true,
     modelConfigResolver,
     detectedLanguage = 'unknown',
     detectedRepoSize = 'medium',
@@ -503,11 +505,12 @@ export async function compileV9Report(
   // Add team members (placeholder - requires Supabase)
   completeMetadata.teamMembers = discoverTeamFromGit(['/tmp/kafka-repo']);
 
-  // Generate report
+  // Generate report - SESSION 112: Always use V9GroupedReportFormatter
   let markdown: string;
   let reportAttachments: any = {};
 
-  if (useGroupedReport) {
+  // Always use grouped report (V9ReportFormatterFinal is deprecated)
+  {
     const allProcessedIssues = [...formattedNewIssues, ...formattedExistingIssues, ...formattedResolvedIssues];
 
     // BUG #89 DEBUG: Check categories in allProcessedIssues
@@ -581,16 +584,15 @@ export async function compileV9Report(
       ideFixFiles: result.ideFixFiles,
       mapping: result.mapping
     };
-  } else {
-    const fullFormatter = new V9ReportFormatterFinal();
-    markdown = await fullFormatter.generateCompleteReport(analysisResult, completeMetadata, detectedLanguage);
   }
+  // SESSION 112: Removed else branch - V9ReportFormatterFinal is deprecated
 
   return {
     analysisResult,
     completeMetadata: {
       ...completeMetadata,
-      ...(useGroupedReport && reportAttachments ? {
+      // SESSION 112: Always include attachments (grouped report is always used)
+      ...(reportAttachments ? {
         attachments: reportAttachments.locationAttachments,
         ideFixFiles: reportAttachments.ideFixFiles,
         issueGroupMapping: reportAttachments.mapping