This repository implements a WakaTime language server extension for the Zed editor. It consists of two Rust crates: a Zed extension (src/lib.rs) that manages downloading and launching the wakatime-ls language server and the wakatime-cli binary, and the language server itself (wakatime-ls/src/main.rs) that translates editor document events (open, change, save) into heartbeats sent to the WakaTime API via the external CLI. The extension uses Zed's extension API for lifecycle management and binary caching, while the language server is built with tower-lsp and tokio, providing robust async handling of LSP notifications. The architecture is a clean plugin-plus-LSP design where the extension is a thin orchestrator and the language server does the actual event processing and API communication. The codebase is well-structured, uses modern Rust patterns, and includes CI/CD configuration for cross-platform releases.
Android Code Studio (formerly AndroidIDE) is a full-featured Integrated Development Environment (IDE) designed to run natively on Android devices. It enables users to write, compile, and debug Android and Java applications directly on mobile hardware. The architecture is a modular monolith built with Kotlin and Java, utilizing a composite build system to bundle critical dependencies like the OpenJDK compiler, Logback, and XML parsers directly into the application rather than relying on external Maven repositories. Key functionality includes a custom code editor powered by Tree-sitter, a Language Server Protocol (LSP) implementation for Java and XML, a UI Designer for visual layout editing, and a terminal integration via Termux.
This repository is a monorepo implementing a Language Server Protocol (LSP) integration for JupyterLab, consisting of a Python backend (`jupyter-lsp`) and a TypeScript frontend (`jupyterlab-lsp`). The backend manages multiple language server processes (Python, R, Julia, bash, SQL, etc.) via WebSocket proxying, file system shadowing for disk-based servers, and configurable spec discovery. The frontend provides LSP features (autocompletion, diagnostics, hover, jump-to-definition, rename, signature help, syntax highlighting) as JupyterLab plugins, with custom CodeMirror 6 extensions, a diagnostics panel, and a status bar. The architecture includes virtual documents for notebook cells with IPython magic handling, foreign code extraction (e.g., `%%R`, `%%sql`), and a settings schema system that dynamically populates language server configuration UIs. The codebase is well-tested with Python unit tests, TypeScript unit tests, and Robot Framework acceptance tests running in CI. While the core functionality is robust, there is moderate technical drift due to reliance on undocumented JupyterLab internal APIs, fragile regex-based magic parsing, and some deprecated language server specifications.
Dingo is a source-to-source transpiler for a custom language that extends Go with Rust-inspired features like sum types (enums), pattern matching, error propagation (`?`), safe navigation (`?.`), null coalescing (`??`), lambdas, tuples, and functional utilities (Option/Result). The transpiled output is clean, idiomatic Go with zero runtime overhead. The repository includes a full CLI tool (`dingo`) with build, run, fmt, lint, and update commands, as well as a language server (`dingo-lsp`) that wraps gopls as a proxy and uses source maps (`.dmap` binary format) for position translation. Editor integrations cover VS Code, Neovim, and JetBrains. The codebase is organized as a monolith with a modular plugin architecture for AST transformations. While actively developed and containing several well-crafted reusable components (source map binary format, error formatting with carets and suggestions, concurrent type cache, animated terminal mascot), the project shows signs of architectural fragmentation: duplicate parser implementations, a legacy preprocessor coexisting with a newer AST pipeline, multiple skipped tests, and known incomplete features tracked in TODOs. The scope is ambitious — many language features are implemented but the overall coherence suffers from incremental AI-assisted development patterns visible in the extensive ai-docs archive.
colorful-menu.nvim is a Neovim plugin that enhances completion menus by providing Tree-sitter based syntax highlighting for completion items. It reconstructs context-aware code snippets from LSP completion data (e.g., turning a variable completion into 'var name Type') and applies semantic highlighting. The plugin integrates with nvim-cmp, blink.cmp, and Neovim's native LSP completion through well-defined entry points. Its architecture separates concerns: utility functions handle Tree-sitter parsing and text manipulation, language-specific modules implement reconstruction logic for various LSPs (gopls, rust-analyzer, etc.), and the core module coordinates these components. The plugin demonstrates strong text processing capabilities, particularly in its highlight range adjustment and truncation logic that preserves semantic highlighting during text modifications.
This is the idris2-lsp language server, a monolithic LSP server implementation for the Idris2 programming language. It provides standard IDE features such as go-to-definition, hover information, code completions, document symbols, semantic tokens, diagnostics, and various code actions including case splitting, expression search, and refactoring. It runs as a single process reading JSON-RPC messages from stdin and writing responses to stdout, leveraging the Idris2 compiler's API to load modules, resolve names, and perform type-checking. The server is built with Idris2 itself and depends on the lsp-lib library for LSP message types and encoding. While the codebase is well-crafted for its domain, it is tightly coupled to Idris2 internals and the LSP protocol, making it highly specific to the Idris ecosystem and not easily reusable outside that context.