Enhance coverage reporting with JaCoCo analysis in JSON format

- CoverageService now parses .exec files using JaCoCo API and produces
  structured JSON output (matching mcp-jacoco-reporter format)
- Reports per-class: nocovered lines, partiallycovered lines, branch info
- Analyzes all workspace Java projects for complete coverage picture
- Add optional Import-Package for org.jacoco.core packages
- Falls back to basic file path output when JaCoCo is unavailable

Author: jcompagner

plugins/com.github.gradusnikov.eclipse.plugin.assistai.main/META-INF/MANIFEST.MF

@@ -118,4 +118,7 @@ Import-Package: com.fasterxml.jackson.core;version="[2.21.0,3.0.0)",
  org.reactivestreams;version="[1.0.0,2.0.0)",
  reactor.core.publisher;version="[3.8.0,4.0.0)",
  reactor.core.scheduler;version="[3.8.0,4.0.0)",
- reactor.util.context;version="[3.8.0,4.0.0)"
+ reactor.util.context;version="[3.8.0,4.0.0)",
+ org.jacoco.core.analysis;resolution:=optional,
+ org.jacoco.core.data;resolution:=optional,
+ org.jacoco.core.tools;resolution:=optional

plugins/com.github.gradusnikov.eclipse.plugin.assistai.main/src/com/github/gradusnikov/eclipse/assistai/mcp/services/CoverageService.java

@@ -1,13 +1,28 @@
 package com.github.gradusnikov.eclipse.assistai.mcp.services;
 
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
 
+import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.ILog;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.e4.core.di.annotations.Creatable;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.jacoco.core.analysis.Analyzer;
+import org.jacoco.core.analysis.CoverageBuilder;
+import org.jacoco.core.analysis.IClassCoverage;
+import org.jacoco.core.analysis.ICounter;
+import org.jacoco.core.analysis.IPackageCoverage;
+import org.jacoco.core.data.ExecutionDataReader;
+import org.jacoco.core.data.ExecutionDataStore;
+import org.jacoco.core.data.SessionInfoStore;
 
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
@@ -72,15 +87,239 @@ public String findLatestCoverageFile()
     }
 
     public String formatCoverageInfo( String execFilePath )
+    {
+        return formatCoverageInfo( execFilePath, null );
+    }
+
+    public String formatCoverageInfo( String execFilePath, String projectName )
     {
         if ( execFilePath == null )
         {
             return "";
         }
+
+        if ( projectName != null )
+        {
+            try
+            {
+                return analyzeCoverage( execFilePath, projectName );
+            }
+            catch ( Exception e )
+            {
+                logger.error( "Error analyzing coverage data, falling back to basic info", e );
+            }
+        }
+
         StringBuilder sb = new StringBuilder();
         sb.append( "\n--- Coverage ---\n" );
         sb.append( "Coverage data collected. View in Eclipse via Coverage view.\n" );
         sb.append( "Coverage data file: " ).append( execFilePath ).append( "\n" );
         return sb.toString();
     }
+
+    private String analyzeCoverage( String execFilePath, String projectName ) throws Exception
+    {
+        ExecutionDataStore executionDataStore = new ExecutionDataStore();
+        SessionInfoStore sessionInfoStore = new SessionInfoStore();
+
+        try ( FileInputStream fis = new FileInputStream( execFilePath ) )
+        {
+            ExecutionDataReader reader = new ExecutionDataReader( fis );
+            reader.setExecutionDataVisitor( executionDataStore );
+            reader.setSessionInfoVisitor( sessionInfoStore );
+            reader.read();
+        }
+
+        CoverageBuilder coverageBuilder = new CoverageBuilder();
+        Analyzer analyzer = new Analyzer( executionDataStore, coverageBuilder );
+
+        IProject[] allProjects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
+        for ( IProject project : allProjects )
+        {
+            if ( !project.isOpen() || !project.hasNature( JavaCore.NATURE_ID ) )
+            {
+                continue;
+            }
+            IJavaProject javaProject = JavaCore.create( project );
+            File outputLocation = project.getLocation().append(
+                javaProject.getOutputLocation().removeFirstSegments( 1 ) ).toFile();
+            if ( outputLocation.exists() )
+            {
+                analyzer.analyzeAll( outputLocation );
+            }
+        }
+
+        return formatReport( coverageBuilder, projectName );
+    }
+
+    private String formatReport( CoverageBuilder coverageBuilder, String projectName )
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append( "\n--- Coverage Report ---\n" );
+
+        int totalLines = 0;
+        int coveredLines = 0;
+        int totalBranches = 0;
+        int coveredBranches = 0;
+
+        StringBuilder jsonArray = new StringBuilder();
+        jsonArray.append( "[\n" );
+        boolean first = true;
+
+        for ( IPackageCoverage pkg : coverageBuilder.getBundle( projectName ).getPackages() )
+        {
+            String packageName = pkg.getName().replace( '/', '.' );
+            totalLines += pkg.getLineCounter().getTotalCount();
+            coveredLines += pkg.getLineCounter().getCoveredCount();
+            totalBranches += pkg.getBranchCounter().getTotalCount();
+            coveredBranches += pkg.getBranchCounter().getCoveredCount();
+
+            for ( IClassCoverage cls : pkg.getClasses() )
+            {
+                int clsLines = cls.getLineCounter().getTotalCount();
+                if ( clsLines == 0 ) continue;
+
+                List<Integer> uncoveredLines = new ArrayList<>();
+                List<Integer> partiallyCoveredLines = new ArrayList<>();
+                List<Integer> uncoveredBranchLines = new ArrayList<>();
+                List<Integer> partiallyCoveredBranchLines = new ArrayList<>();
+
+                for ( int i = cls.getFirstLine(); i <= cls.getLastLine(); i++ )
+                {
+                    int lineStatus = cls.getLine( i ).getStatus();
+                    if ( lineStatus == ICounter.NOT_COVERED )
+                    {
+                        uncoveredLines.add( i );
+                    }
+                    else if ( lineStatus == ICounter.PARTLY_COVERED )
+                    {
+                        partiallyCoveredLines.add( i );
+                    }
+
+                    int branchTotal = cls.getLine( i ).getBranchCounter().getTotalCount();
+                    if ( branchTotal > 0 )
+                    {
+                        int branchStatus = cls.getLine( i ).getBranchCounter().getStatus();
+                        if ( branchStatus == ICounter.NOT_COVERED )
+                        {
+                            uncoveredBranchLines.add( i );
+                        }
+                        else if ( branchStatus == ICounter.PARTLY_COVERED )
+                        {
+                            partiallyCoveredBranchLines.add( i );
+                        }
+                    }
+                }
+
+                if ( uncoveredLines.isEmpty() && partiallyCoveredLines.isEmpty()
+                    && uncoveredBranchLines.isEmpty() && partiallyCoveredBranchLines.isEmpty() )
+                {
+                    continue;
+                }
+
+                if ( !first ) jsonArray.append( ",\n" );
+                first = false;
+
+                String sourceFile = cls.getSourceFileName() != null ? cls.getSourceFileName()
+                    : cls.getName().substring( cls.getName().lastIndexOf( '/' ) + 1 ) + ".java";
+
+                jsonArray.append( "  {\n" );
+                jsonArray.append( "    \"sourcefile\": \"" ).append( sourceFile ).append( "\",\n" );
+                jsonArray.append( "    \"package\": \"" ).append( packageName ).append( "\",\n" );
+                jsonArray.append( "    \"lines\": {\n" );
+                jsonArray.append( "      \"nocovered\": " ).append( toJsonArray( uncoveredLines ) ).append( ",\n" );
+                jsonArray.append( "      \"partiallycovered\": " ).append( toJsonArray( partiallyCoveredLines ) ).append( "\n" );
+                jsonArray.append( "    },\n" );
+                jsonArray.append( "    \"branch\": {\n" );
+                jsonArray.append( "      \"nocovered\": " ).append( toJsonArray( uncoveredBranchLines ) ).append( ",\n" );
+                jsonArray.append( "      \"partiallycovered\": " ).append( toJsonArray( partiallyCoveredBranchLines ) ).append( "\n" );
+                jsonArray.append( "    }\n" );
+                jsonArray.append( "  }" );
+            }
+        }
+
+        jsonArray.append( "\n]" );
+
+        if ( totalLines > 0 )
+        {
+            int overallLinePct = (int) ( 100.0 * coveredLines / totalLines );
+            sb.append( "Overall: " ).append( overallLinePct ).append( "% line coverage (" )
+                .append( coveredLines ).append( "/" ).append( totalLines ).append( " lines)" );
+            if ( totalBranches > 0 )
+            {
+                int overallBranchPct = (int) ( 100.0 * coveredBranches / totalBranches );
+                sb.append( ", " ).append( overallBranchPct ).append( "% branch coverage (" )
+                    .append( coveredBranches ).append( "/" ).append( totalBranches ).append( " branches)" );
+            }
+            sb.append( "\n\n" );
+        }
+
+        if ( first )
+        {
+            sb.append( "All classes fully covered.\n" );
+        }
+        else
+        {
+            sb.append( "Classes with incomplete coverage:\n" );
+            sb.append( jsonArray );
+            sb.append( "\n" );
+        }
+
+        return sb.toString();
+    }
+
+    private String toJsonArray( List<Integer> values )
+    {
+        if ( values.isEmpty() ) return "[]";
+        StringBuilder sb = new StringBuilder();
+        sb.append( "[" );
+        for ( int i = 0; i < values.size(); i++ )
+        {
+            if ( i > 0 ) sb.append( ", " );
+            sb.append( values.get( i ) );
+        }
+        sb.append( "]" );
+        return sb.toString();
+    }
+
+    private String formatLineList( List<Integer> lines )
+    {
+        if ( lines.isEmpty() ) return "";
+        if ( lines.size() > 30 )
+        {
+            return lines.size() + " lines";
+        }
+        StringBuilder sb = new StringBuilder();
+        int start = lines.get( 0 );
+        int end = start;
+
+        for ( int i = 1; i < lines.size(); i++ )
+        {
+            if ( lines.get( i ) == end + 1 )
+            {
+                end = lines.get( i );
+            }
+            else
+            {
+                appendRange( sb, start, end );
+                sb.append( ", " );
+                start = lines.get( i );
+                end = start;
+            }
+        }
+        appendRange( sb, start, end );
+        return sb.toString();
+    }
+
+    private void appendRange( StringBuilder sb, int start, int end )
+    {
+        if ( start == end )
+        {
+            sb.append( start );
+        }
+        else
+        {
+            sb.append( start ).append( "-" ).append( end );
+        }
+    }
 }

plugins/com.github.gradusnikov.eclipse.plugin.assistai.main/src/com/github/gradusnikov/eclipse/assistai/mcp/services/PDEService.java

@@ -409,7 +409,7 @@ public void testCaseFinished( ITestCaseElement testCaseElement )
             if ( useCoverage )
             {
                 String execFile = coverageService.findLatestCoverageFile();
-                results += coverageService.formatCoverageInfo( execFile );
+                results += coverageService.formatCoverageInfo( execFile, javaProject.getProject().getName() );
             }
 
             return results;

plugins/com.github.gradusnikov.eclipse.plugin.assistai.main/src/com/github/gradusnikov/eclipse/assistai/mcp/services/UnitTestService.java

@@ -544,7 +544,7 @@ public void testCaseFinished(ITestCaseElement testCaseElement) {
 
                 if (useCoverage) {
                     String execFile = coverageService.findLatestCoverageFile();
-                    results += coverageService.formatCoverageInfo( execFile );
+                    results += coverageService.formatCoverageInfo( execFile, javaProject.getProject().getName() );
                 }
 
                 return results;