This is a comprehensive test automation framework for 1C:Enterprise 8.3 managed applications, named 'Tester'. It provides a full suite of tools for creating, managing, executing, and reporting on UI and business logic test scenarios. The repository contains three main integrated components: (1) a native C++ add-in (addon/) that exposes low-level capabilities like screenshot capture, regex, file watching, metadata parsing, and a Model Context Protocol (MCP) server for AI agent integration; (2) a 1C:Enterprise configuration (tester/) with catalogs, documents, common modules, and forms implementing scenario lifecycle management, execution engine with debugging, job scheduling, error logging, and report generation; and (3) a VS Code extension (addon.vscode/) for editing scenarios with syntax highlighting, code completion, and direct test execution. The system supports distributed execution via agent computers, file system synchronization with external editors (EDT, VS Code), version control through git integration, and role-based access control. Notable patterns include a bilingual API (English/Russian method aliases), a fluent assertion library, a custom JSON diff engine for UI state comparison, and an XML log transpiler that converts recorded user actions into executable scripts. Documentation is extensive, including a separate wiki site built with MkDocs. The repository is actively maintained with frequent releases, though it shows medium technical drift due to some outdated dependencies in the VS Code extension and use of platform-specific workarounds.
This repository is an awesome list of Visual Studio Code extensions and resources, with the README.md serving as the primary product. It does not contain a runnable application but functions as a curated reference guide for developers seeking VS Code extensions. The repository includes a GitHub Actions workflow (links.yml) that automatically validates all links in the README using the awesome_bot tool to prevent link rot. Contributions are governed by strict guidelines ensuring consistent formatting, alphabetical ordering, and inclusion of screenshots/GIFs where possible. While the core content is static, the CI pipeline demonstrates a reusable pattern for documentation maintenance in open-source projects.
This is a Visual Studio Code extension providing comprehensive language support for Garry's Mod Lua (GLua). It delivers syntax highlighting, autocompletion, hover documentation, signature help, go-to-definition, find references, color picker, type hints, file previews (VTF/PNG), workspace scanning, global variable optimization, and a bytecode heatmap generator. The extension is built as a single Node.js process using the VS Code API, with a custom Lua parser (gluaparse) for AST analysis and a bundled gluac binary for LuaJIT bytecode manipulation. It downloads wiki data from a remote server and caches it locally. The codebase is well-organized into providers and commands, but is tightly coupled to the VS Code extension model and Garry's Mod-specific data sources, limiting direct reuse outside this context. A Python-based generator script for scraping the Facepunch wiki is also included as a separate tool.
This repository is a VS Code extension for monitoring and managing AI model quotas (Antigravity/Google Gemini/Claude/etc.). It provides a WebView dashboard and QuickPick view for real-time quota tracking, account management with OAuth authentication, auto-trigger/wakeup functionality to prevent quota exhaustion, and integration with the Cockpit Tools desktop application. The extension features quota grouping, history visualization, threshold-based notifications, multi-account support, and internationalization across 18+ languages. Architecture follows modular VS Code extension patterns with separate controllers, services, and views communicating via event-driven messaging.
This repository is the official Microsoft Visual Studio Code extension for the Black Python code formatter. It provides formatting support for Python files directly within VS Code, including full-document, range, and multi-range formatting, as well as notebook cell formatting. The architecture follows a client-server LSP pattern: a TypeScript extension (client) communicates via stdio or named pipe with a Python LSP server that invokes Black. The server is built on pygls and lsprotocol, with a shared infrastructure library (`@vscode/common-python-lsp`) for common LSP utilities. The extension bundles Black as a dependency and supports flexible configuration (custom paths, interpreters, arguments). It includes comprehensive unit and integration tests for both TypeScript and Python components, with test fixtures covering edge cases like unformatted/formatted pairs, notebook scenarios, and internationalization. While the implementation is solid and follows established patterns for VS Code formatter extensions, it relies heavily on a shared submodule and has some minor version inconsistencies (e.g., outdated minimum version constant in the server code). The project is under active development (pre-release status) with automated CI/CD, dependency management via Dependabot, and AI-assisted workflows for issue triage and template synchronization.
CodeTour is a Visual Studio Code extension for recording and playing guided walkthroughs of codebases. It allows developers to create interactive step-by-step tours associated with files, directories, and specific lines of code, with support for markdown descriptions, code snippets, shell commands, and command links. The extension features a player (comment-based UI, tree view, status bar, gutter markers) and a recorder (comment creation, step management, git ref association, tour export). It integrates with VS Live Share for collaborative tours and exposes an API for other extensions. The architecture is modular with clear separation between player, recorder, store (MobX-based state management), and LiveShare modules. The codebase is well-structured and demonstrates good TypeScript practices, though it lacks automated tests and relies on some experimental VS Code APIs (notebook provider). The project appears to be in a stale maintenance state with the last release in March 2023.
The Kickbacks extension is a VS Code extension that monetizes IDE 'thinking' spinners in Claude Code and Codex by rendering clickable sponsored ads and sharing up to 50% of ad revenue with developers. It operates as a modular TypeScript application with a complex activation orchestrator managing subsystems for authentication, ad rotation, metrics, earnings, kill switch, consent, self-update, and UI components. The extension uses a local loopback server for secure communication between the extension and injected code in webviews/CLI, implements feature flags via sentinel files, and employs OS-native credential storage. Its architecture centers around adapters for Claude Code (webview and CLI) and Codex (webview), with centralized state management and serving gates controlling ad display based on kill switches, user preferences, and canary states. The code demonstrates strong engineering practices in areas like secure token handling, deduplication, and resilience patterns, though it remains tightly coupled to its specific ad-serving backend and third-party tool integrations.
Continue is an open-source AI coding agent that provides chat, autocomplete, edit, and agent capabilities across VS Code, JetBrains IDEs, and a standalone CLI. The architecture centers on a shared TypeScript core (`core/`) that handles LLM interactions, context providers, tool definitions, indexing, and configuration management. This core is consumed by three frontends: a VS Code extension (`extensions/vscode/`), a JetBrains plugin (`extensions/intellij/`), and a CLI (`extensions/cli/`) with a React-based TUI. A separate React GUI (`gui/`) runs as a webview in the IDE extensions. The system supports 50+ LLM providers through a plugin architecture in `core/llm/llms/` and uses a YAML-based configuration system (`packages/config-yaml/`) with a Hub for sharing assistants. Codebase indexing uses a content-addressed Merkle tree approach with a Rust sync library (`sync/`). The repository is now read-only and deprecated as of the final 2.0.0 release, with the team recommending users migrate to the CLI.
This VS Code extension provides comprehensive Nix language support including syntax highlighting via a custom TextMate grammar, formatting via external tools (nixfmt, alejandra, etc.), linting via nix-instantiate, and a language server client supporting nil and nixd. It uses a clean architecture with separate modules for the language client, formatter, linter, and process execution. The extension activates on Nix files and falls back to local formatting/linting when no LSP is enabled. The codebase demonstrates good software engineering practices with TypeScript, unit tests, and continuous integration, though it is tightly coupled to the VS Code extension API and Nix toolchain, limiting reuse outside its domain. The most reusable component is the process-runner module, which encapsulates external command execution with error handling in a workspace-aware manner.
Gitlantis is a VS Code extension that turns the traditional file explorer into an interactive 3D ocean world. Users control a boat to navigate a seascape where directories appear as lighthouses and files as buoys, making code exploration more engaging. The extension communicates via webview with a React Three Fiber interface, offering features like branch switching, file opening, and settings customization. It also supports a standalone browser mode for demo purposes using sample data. Architecturally, the extension consists of a VS Code extension host that handles workspace and Git operations, and a rich webview application built with React 18, Three.js, React Three Fiber/Drei, and Zustand for state management. The 3D scene includes dynamic ocean tiling, boat physics (using React Three Cannon), collision-based node interaction, a compass, minimap, and ambient audio. The UI layer provides splash screens, loading states, settings modals with multiple tabs, and mobile joystick support. The codebase demonstrates modern frontend practices and creative use of 3D in a developer tool. However, it has several maintainability concerns: many @ts-expect-error comments for Three.js types, hardcoded demo data for browser mode, a complex dual-build setup, and no automated tests. Some components, like the settings modal and the dynamic backdrop, are well-abstracted and potentially reusable in other Three.js projects.
This repository is a Visual Studio Code extension for developing, debugging, and simulating Apache Cordova and Ionic mobile applications. It provides a comprehensive debug adapter that supports launching and attaching to Android, iOS, browser, and simulated targets. The extension integrates with the Chrome DevTools Protocol (CDP) via a custom proxy to enable sourcemap rewriting and cross-platform debugging, and it offers IntelliSense for Cordova plugin APIs and Ionic framework components. It also includes commands for building, running, preparing, and cleaning Cordova/Ionic projects, as well as telemetry and localization support across 14 languages. The architecture is modular: the core debug session (`CordovaDebugSession`) delegates to platform-specific implementations (`AndroidPlatform`, `IosPlatform`, `BrowserPlatform`) that inherit from abstract base classes (`AbstractPlatform`, `AbstractMobilePlatform`). A CDP proxy layer (`CordovaCDPProxy`) intercepts and transforms messages between the debugger and the target runtime, with specialized message handlers for Chrome and Safari runtimes. Target management is handled by `MobileTargetManager` subclasses (`AndroidTargetManager`, `IOSTargetManager`) that enumerate devices and emulators. The extension also includes a plugin simulator (`PluginSimulator`) that serves the app via `cordova-simulate` and a Socket.IO connection. Key entry points include the extension activation (`src/extension/cordova-extension.ts`), the debug configuration provider (`src/extension/debugConfigurationProvider.ts`), and the debug session class (`src/debugger/cordovaDebugSession.ts`). External dependencies include the Cordova CLI, Ionic CLI, Android SDK, iOS toolchain (Xcode, ios-webkit-debug-proxy), and npm packages like `cordova-simulate`, `socket.io-client`, and `vscode-js-debug-browsers`. The codebase is written in TypeScript and uses Gulp and Webpack for building. While the extension is functionally complete and well-structured, it shows signs of technical drift: many dependencies are outdated (e.g., `applicationinsights` 0.15.6, `socket.io-client` 2.4.0), the Cordova ecosystem has declined in favor of Capacitor, and the large i18n file set (200+ files) adds maintenance overhead. The code contains some legacy patterns (e.g., `eval` for custom require, extensive use of `any` types) and hardcoded timeouts. Despite this, the core abstractions for platform handling and CDP message processing are well-designed and potentially reusable.
This repository serves as a comprehensive guide and utility for managing Visual Studio Code extensions. It provides a curated list of extensions categorized by functionality (themes, productivity, data science, etc.) with descriptions and screenshots. The repository includes a PowerShell script for bulk installing extensions and a set of tools (Python and Bash) for comparing extension lists between different environments. Additionally, it contains a standalone decision tree implementation in Python, which, while not directly related to the main purpose, demonstrates solid algorithmic implementation. The main value lies in the extension recommendations and the practical scripts for managing VS Code setups, making it a useful reference for developers seeking to enhance their coding environment.
This VS Code extension replaces the built-in TypeScript version with the nightly build of TypeScript (`typescript@next`), providing the latest TypeScript and JavaScript IntelliSense features. It is a small, focused extension that contributes TextMate grammars for JavaScript, TypeScript, JSX, and TSX syntax highlighting, sourced from the Microsoft/TypeScript-TmLanguage repository. The extension is designed for advanced users who want to test upcoming TypeScript features before they are officially released. The codebase is minimal: a package.json defining the extension, a set of grammar JSON files, and build scripts for updating the grammar and version. The CI pipeline (Azure Pipelines) automates the process of pulling the latest TypeScript nightly and publishing the extension. The extension is currently in a maintained state but with reduced activity, as the CI scheduled trigger is disabled to avoid picking up TypeScript 7. The grammars are large, well-structured TextMate definitions that follow standard patterns and are reusable in other editors. The overall codebase is functional and straightforward, but lacks original craftsmanship beyond the grammar modularity.
This repository is Visual Studio Code Void, a deprecated fork of VS Code focused on AI-enhanced desktop editing. While the project is no longer accepting contributions per its README, it contains the core VS Code architecture with additional AI-oriented features in the `src/vs/workbench/contrib/void/` directory. The application provides a code editor experience with syntax highlighting, IntelliSense, debugging, and extension support, built on Electron for desktop with web fallback capabilities. It features a modular architecture with core editor (Monaco), workbench/UI framework, platform services, and extension system, along with a Rust-based CLI for code and tunnel management.