Deep Dive: The Internals of JetBrains IDEA 2026's New AI Code Completion and GitHub Copilot 2026

package com.jetbrains.ai.completion.context;

import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiImportStatement;
import com.intellij.psi.Document;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.openapi.editor.DocumentEvent;
import com.intellij.openapi.editor.DocumentEventManager;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;

public class ProjectContextExtractor {
    private static final int MAX_CONTEXT_TOKENS = 32_000;
    private static final int PSI_TRAVERSAL_TIMEOUT_MS = 500;
    private final Project project;
    private final ContextCache contextCache;

    public ProjectContextExtractor(@NotNull Project project) {
        this.project = project;
        this.contextCache = ContextCache.getInstance(project);
    }

    /**
     * Extracts up to 32k tokens of project-relevant context for AI completion,
     * prioritizing recent edits, open file imports, and type hierarchies for the current offset.
     *
     * @param currentFile The active PSI file being edited
     * @param offset The current cursor offset in the file
     * @return List of context strings, truncated to MAX_CONTEXT_TOKENS
     * @throws ContextExtractionException if PSI traversal times out or fails
     */
    @NotNull
    public List extractContext(@NotNull PsiFile currentFile, int offset) throws ContextExtractionException {
        List contextChunks = new ArrayList<>();
        // Check cache first to avoid redundant PSI traversal
        String cacheKey = generateCacheKey(currentFile, offset);
        List cachedContext = contextCache.get(cacheKey);
        if (cachedContext != null) {
            return cachedContext;
        }

        try {
            // Step 1: Extract recent edit history (last 10 edits, max 8k tokens)
            List editHistory = extractRecentEdits(currentFile, offset);
            contextChunks.addAll(editHistory);

            // Step 2: Extract import statements from current file (max 2k tokens)
            List imports = extractImports(currentFile);
            contextChunks.addAll(imports);

            // Step 3: Extract type hierarchy for the element at cursor (max 4k tokens)
            PsiElement elementAtCursor = currentFile.findElementAt(offset);
            if (elementAtCursor != null) {
                List typeHierarchy = extractTypeHierarchy(elementAtCursor);
                contextChunks.addAll(typeHierarchy);
            }

            // Step 4: Add open file content (max 18k remaining tokens)
            String openFileContent = currentFile.getText();
            contextChunks.add(truncateToTokenLimit(openFileContent, MAX_CONTEXT_TOKENS - countTokens(contextChunks)));

            // Truncate to max token limit
            List truncatedContext = truncateContextToLimit(contextChunks, MAX_CONTEXT_TOKENS);
            // Cache for 500ms to align with IDEA's completion debounce
            contextCache.put(cacheKey, truncatedContext, 500, TimeUnit.MILLISECONDS);
            return truncatedContext;
        } catch (TimeoutException e) {
            throw new ContextExtractionException("PSI traversal timed out after " + PSI_TRAVERSAL_TIMEOUT_MS + "ms", e);
        } catch (Exception e) {
            throw new ContextExtractionException("Failed to extract project context", e);
        }
    }

    private List extractRecentEdits(PsiFile file, int offset) {
        List edits = new ArrayList<>();
        Document document = file.getViewProvider().getDocument();
        if (document == null) {
            return edits;
        }
        // Get last 10 document modifications, sorted by timestamp descending
        List recentEvents = DocumentEventManager.getInstance(project).getRecentEvents(document, 10);
        for (DocumentEvent event : recentEvents) {
            if (event.getNewFragment().length() > 0) {
                edits.add(event.getNewFragment().toString());
            } else if (event.getOldFragment().length() > 0) {
                edits.add("REMOVED: " + event.getOldFragment().toString());
            }
        }
        return edits;
    }

    private List extractImports(PsiFile file) {
        // Uses PsiImportList to extract all import statements
        return PsiTreeUtil.findChildrenOfType(file, PsiImportStatement.class)
                .stream()
                .map(PsiElement::getText)
                .collect(Collectors.toList());
    }

    private List extractTypeHierarchy(PsiElement element) {
        List hierarchy = new ArrayList<>();
        PsiClass containingClass = PsiTreeUtil.getParentOfType(element, PsiClass.class);
        if (containingClass == null) {
            return hierarchy;
        }
        int depth = 0;
        PsiClass current = containingClass;
        while (current != null && depth < 5) {
            hierarchy.add("CLASS: " + current.getQualifiedName());
            // Add interfaces
            for (PsiClass iface : current.getInterfaces()) {
                hierarchy.add("IMPLEMENTS: " + iface.getQualifiedName());
            }
            current = current.getSuperClass();
            depth++;
        }
        return hierarchy;
    }

    private String generateCacheKey(PsiFile file, int offset) {
        return file.getVirtualFile().getPath() + ":" + offset + ":" + file.getModificationStamp();
    }

    private int countTokens(List chunks) {
        // Uses JetBrains' internal tokenizer, approximates 1 token = 4 chars for simplicity
        return chunks.stream().mapToInt(s -> s.length() / 4).sum();
    }

    private List truncateContextToLimit(List chunks, int maxTokens) {
        List result = new ArrayList<>();
        int currentTokens = 0;
        for (String chunk : chunks) {
            int chunkTokens = chunk.length() / 4;
            if (currentTokens + chunkTokens > maxTokens) {
                int remaining = maxTokens - currentTokens;
                result.add(chunk.substring(0, remaining * 4));
                break;
            }
            result.add(chunk);
            currentTokens += chunkTokens;
        }
        return result;
    }

    private String truncateToTokenLimit(String input, int maxTokens) {
        if (input.length() / 4 <= maxTokens) {
            return input;
        }
        return input.substring(0, maxTokens * 4);
    }

    public static class ContextExtractionException extends Exception {
        public ContextExtractionException(String message, Throwable cause) {
            super(message, cause);
        }
    }
}

import time
import json
import subprocess
import sys
from typing import List, Dict, Optional
from dataclasses import dataclass
import requests
from requests.exceptions import RequestException, Timeout

@dataclass
class CompletionResult:
    tool: str
    latency_ms: float
    suggestion: str
    is_valid_syntax: bool
    context_tokens: int

class Copilot2026Benchmark:
    def __init__(self, github_token: str):
        self.github_token = github_token
        self.api_url = "https://api.github.com/copilot/v3/generate"
        self.headers = {
            "Authorization": f"token {github_token}",
            "Content-Type": "application/json",
            "X-Request-Id": "copilot-benchmark-2026"
        }

    def generate_completion(self, prompt: str, context: List[str]) -> Optional[CompletionResult]:
        payload = {
            "prompt": prompt,
            "context": context,
            "max_tokens": 50,
            "temperature": 0.1,
            "stream": False
        }
        start_time = time.perf_counter()
        try:
            response = requests.post(
                self.api_url,
                headers=self.headers,
                json=payload,
                timeout=10  # Copilot 2026 has 10s max timeout per request
            )
            end_time = time.perf_counter()
            latency_ms = (end_time - start_time) * 1000
            if response.status_code != 200:
                print(f"Copilot API error: {response.status_code} {response.text}", file=sys.stderr)
                return None
            response_data = response.json()
            suggestion = response_data.get("choices", [{}])[0].get("text", "")
            # Simple syntax validation for Python: try to compile
            is_valid = False
            try:
                compile(suggestion, "", "exec")
                is_valid = True
            except SyntaxError:
                pass
            return CompletionResult(
                tool="GitHub Copilot 2026",
                latency_ms=latency_ms,
                suggestion=suggestion,
                is_valid_syntax=is_valid,
                context_tokens=len(json.dumps(context)) // 4  # Approx 4 chars per token
            )
        except Timeout:
            print("Copilot request timed out after 10s", file=sys.stderr)
            return CompletionResult(
                tool="GitHub Copilot 2026",
                latency_ms=10000,
                suggestion="",
                is_valid_syntax=False,
                context_tokens=0
            )
        except RequestException as e:
            print(f"Copilot request failed: {e}", file=sys.stderr)
            return None

class IDEA2026AIBenchmark:
    def __init__(self, idea_path: str):
        self.idea_path = idea_path  # Path to IDEA 2026 EAP installation
        self.completion_script = "benchmark_completion.py"  # Script to run inside IDEA

    def generate_completion(self, prompt: str, context: List[str]) -> Optional[CompletionResult]:
        # Use IDEA's headless mode to trigger completion and capture output
        context_file = "benchmark_context.json"
        with open(context_file, "w") as f:
            json.dump({"prompt": prompt, "context": context}, f)
        start_time = time.perf_counter()
        try:
            result = subprocess.run(
                [
                    f"{self.idea_path}/bin/idea.sh",
                    "benchmark",
                    "--headless",
                    f"--context-file={context_file}",
                    "--output-format=json"
                ],
                capture_output=True,
                text=True,
                timeout=30
            )
            end_time = time.perf_counter()
            latency_ms = (end_time - start_time) * 1000
            if result.returncode != 0:
                print(f"IDEA benchmark failed: {result.stderr}", file=sys.stderr)
                return None
            output = json.loads(result.stdout)
            suggestion = output.get("suggestion", "")
            is_valid = output.get("is_valid_syntax", False)
            return CompletionResult(
                tool="JetBrains IDEA 2026 AI",
                latency_ms=latency_ms,
                suggestion=suggestion,
                is_valid_syntax=is_valid,
                context_tokens=output.get("context_tokens", 0)
            )
        except subprocess.TimeoutExpired:
            print("IDEA benchmark timed out after 30s", file=sys.stderr)
            return None
        except Exception as e:
            print(f"IDEA benchmark error: {e}", file=sys.stderr)
            return None

def run_benchmark(prompt: str, context: List[str], copilot: Copilot2026Benchmark, idea: IDEA2026AIBenchmark, iterations: int = 10) -> Dict[str, List[CompletionResult]]:
    results = {"copilot": [], "idea": []}
    for _ in range(iterations):
        # Run Copilot
        copilot_result = copilot.generate_completion(prompt, context)
        if copilot_result:
            results["copilot"].append(copilot_result)
        # Run IDEA
        idea_result = idea.generate_completion(prompt, context)
        if idea_result:
            results["idea"].append(idea_result)
        time.sleep(1)  # Avoid rate limiting
    return results

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: python benchmark.py  ", file=sys.stderr)
        sys.exit(1)
    github_token = sys.argv[1]
    idea_path = sys.argv[2]
    copilot = Copilot2026Benchmark(github_token)
    idea = IDEA2026AIBenchmark(idea_path)
    test_prompt = "def calculate_average(numbers):"
    test_context = [
        "import typing",
        "from typing import List, Optional",
        "def sum_numbers(nums: List[int]) -> int:",
        "    return sum(nums)"
    ]
    print("Running benchmark...")
    results = run_benchmark(test_prompt, test_context, copilot, idea, iterations=10)
    print(json.dumps(results, indent=2))

package com.github.copilot.intellij.completion

import com.intellij.openapi.diagnostic.Logger
import com.intellij.psi.PsiFile
import com.intellij.psi.codeStyle.CodeStyleManager
import com.jetbrains.python.psi.PyFile
import org.jetbrains.kotlin.psi.KtFile
import java.util.concurrent.atomic.AtomicInteger

/**
 * Client-side suggestion filter for GitHub Copilot 2026 IntelliJ plugin.
 * Filters out syntax-invalid suggestions and ranks by project-specific acceptance history.
 */
class CopilotSuggestionFilter {
    companion object {
        private val LOG = Logger.getInstance(CopilotSuggestionFilter::class.java)
        private const val MAX_SUGGESTIONS_TO_RETURN = 3
        private const val SYNTAX_CHECK_TIMEOUT_MS = 200
    }

    private val acceptanceCache = CopilotAcceptanceCache.getInstance()
    private val syntaxChecker = SyntaxChecker()

    /**
     * Filters and ranks raw Copilot suggestions for a given file and offset.
     *
     * @param rawSuggestions List of raw suggestion strings from Copilot API
     * @param file The active PSI file being edited
     * @param offset Current cursor offset
     * @return Top 3 filtered and ranked suggestions
     */
    fun filterSuggestions(
        rawSuggestions: List,
        file: PsiFile,
        offset: Int
    ): List {
        if (rawSuggestions.isEmpty()) {
            LOG.warn("No raw suggestions to filter")
            return emptyList()
        }

        val filteredSuggestions = mutableListOf()

        for ((index, suggestion) in rawSuggestions.withIndex()) {
            // Step 1: Check syntax validity
            val syntaxValid = syntaxChecker.isSyntaxValid(suggestion, file, SYNTAX_CHECK_TIMEOUT_MS)
            if (!syntaxValid) {
                LOG.debug("Suggestion $index rejected: invalid syntax")
                continue
            }

            // Step 2: Calculate acceptance score from cache
            val acceptanceScore = acceptanceCache.getScore(suggestion, file.language.id)
            if (acceptanceScore < 0.1) { // Reject suggestions with <10% historical acceptance
                LOG.debug("Suggestion $index rejected: low acceptance score $acceptanceScore")
                continue
            }

            // Step 3: Calculate relevance score based on offset match
            val relevanceScore = calculateRelevanceScore(suggestion, file, offset)
            val totalScore = (acceptanceScore * 0.7) + (relevanceScore * 0.3)

            filteredSuggestions.add(RankedSuggestion(suggestion, totalScore, index))
        }

        // Sort by total score descending, then original index ascending
        filteredSuggestions.sortWith(compareByDescending { it.totalScore }.thenBy { it.originalIndex })

        // Return top N suggestions
        return filteredSuggestions.take(MAX_SUGGESTIONS_TO_RETURN).map { it.text }
    }

    private fun calculateRelevanceScore(suggestion: String, file: PsiFile, offset: Int): Double {
        // Score based on how well the suggestion matches the current file's style
        return when (file) {
            is KtFile -> {
                // Check if suggestion uses Kotlin idioms (e.g., let/run, null safety)
                val idioms = listOf("?.", "?:", "let {", "run {")
                idioms.count { suggestion.contains(it) } / idioms.size.toDouble()
            }
            is PyFile -> {
                // Check if suggestion follows PEP8 (e.g., snake_case, no semicolons)
                val hasSemicolon = suggestion.contains(";")
                val isSnakeCase = suggestion.split(" ").none { it.contains(Regex("[A-Z]")) }
                if (hasSemicolon) 0.0 else if (isSnakeCase) 1.0 else 0.5
            }
            else -> 0.5 // Neutral score for unknown languages
        }
    }

    /**
     * Data class to hold ranked suggestion metadata
     */
    private data class RankedSuggestion(
        val text: String,
        val totalScore: Double,
        val originalIndex: Int
    )

    /**
     * Simple syntax checker with timeout support
     */
    private class SyntaxChecker {
        fun isSyntaxValid(suggestion: String, file: PsiFile, timeoutMs: Long): Boolean {
            return try {
                val tempFile = file.copy() as PsiFile
                tempFile.setText(tempFile.text + suggestion)
                // Run syntax validation via IDEA's internal checker
                val errors = tempFile.checkFileSyntax()
                errors.isEmpty()
            } catch (e: Exception) {
                LOG.warn("Syntax check failed for suggestion: ${e.message}")
                false
            }
        }
    }
}

// Custom Spring Boot context contributor for IDEA 2026 AI
public class SpringBootContextContributor extends BaseContextContributor {
    @Override
    public void contributeContext(@NotNull ContextContributionRequest request, @NotNull ContextSink sink) {
        PsiFile file = request.getFile();
        if (!(file instanceof JavaFile || file instanceof KtFile)) {
            return;
        }
        // Extract Spring stereotype annotations
        List springAnnotations = PsiTreeUtil.findChildrenOfType(file, PsiAnnotation.class)
                .stream()
                .map(PsiAnnotation::getQualifiedName)
                .filter(name -> name != null && (name.contains("org.springframework") || name.contains("jakarta.persistence")))
                .distinct()
                .collect(Collectors.toList());
        if (!springAnnotations.isEmpty()) {
            sink.addContextChunk("SPRING_ANNOTATIONS: " + String.join(", ", springAnnotations), 2000); // 2k tokens
        }
        // Extract OpenAPI spec from local cache if available
        VirtualFile openApiSpec = request.getProject().getBaseDir().findFileByRelativePath("src/main/resources/openapi.yaml");
        if (openApiSpec != null) {
            try {
                String specContent = VfsUtilCore.loadText(openApiSpec);
                sink.addContextChunk("OPENAPI_SPEC: " + specContent, 5000); // 5k tokens
            } catch (IOException e) {
                LOG.warn("Failed to load OpenAPI spec", e);
            }
        }
    }
}

// Context pre-filter for Copilot 2026 IntelliJ plugin
public class CopilotContextPreFilter {
    private static final int MAX_CONTEXT_LINES = 50;
    private static final int MAX_IMPORT_TOKENS = 1000;

    public List filterContext(PsiFile file, int offset) {
        List filteredContext = new ArrayList<>();
        // Add imports first (max 1k tokens)
        List imports = PsiTreeUtil.findChildrenOfType(file, PsiImportStatement.class)
                .stream()
                .map(PsiElement::getText)
                .collect(Collectors.toList());
        int importTokens = imports.stream().mapToInt(s -> s.length() / 4).sum();
        if (importTokens <= MAX_IMPORT_TOKENS) {
            filteredContext.addAll(imports);
        } else {
            filteredContext.addAll(imports.subList(0, (int) (imports.size() * (MAX_IMPORT_TOKENS / (double) importTokens))));
        }
        // Add last 50 lines of current file
        String fileText = file.getText();
        String[] lines = fileText.split("\n");
        int startLine = Math.max(0, lines.length - MAX_CONTEXT_LINES);
        String lastLines = String.join("\n", Arrays.copyOfRange(lines, startLine, lines.length));
        filteredContext.add(lastLines);
        // Add current method body if available
        PsiElement elementAtCursor = file.findElementAt(offset);
        PsiMethod currentMethod = PsiTreeUtil.getParentOfType(elementAtCursor, PsiMethod.class);
        if (currentMethod != null) {
            filteredContext.add("CURRENT_METHOD: " + currentMethod.getText());
        }
        return filteredContext;
    }
}

# Run completion benchmark against your own codebase
git clone https://github.com/jetbrains/completion-benchmark
cd completion-benchmark
pip install -r requirements.txt
export GITHUB_TOKEN="your_copilot_token"
export IDEA_PATH="/opt/jetbrains/idea-2026-eap"
python benchmark.py \
  --codebase-path ./your-project \
  --tools idea,copilot \
  --iterations 100 \
  --output report.json \
  --prometheus-port 9090