This is a VS Code extension that provides language support for the Crystal programming language. It offers syntax highlighting, code snippets, formatting, hover information showing types, jump-to-definition, problem detection, symbol navigation, macro expansion viewing, and test integration. The extension interacts with the Crystal compiler and shards package manager through CLI tools to provide these features. The architecture is modular with separate TypeScript files handling different concerns (completion, definitions, hover, formatting, tasks, etc.), coordinated through a main extension.ts file. It uses a mutex to prevent concurrent compiler tool usage and properly handles error cases and platform differences.
The Ada Language Server (ALS) is a Language Server Protocol implementation providing IDE features for Ada and SPARK programming languages. It consists of a core server written in Ada that handles language intelligence features (completion, diagnostics, refactoring, etc.) and a VS Code extension written in TypeScript that integrates with the editor. The architecture follows a client-server model where the language server communicates with editor clients via JSON-RPC. Key components include the Ada-based LSP server implementing standard LSP capabilities plus Ada-specific extensions, the VS Code extension providing editor integration, and a comprehensive test suite validating LSP compliance. The project shows active maintenance with regular commits, clear build systems, and dependency management through Alire.
This repository is the official AWS Toolkit extension for Visual Studio Code, providing deep integration with Amazon Web Services directly within the IDE. It enables developers to browse and manage AWS resources (S3, Lambda, CloudFormation, EC2, ECS, IoT, and dozens more), invoke Lambda functions, deploy serverless applications using AWS SAM, debug Lambda functions locally, and access Amazon Q (formerly CodeWhisperer) for AI-powered code suggestions, chat, security scanning, and code transformation. The codebase is a large monorepo organized into packages including the core extension logic, generated streaming API clients, a custom ESLint plugin, and webview-based UIs built with Vue.js. The architecture follows a modular activation pattern with centralized command registration, tree view providers for resource exploration, a wizard/prompter framework for multi-step user flows, and a telemetry system for operational metrics. It supports both Node.js and web (browser) extension targets. Despite its size, the codebase maintains consistent patterns, extensive test coverage, and clear separation of concerns, making it a well-crafted enterprise-grade IDE extension.
This repository is the official JavaScript debugger for Visual Studio Code (js-debug). It implements a full Debug Adapter Protocol (DAP) server that communicates with JavaScript runtimes via the Chrome DevTools Protocol (CDP). The debugger supports Node.js, Chrome, Edge, WebView2, VS Code extension hosts, Blazor, and WebAssembly (with DWARF symbols). The architecture is modular, with a core adapter layer handling breakpoints, source maps, evaluation, and console output; target-specific launchers for Node and browser processes; a UI layer providing VS Code commands, configuration providers, and profiling tools; and extensive telemetry and diagnostics infrastructure. Key entry points include the VS Code extension activation (`src/extension.ts`) and a standalone DAP server (`src/debugServerMain.ts`). The codebase uses dependency injection (Inversify), custom event emitters, and source map management with caching and rename support. External dependencies include `ws` (WebSocket), `got` (HTTP), `acorn`/`astring` (JavaScript parsing/code generation), and `@jridgewell/trace-mapping` (source map resolution). While primarily an application, it includes a diagnostic tool webview and telemetry for operational analysis.
This repository is the official Visual Studio Code extension for PowerShell (published as ms-vscode.PowerShell). It provides rich language support including IntelliSense, code navigation, formatting, PSScriptAnalyzer linting, debugging with a custom debug adapter, integrated PowerShell console, Pester test runner, ISE compatibility mode, command explorer, help view, alias expansion, remote file editing, and language model tools for AI copilot integration. The extension acts as a Language Server Protocol (LSP) client that communicates with the external PowerShellEditorServices server, and uses the Debug Adapter Protocol for debugging. It supports all major platforms (Windows, macOS, Linux) and multiple PowerShell editions (stable, preview, daily, etc.). The architecture follows a modular feature-class pattern under `src/features/`, with a central `SessionManager` handling the PowerShell process lifecycle and language client connection. The extension is well-tested with unit and integration tests across CI, and its code demonstrates solid TypeScript patterns, clean separation of concerns, and reusable abstractions such as `LanguageClientConsumer` for async LSP client access and `PowerShellExeFinder` for cross-platform PowerShell discovery. While the codebase is actively maintained and keeps pace with VS Code API changes, it contains some deprecated settings and minor complexity in session management. Overall, it is a professional-grade VS Code extension with a few genuinely reusable components that could benefit other extensions or tools dealing with PowerShell or LSP clients.
This is the Spring Tools 4 (STS4) repository, a comprehensive set of IDE tooling for Spring Boot development. It provides language servers (LSP) for Spring Boot (Java, YAML, properties, XML), Concourse CI, BOSH, and Cloud Foundry manifests, along with Eclipse plugins and VS Code extensions. The architecture separates headless language servers (built as Spring Boot applications) from IDE-specific frontends, with shared commons libraries for YAML, Java project indexing, metadata, and live process monitoring via Actuator. The codebase is professional and well-structured but shows signs of organic growth over a decade, with some code duplication between the Eclipse and headless/VS Code paths, deprecated API usage, and developer-specific hardcoded paths. It is actively maintained by VMware/Spring engineering team with strong CI/CD pipelines.
This is a VS Code extension that provides a unified interface for discovering, installing, and managing MCP (Model Context Protocol) servers and AI agent skills. It integrates with multiple sources: the Official MCP Registry, skills.sh, GitHub repositories, and CloudMCP (a hosted alternative). The extension offers a chat participant (`@mcp`) for natural-language search and install, and a sidebar webview with search and management tabs. It supports 30+ AI coding agents including GitHub Copilot, Claude Code, and Codex CLI. The architecture consists of a TypeScript extension backend (using esbuild for bundling) and a React 19 + Vite + Tailwind CSS + shadcn/ui frontend, communicating via typed RPC messages. Telemetry is collected anonymously with standardized error classification. The codebase is well-structured with clear separation of concerns, CI/CD pipelines, and unit tests.
This repository is the monorepo for Cherry Markdown, a rich, extensible WYSIWYG markdown editor library developed by Tencent. The core package (`packages/cherry-markdown`) provides a modular parsing engine with a plugin-based syntax hook system, a comprehensive toolbar, streaming rendering for AI chat, and support for diagrams (Mermaid, PlantUML, ECharts), math (KaTeX/MathJax), tables, and code blocks. The repository also includes a desktop client built with Tauri (Vue 3 + Pinia + Rust) that adds file management, local versioning, and native integrations; a VS Code extension; a WeChat Mini Program renderer; and various example applications. The architecture is well-structured with clear separation of concerns (engine, previewer, editor, toolbar, addons), extensive unit tests, and a consistent event-driven pattern. While the core library is JavaScript with JSDoc types, the client and plugins are TypeScript. Some technical drift exists due to vendored third-party assets (e.g., drawio library), a partially implemented Milkdown adapter, and a few deprecated code paths. Overall, this is a mature, actively maintained editor framework with high reusability in its hook system, utility classes, and composable patterns.
This is a VS Code extension that provides an enhanced markdown preview with live updates, scroll sync, diagram rendering (Mermaid, PlantUML, Vega, etc.), math typesetting (KaTeX/MathJax), wikilinks, backlinks, graph view, AI translation, and multiple export formats (HTML, PDF, Pandoc, etc.). The architecture is a monolithic extension with a central PreviewProvider class managing webview panels, backed by the crossnote library for markdown processing. It registers over 30 commands and multiple VS Code providers (hover, completion, document link, custom editor, graph view). The codebase is well-structured with TypeScript, has CI/CD pipelines, and demonstrates good engineering practices such as mutex-based singletons, request sequencing, and CSP generation. However, the PreviewProvider class is large (~1200 lines) and handles many responsibilities, indicating potential for modularization. The extension is actively maintained with frequent releases and security fixes.
This repository is a Visual Studio Code extension that provides a comprehensive file and folder icon theme using the Catppuccin pastel color palette. It offers icons for over 300 file types and numerous folder types, split across four flavor variants (Latte, Frappé, Macchiato, Mocha). The extension is built with TypeScript and modern tooling (tsup, pnpm, eslint), featuring a modular architecture with separate concerns for configuration, icon compilation, theme generation, and build scripts. Users can customize settings such as monochrome mode, specific folder icons, and custom associations via VS Code settings. The codebase is well-structured, actively maintained, and includes CI/CD pipelines, integrity checks, and preview generation scripts.
MDV (Markdown Data & Visualization) is a tool that extends CommonMark Markdown with front-matter, fenced code blocks for charts/tables/stats, `:::` container directives for layout and styled regions, and auto-generated table of contents. It parses `.mdv` files and renders them to self-contained HTML with inline SVG charts (bar, line, pie) and CSS themes, requiring no JavaScript runtime in the output. The project is a TypeScript monorepo with three packages: `@mdv/core` (parser and renderer library), `@mdv/cli` (CLI with render, preview, and PDF export commands), and `mdv-vscode` (VS Code extension providing live side-by-side preview). The parser uses `markdown-it` as a base with a fence-aware preprocessor that handles `:::` directives and HTML comments correctly within code blocks. The renderer is designed for robustness: errors never crash the document, invalid front-matter renders a fatal banner, and chart data validation produces inline error messages. Security measures include escaping raw HTML, sanitizing style values, and preventing path traversal in data file references. The CLI supports live preview with file watching and auto-reload, and PDF export via headless Chromium (Puppeteer). The VS Code extension provides a debounced live preview that also refreshes on data file changes.
This repository contains the GitHub Copilot Chat extension for Visual Studio Code. It provides an AI-powered coding assistant with multiple interaction modes: inline code completions (ghost text), chat conversations, inline edits, next-edit suggestions, and agent-based tool orchestration. The extension supports multiple AI model providers (OpenAI, Anthropic, Google Gemini, xAI, and bring-your-own-key endpoints) and includes a sophisticated prompt engineering system using JSX-based prompt elements. It integrates deeply with VS Code through dozens of proposed APIs, and features a layered architecture (common/node/vscode) with dependency injection, telemetry, and a simulation test framework. While the README states the project has moved to the main VS Code repository, the codebase shows active development with recent commits and extensive feature work.
POML (Prompt Orchestration Markup Language) is a developer toolchain for structured, reusable LLM prompt engineering. It provides an HTML-like markup language with semantic components, CSS-like styling, templating (variables, loops, conditionals), and multimodal data integration (PDFs, images, tables). The repository contains a core TypeScript/React SDK, a Python wrapper with OpenAI/LangChain/MLflow integrations, a VS Code extension (LSP, live preview, test command), and a Chrome browser extension for content extraction. It is packaged as CLI tools and libraries on npm and PyPI. Designed for building maintainable prompts in LLM applications, it also includes research artifacts (arXiv papers) and a tracing system for debugging prompt execution.
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.
This repository implements a Language Server Protocol (LSP) server for the Stimulus JavaScript framework, providing intelligent tooling for editors like VS Code. The architecture follows a standard client/server LSP pattern where the TypeScript-based VS Code extension (client) communicates with a TypeScript language server (server) via JSON-RPC. The server parses HTML, ERB, Blade, PHP, and JavaScript/TypeScript files to offer Stimulus-specific features: autocompletion for controllers/actions/targets, diagnostics for incorrect usage, code actions for quick fixes, and code navigation. Key capabilities include validating Stimulus controller existence, action correctness, and proper data attribute usage, with intelligent suggestions for corrections.
LapisCV is a collection of Markdown-based resume templates and styling assets designed for use with Obsidian, Typora, and VSCode. It provides a base CSS file (main.css) that defines the core resume styling using CSS variables for easy theming, along with platform-specific overrides to adapt to each editor's rendering engine. Users edit the provided Markdown templates to create their resumes and export to PDF using their editor's built-in or plugin-based PDF export functionality. The project includes a Makefile to build distribution packages for each supported platform.
Roo Code is an AI coding assistant extension for Visual Studio Code that provides AI-powered code generation, explanation, refactoring, and debugging capabilities. It integrates with multiple LLM providers (OpenAI, Anthropic, Google Gemini, etc.) through a well-designed abstraction layer. The application features different modes (Code, Architect, Ask, Debug, Custom) for various tasks, file operations through AI, terminal integration, MCP (Model Context Protocol) support for extensible tooling, task persistence, and a chat interface for interacting with AI models. Built as a monorepo with pnpm workspaces, it consists of a core extension, webview-based UI, CLI application, and documentation site. While the original team has moved on to another project (Roomote), the README indicates a community team has stepped up to maintain and improve Roo Code.
EIDE (Embedded IDE) is a VS Code extension for embedded microcontroller development, supporting a wide range of architectures (8051, STM8, Cortex-M, RISC-V, MIPS) and toolchains (GCC, Arm Compiler, IAR, SDCC, COSMIC, LLVM). It provides project management (create, import from Keil/IAR/Eclipse), build system integration, flash programming (JLink, STLink, OpenOCD, pyOCD, probe-rs), and analysis tools (callgraph visualization, stack usage, memory map, CMSIS pack management). The extension includes a web-based configuration UI, a Model Context Protocol (MCP) server for headless tool access, and custom language support for embedded assembly/linker scripts. The architecture is a VS Code extension with TypeScript core, Vue.js webviews, and platform-specific .NET binaries for build/flash operations. While deeply functional and feature-rich, the codebase exhibits some monolithic files, vendored outdated dependencies (Bootstrap 4.3.1, Vue 2.6), and a high degree of coupling between project management and UI logic.
AREPL is a VS Code extension that evaluates Python code in real-time as you type, displaying variables, errors, and print output in a side panel. It provides a scratchpad-like experience for Python development, with features like real-time evaluation, variable inspection, error display, and support for dumping variables from functions. The extension uses a Python backend (arepl-backend npm package) to execute code and communicate results via JSON. The TypeScript architecture includes a PreviewManager that orchestrates execution and preview updates, a PreviewContainer that manages the webview, and separate modules for inline errors (PythonInlinePreview) and panel display (PythonPanelPreview). The codebase is well-structured with clear separation of concerns, includes unit tests (mocha), and uses telemetry for diagnostics. The extension is maintained (last release November 2024) and uses modern dependencies.
This is a VS Code extension that enables users to easily insert gitmojis (emojis related to git commits) into commit messages. The extension activates via a command or SCM menu item, presents an emoji picker, and inserts the selected emoji at a configurable position (start, end, or cursor) in the commit message. It features smart handling of existing emojis (removing them when repeats aren't allowed), usage-based sorting, auto-matching based on commit message content, and support for custom emojis. The architecture follows standard VS Code extension patterns with clear separation between UI logic, data (emoji definitions), and utility functions.