The antlr/intellij-plugin-v4 repository is an IntelliJ IDEA plugin that provides comprehensive language support for ANTLR v4 grammar files (.g4). It offers syntax highlighting, real-time error checking, code navigation, refactoring capabilities (such as rule extraction and inlining), live parse tree preview, grammar profiling, and code generation. The plugin integrates deeply with the IntelliJ Platform SDK, implementing extension points like FileTypeFactory, ParserDefinition, SyntaxHighlighterFactory, ExternalAnnotator, StructureViewFactory, CompletionContributor, and custom tool windows. Its architecture follows a modular design where core functionality is separated into concerns such as parsing, preview, refactoring, and configuration, utilizing patterns like the adaptor pattern for ANTLR integration, background processing for UI responsiveness, and specialized token streams for incremental parsing.
TeXiFy-IDEA is an IntelliJ IDEA plugin that provides comprehensive LaTeX editing support. It enhances the IntelliJ Platform with features including syntax highlighting, code completion, inspections, refactoring intentions, build execution (supporting pdfLaTeX, XeLaTeX, LuaLaTeX, latexmk, biber), forward/inverse search with PDF viewers, bibliography management (local BibTeX and remote libraries like Zotero/Mendeley), and project structure visualization. The plugin follows IntelliJ Platform SDK conventions with a modular architecture organized around concerns like actions, editing, grammar, indexing, PSI, run configurations, settings, structure view, utilities, and remote library integration. It demonstrates strong software engineering practices through patterns like step-based execution systems, PDF viewer abstraction, magic comment parsing, Kotlin DSL builders for command definitions, and generic caching mechanisms. The plugin is actively maintained with recent commits, regular version updates, dependency management via Dependabot, and comprehensive testing.
This repository is the open-source 'Rainbow Brackets Lite' IntelliJ IDEA plugin, a free and feature-limited version of the popular Rainbow Brackets plugin. The plugin colorizes nested brackets (round, square, squiggly, angle) with distinct colors to improve code readability, and provides additional features like rainbow indent guide lines and scope highlighting via mouse shortcuts. It is implemented as a JetBrains plugin using the IntelliJ Platform SDK, with core logic split between an Annotator (for simple leaf-elements) and a HighlightVisitor (for more accurate per-language matching via BracePairProvider extension points). The architecture follows standard IntelliJ plugin patterns: extension points for brace providers, custom text attributes, and a thorough settings UI integrated into the IDE's color scheme page. The codebase is well-structured with proper separation of concerns, utility functions (memoization, color blending), and comprehensive tests for multiple languages. While tightly coupled to the IntelliJ API, several components (BracePairProvider interface, memoization utility, color blending) demonstrate non-obvious skill and could be extracted for reuse in other JetBrains plugins or JVM projects.
This repository is the JetBrains Godot Support plugin, a multi-language IDE extension for IntelliJ IDEA and Rider that provides comprehensive GDScript language intelligence, scene editing, debugging, and project integration for the Godot game engine. It consists of several modules: a Kotlin-based GDScript language plugin with custom lexer/parser, PSI, annotations, inspections, refactoring, formatting, code completion, and LSP client; a C# debugger worker that allows inspecting Godot scenes during debugging with optimized bulk-fetch strategies; a C++ native addon (GDExtension) for bidirectional communication between the IDE and Godot editor; a PHP toolchain to generate SDK metadata from Godot's official XML documentation; and .NET ReSharper components for C# Godot project support. The plugin uses JetBrains' PolySymbols framework for unified symbol resolution and has an extensive test suite covering parsing, type inference, inspections, and debugger integration. While deeply integrated with JetBrains platform APIs and generated code, the debugger worker's child-chunking algorithm and SDK fingerprinting utility are well-crafted, self-contained components that could be reused in other contexts. The codebase is actively maintained with regular commits, but relies on several internal/experimental APIs and snapshot dependencies, posing moderate technical drift risk.
AutoDev is a multi-platform AI-powered coding assistant that integrates with IntelliJ IDEA and VS Code, and also runs as a standalone desktop app, CLI, web app, and mobile app. Its core engine is a Kotlin Multiplatform (KMP) agent framework that orchestrates LLM calls, tool execution (file I/O, shell, web fetch, MCP servers), and code generation/refactoring. The architecture is modular: `mpp-core` provides shared agent logic, tool schemas, linters, and document parsing; IDE-specific plugins (`mpp-idea`, `mpp-vscode`) deliver chat panels, inline completions, code review, and database integration; `mpp-ui` is a Compose Multiplatform frontend for desktop/CLI/mobile; `mpp-server` is a Ktor-based remote agent server; `xiuper-ui` implements a novel spec-driven UI DSL (NanoDSL) for rendering agent output as interactive components. The system supports multiple LLM providers (OpenAI, Anthropic, Google, GitHub Copilot, etc.), MCP protocol for tool integration, and A2A (agent-to-agent) communication. It includes a custom DSL (DevIns/Shire) for defining agent behaviors, completions, and variable resolution. While primarily an application, it includes data processing components like code graph parsing, document indexing, NLP tokenization, and heuristic scoring models, giving it a hybrid character. The codebase is large and actively developed, with frequent releases and a rich set of features, though some platform-specific implementations are stubs and there is moderate technical drift from deprecated APIs and naming inconsistencies.
ProxyAI (formerly CodeGPT) is a JetBrains IDE plugin that provides AI-powered code assistance including chat, inline editing, code completions, agent-based task execution, commit message generation, and next-edit suggestions. The plugin integrates with multiple LLM providers (OpenAI, Anthropic, Google, Mistral, Ollama, llama.cpp, custom OpenAI-compatible, and its own ProxyAI cloud) and supports local inference via a bundled llama.cpp submodule. It implements an agent framework with a tool system (read, write, edit, bash, web search, diagnostics, debugger control), MCP (Model Context Protocol) client for external tool servers, and ACP (Agent Client Protocol) for external agent integration. The architecture follows IntelliJ Platform conventions: services, actions, tool windows, settings via PersistentStateComponent, and editor listeners. The codebase is a mix of Kotlin (dominant) and Java, with Gradle build system and extensive use of coroutines for async operations.
The JetBrains MCP Proxy Server is a Node.js application that acts as a middleware between MCP-compatible clients (such as Claude Desktop or VS Code) and JetBrains IDEs equipped with the MCP Server plugin. It discovers the IDE's MCP endpoint by scanning a predefined port range (63342-63352) or using a specified IDE_PORT environment variable, caches the endpoint, and periodically verifies its availability. The proxy then exposes an MCP server over stdio, forwarding tool listing and tool invocation requests to the IDE's HTTP-based MCP endpoint. The implementation uses the Model Context Protocol SDK for stdio communication and node-fetch for HTTP requests, featuring error handling, logging, and endpoint caching with periodic refresh.
Preview.js is a developer tool for live component previews integrated into IDEs (VS Code, IntelliJ) and available as a CLI. It analyzes source code to detect UI components and Storybook stories, extracts their props via a custom TypeScript type analyzer, and renders them in an isolated iframe powered by Vite with Hot Module Replacement. The system consists of a core server library (`@previewjs/core`), framework-specific plugins (React, Preact, Solid, Svelte, Vue 2/3), a virtual file system abstraction, and a type analysis engine. It targets frontend developers who want instant visual feedback on component changes without leaving their editor. The project is explicitly **no longer maintained** per the README, and the codebase shows signs of technical drift with outdated test apps and potential dependency stagnation. Despite its abandonment, the architecture is well-structured: a monorepo with clear separation of concerns (loader/worker pattern for isolate Vite servers, iframe controller, screenshot generator, serializable value handling). The type analyzer and virtual filesystem are reusable components that demonstrate non-obvious skill with TypeScript compiler API and abstract file access patterns.