This repository is the Python implementation of PowerView, a comprehensive Active Directory (AD) security assessment and exploitation tool. It provides a feature-rich CLI (with an interactive shell), a web-based UI (Flask + vanilla JS), and a Model Context Protocol (MCP) server for AI agent integration. The tool enumerates AD objects (users, groups, computers, GPOs, trusts, certificates, DNS, SMB shares, etc.), identifies security vulnerabilities (kerberoasting, AS-REP roasting, shadow credentials, ACL abuse, certificate template misconfigurations), and supports active exploitation (DACL modification, RBCD, coercion attacks, SMB file operations). It is designed for red team operations and AD security audits. The architecture is a monolith centered on a large `PowerView` class (in `powerview.py`) that orchestrates all commands and dispatches to specialized modules (e.g., `kerberoast.py`, `ca.py`, `exchange.py`, `ldapattack.py`). It supports both standard LDAP and a custom implementation of Microsoft's Active Directory Web Services (ADWS) protocol (SOAP over .NET Message Framing and NegotiateStream), enabling operations without conventional LDAP. The tool leverages Impacket for low-level Windows protocols (SMB, RPC, Kerberos) and includes a plugin system with decorator-based registration and before/after hooks. The web front-end offers interactive graph visualization, object exploration, and real-time command history, while the MCP server exposes AD operations to AI assistants. Key data flows involve LDAP/ADWS queries for object enumeration, SMB/RPC sessions for remote system interaction, and Kerberos tickets for authentication attacks. External dependencies include `ldap3` (forked), `impacket` (forked), `dsinternals`, `flask`, `werkzeug`, and client-side libraries (Cytoscape.js, Alpine.js, Tailwind CSS). The codebase is large and tightly coupled in places, but the custom ADWS implementation, plugin system, and vulnerability detection engine are notable achievements that could be extracted and reused.
A Django library that replaces the standard Django admin interface with a modern, responsive Bootstrap 5 theme. It provides a custom AdminSite with automatic model registration, configurable sidebar menus, form tabs, enhanced list filters (input, dropdown, multiple choice), changelist page size selector, and collapsible inlines. It also integrates AI features (translation, summarization, correction, image generation, vision/alt-text, tag suggestions) by proxying requests to an external API (`baton.sqrt64.it`). The architecture is a monolithic Django reusable app with a Webpack-based JavaScript frontend. It is actively maintained and supports Django 4.2 through 6.1.
This repository implements the Facebook Open Switching System (FBOSS), a production network switch operating system used in Meta's data centers. The codebase controls and manages network switches by running a software agent on each switch that programs hardware forwarding ASICs, implements control-plane protocols (ARP, NDP, LLDP, LACP), and provides Thrift-based APIs for external routing controllers. It encompasses a distributed architecture with multiple daemons: the core agent (SwSwitch, HwSwitch), a state database (FSDB) that publishes/subscribes to operational state and stats, a CLI (fboss2) with a trait-driven command framework, platform services (fan, sensor, LED, QSFP transceiver management, firmware updates), and extensive hardware abstraction layers for Broadcom BCM and SAI-based ASICs. A significant portion of the codebase supports multiple switch platforms (Wedge, Minipack, Meru, Janga, etc.) with platform-specific mappings, LED managers, and test harnesses. The open-source release includes OSS stubs for internal Meta features, SDK version conditionals, and a build system based on getdeps.py/FB code builder.
A Python CLI tool for searching, downloading, and organizing doujinshi (self-published manga) from configurable mirror sites. The architecture uses a plugin system defined via abstract base classes (BaseParser, BaseModel, BaseSerializer, BasePlugin) and discovered through Python entry points, allowing support for multiple sites (e.g., nhentai) without modifying the core code. The core package handles CLI argument parsing, asynchronous image downloading via httpx/asyncio with retry and proxy support, export to CBZ/PDF/ZIP, generation of HTML viewers for local browsing, and SQLite-based download history tracking. The codebase is well-structured with clear separation between core utilities and plugin-specific logic, though it contains duplicated viewer template files that indicate incomplete cleanup.
HyperView is a CLI-driven toolkit for downloading TradingView market data, backtesting Python trading strategies with TradingView-parity fill assumptions, and optimizing parameters via Bayesian search (Optuna). The system is organized as a monolith with subcommands: download-data, backtest, hyperopt, pine-optimize, pine-batch-optimize, list-data, list-strategies. It features a pluggable strategy framework with auto-discovery, 20+ TA-Lib indicator wrappers, a backtester that simulates intrabar SL/TP paths, and a two-stage Pine input optimizer that exports optimized Pine scripts with injected best parameters. The codebase is well-structured with dataclasses, type hints, and a rich CLI output using the `rich` library. It includes unit tests for the Pine optimization pipeline and CLI parser. The repository is primarily an application, though it contains data engineering patterns in its downloader and caching layers.
Vaadin Hilla is a full-stack web framework that bridges a Java (Spring Boot) backend with a TypeScript (React/Lit) frontend. Its primary function is to automatically generate TypeScript client code—including type-safe endpoints, form models, and reactive state signals—directly from annotated Java classes. The framework provides a complete ecosystem for building modern web applications, encompassing CRUD UI components (AutoGrid, AutoForm), authentication/authorization hooks, file-based routing, and internationalization support, all integrated with standard Java build tools (Maven, Gradle). The architecture is a monorepo managed by Nx, containing Java packages for the backend runtime and code generation engine, and TypeScript packages for the frontend libraries. The core innovation is a sophisticated code generation pipeline: a plugin-based parser walks Java classes to build an intermediate model, which is then rendered into TypeScript by dedicated writers. This pipeline handles complex Java features like generics, polymorphism (Jackson subtypes), and nullability annotations, translating them into idiomatic TypeScript. While the framework demonstrates strong engineering with a well-abstracted plugin system, clean service interfaces, and elegant client-side model builders, it carries notable technical debt. The codebase relies on a custom fork of Jackson, has deprecated APIs (e.g., legacy @Nonnull/@Nullable annotations), and contains experimental features (reactive signals) with disabled tests and duplicate test files indicating incomplete migrations. Despite these issues, the core architecture is sound and the framework is actively maintained by the Vaadin team.
This repository is a collection of competitive programming solutions and learning resources accumulated during interview preparation for a Microsoft SWE role. It contains implementations of algorithms and data structures from platforms like LeetCode, HackerRank, CodeChef, and others, organized by problem source and topic. The repository serves as both a personal record of solved problems and a reference for common coding interview patterns. The codebase consists of standalone solution files that implement specific algorithms to solve well-defined problems. Rather than a unified application, it's an educational repository where each file represents a self-contained solution to a particular coding challenge. The solutions demonstrate various techniques including two-pointer approaches, stack-based algorithms, in-place array modifications, and thread synchronization patterns. While the repository doesn't contain a single cohesive software system, it does include several reusable algorithmic patterns that could be extracted for use in other projects. Notable examples include the stack-based parentheses validation, two-pointer technique for sorted arrays, in-place array modification algorithms, and thread coordination mechanisms using Events and Semaphores. These components represent fundamental computer science concepts implemented with attention to correctness and efficiency.
go-chromecast is a mature Go CLI and HTTP API server for controlling Google Chromecast and Google Home devices over a local network. It discovers devices via mDNS (zeroconf browsing of _googlecast._tcp), connects to them over TLS port 8009 speaking the Cast V2 protocol (length-prefixed protobuf frames carrying JSON payloads on connection/receiver/media namespaces), and exposes a full command surface: load/queue media, playlist management, volume/mute, seek/rewind, playback rate, skip-ad, slideshow, status polling, and event watching. For local media files it spins up an embedded HTTP streaming server that the cast device pulls from, with optional ffmpeg transcoding to MP4 for unrecognized formats, and it can convert subtitles (srt/ass/embedded) to WebVTT via ffmpeg on the fly. Playback position history is persisted to a JSON cache for playlist resume. A REST API layer (GET/POST /devices, /connect, /status, /pause, /volume, /load, etc.) and a gocui-based terminal UI wrap the same core application logic. Optional Google Cloud Text-to-Speech integration enables casting spoken text as an MP3 stream. The architecture is cleanly package-separated: cast/ implements the low-level protocol transport (TLS dial, binary framing, PING/PONG heartbeat, async receive loop), application/ is a large orchestration layer implementing the App interface (state tracking, request/response correlation keyed by request ID, media streaming server, playlist resume), dns/ handles mDNS discovery with robust decoding of malformed UTF-8 escapes in TXT records, cmd/ wires cobra subcommands, http/ provides the REST facade with errgroup-based concurrent status aggregation, and ui/ provides the TUI with an extensible JSON theme system. Testing is decent: unit tests with testify/mockery mocks, testscript-based CLI integration tests, and CI across Go 1.21-1.24 on Linux/macOS. Notable weaknesses: the Application struct is an overgrown god-object mixing transport, state, and HTTP serving; startStreamingServer and startTranscodingServer are near-identical copy-paste; and the --with-ui path in the playlist, load-app, and transcode commands double-executes the load operation after the UI exits (load.go correctly returns, the others fall through). Deprecated ioutil usage and the dormant gocui dependency indicate minor drift, but the Go module and cloud dependencies are current.
Fireproof is a local-first, real-time document database with CRDT-based conflict resolution, end-to-end encryption, and multi-platform support (browser, Node.js, Deno, Cloudflare Workers). The monorepo contains the core database engine (`@fireproof/core`), a cloud sync backend (Hono + Durable Objects), a dashboard web application for tenant/ledger management, a CLI tool for build and DevOps tasks, and a React hooks library (`use-fireproof`). The architecture is modular with clear separation between storage gateways (IndexedDB, filesystem, memory, cloud), key management (KeyBag with fingerprinting), device identity (X.509-like PKI), and protocol layers (WebSocket/HTTP message dispatch). The codebase exhibits strong engineering practices including extensive TypeScript usage, comprehensive testing (though some tests are skipped or known to fail), and reusable patterns like the Gateway interceptor, Result type, and Evento command pipeline. However, complexity is high due to multiple runtime targets and active refactoring between versions, and there are known critical bugs (e.g., remote sync not triggering subscriptions in React hooks).
The Flask-DebugToolbar is a Flask extension that provides a debug toolbar with various panels for debugging purposes. It includes features such as syntax highlighting, line numbers, and bracket matching.
Promptomatix is a framework for automating and optimizing large language model (LLM) prompts through iterative refinement. It provides both CLI and API interfaces for users to input task descriptions, generate synthetic data, optimize prompts using DSPy or meta-prompt backends, and evaluate results with custom metrics. The system features modular architecture separating language model management, configuration, session tracking, feedback handling, and metrics evaluation. Key workflows include prompt optimization with feedback incorporation, batch processing capabilities, and extensibility for custom metrics and optimization backends. The framework targets researchers and developers seeking to reduce manual prompt engineering effort while improving LLM output consistency and quality.
This is a VS Code extension that provides comprehensive Terraform language support by integrating the terraform-ls language server. It offers syntax highlighting, IntelliSense, code navigation, formatting, validation, and deep integration with HCP Terraform (formerly Terraform Cloud) for viewing workspaces, runs, plans, and applies directly within the editor. The extension manages the lifecycle of the language server binary and communicates with HCP Terraform via a typed API client built on Zodios. It also includes an optional MCP server for AI-assisted code generation and a telemetry system for feature usage and error reporting. The codebase follows a modular structure with separate features, commands, providers, and API layers, demonstrating solid engineering practices for a VS Code extension.
gimme-aws-creds is a Python CLI tool for obtaining temporary AWS and Alibaba Cloud credentials via Okta SAML authentication. It supports both Okta Classic and Identity Engine flows, handles multiple MFA methods (push, TOTP, hardware tokens, SMS, email, FIDO2/WebAuthn, Duo), and exchanges SAML assertions for temporary cloud credentials. The tool outputs credentials in various formats (export, JSON, Windows PowerShell) or writes them to standard credential files (~/.aws/credentials, ~/.aliyun/config.json). The application features a modular architecture with separate modules for Okta authentication (okta_classic.py, okta_identity_engine.py), cloud provider resolution (aws.py, alibaba_cloud.py), configuration management (config.py), MFA handling (duo.py, u2f.py, webauthn.py), and shared utilities (common.py, ui.py, debug_formatter.py). Key entry points include bin/gimme-aws-creds (main executable) and platform-specific wrappers. Data flows involve parsing configuration/authentication options, performing Okta authentication with MFA, extracting SAML assertions, assuming cloud roles via STS APIs, and formatting output. Notable reusable components include a flexible configuration system with inheritance and source tracking (config.py), isolated SAML parsing utilities (common.py), a UI abstraction layer for testability (ui.py), and a secure HTTP logging formatter that automatically redacts sensitive data (debug_formatter.py). The project is actively maintained but shows medium technical drift due to platform-specific WebAuthn dependencies requiring older Python versions on Windows and the complexity of maintaining compatibility with multiple authentication systems and cloud providers.
This repository is a pure Python library implementing elliptic curve cryptography algorithms, specifically ECDSA (Elliptic Curve Digital Signature Algorithm), ECDH (Elliptic Curve Diffie-Hellman), and EdDSA (Edwards-curve Digital Signature Algorithm). It provides key generation, signing, verification, and shared secret derivation functionalities across multiple curve types including NIST prime curves, Brainpool curves, and twisted Edwards curves (Ed25519/Ed448). The library is structured as a modular package with clear separation of concerns: high-level API in `keys.py`, low-level arithmetic in `ellipticcurve.py`, curve definitions in `curves.py`, ASN.1 DER handling in `der.py`, and utility functions for encoding/decoding in `util.py`. While the code is well-structured and includes comprehensive test suites, the project explicitly states it is not designed for production security due to vulnerability to side-channel attacks, recommending wrappers like `pyca/cryptography` for sensitive applications.
Arkit is a static analysis tool that generates architecture diagrams from JavaScript, TypeScript, Flow, Vue, and Nuxt codebases. It analyzes source code to extract component dependencies (imports/exports) and produces visual diagrams in PlantUML, SVG, or PNG formats. The tool is designed for CI/CD pipelines and local development, with a focus on producing meaningful, committable architecture documentation that stays in sync with the codebase. The architecture follows a pipeline pattern: CLI or programmatic entry point → configuration loading (merging CLI options, config files, and defaults) → file system scanning with ts-morph → parsing of imports/exports → component and dependency graph generation → PlantUML text generation → conversion to SVG/PNG via local Java PlantUML or an optional WASM GraphViz backend. The tool supports configurable component grouping, output paths, and diagram directions. Key features include automatic detection of module systems (ESM, CommonJS, TypeScript path aliases), support for Vue single-file components and Angular templates, configurable exclude patterns, and a JSON schema for editor autocomplete. The codebase is well-tested with Jest, includes CI/CD via GitHub Actions, and provides both a CLI and a programmatic API.
mdless is a Ruby-based command-line utility that renders Markdown files with syntax highlighting, formatting, and pager functionality. It acts as a 'less' replacement for Markdown, offering features like syntax highlighting via Pygments, image rendering with imgcat/chafa, table formatting, and support for TaskPaper syntax. The application processes input from files or stdin, applies Markdown parsing via Redcarpet, and outputs formatted terminal-ready text with ANSI color codes. It includes configurable themes, optional pager usage, and various output customization options. The codebase shows consistent maintenance with recent commits and demonstrates thoughtful handling of terminal rendering complexities.
cdk-dia is a CLI tool that automatically generates architecture diagrams from AWS CDK synthesized tree.json files. It parses the CDK construct tree, identifies CloudFormation resources and their references (Ref, Fn::GetAtt, Fn::ImportValue), builds a hierarchical diagram model, and renders it via Graphviz (PNG) or Cytoscape (interactive HTML). The tool supports collapsing groups, ignoring resources, cross-stack edge resolution, and custom diagram styling through construct attributes. It is a well-architected Node.js library with a clean separation of parsing, diagram generation, and rendering layers. The codebase demonstrates strong engineering practices with abstract component trees, customizable attributes, and extensive snapshot testing against real-world CDK app fixtures.
PageEyes Agent is a production-grade Python framework for natural-language-driven UI automation, published on PyPI as `page-eyes` (v1.3.9). It provides LLM agents that perceive screens and execute actions (click, input, swipe, assert) across Web (Playwright), Android (ADB), iOS (WebDriverAgent), HarmonyOS (hdc), and Electron (CDP). The core architecture separates a PlanningAgent that decomposes user instructions into atomic steps from per-platform execution agents that call tools through Pydantic AI's tool-calling framework. Screen perception is delegated either to a vision-language model in lightweight mode or to the bundled OmniParser2 service in full mode. Each run produces a self-contained HTML report with step logs, screenshots, element bounding-box overlays, and video, which can be uploaded to COS or MinIO. The repo is hybrid: it is primarily an application framework but embeds a significant ML-serving sub-project, OmniParser2, which is a FastAPI microservice running PaddleOCR for text detection, a fine-tuned YOLOv11n for icon detection, a LoRA-fine-tuned Florence-2 model for icon captioning, and a YOLO overlay detector for popups/loading states, with optional Milvus-based image caching. Model weights and tokenizer artifacts (including a ~96k-token BPE merges file) are committed to the repository, and the docs include detailed articles on Florence-2 LoRA fine-tuning and YOLO overlay detection, giving the repo a data-research flavor alongside its application character. The codebase shows genuine engineering skill: a generic Device abstraction with factory methods, a storage strategy pattern (COS/MinIO/Base64), a reusable skills system (e.g., gui-popup-handler), and an agent loop with planning/execution/reflection separation. CI/CD, tests, a changelog, and mkdocs documentation are present. Weaknesses include heavy ML dependencies with override conflicts, a committed binary blob (yadb), code duplication between the main package and OmniParser2, and coupling to Tencent-internal infrastructure (mirror URLs, email addresses, platform names), which limits external portability.
discrawl is a Go CLI application for archiving and searching Discord data. It syncs messages from the Discord API, imports Discord desktop cache, stores raw JSON in SQLite via sqlc-generated code, and provides subcommands for sync, publish, subscribe, share import, and remote status. It also exports/imports compressed JSONL snapshots with manifests and commits them to a Git snapshot repo using NUL-delimited path-only commits to preserve unrelated staged work. The repository is primarily an application, but it also vendors agent skills (autoreview, crabbox, discrawl) under .agents/skills, making it a hybrid monorepo.
Compressor is a native Android video compression application built with Kotlin and Jetpack Compose (Material3). It leverages Android's Media3 Transformer API for hardware-accelerated encoding, supporting H.265/HEVC, H.264, and AV1 codecs. The app follows an MVVM architecture with a single-activity design, state-driven UI managed by CompressorUiState, and declarative navigation via AnimatedContent. It provides a rich set of features including target size presets (e.g., Discord 20MB, GitHub 10MB), quality presets, auto-adjust algorithm to scale resolution/framerate/bitrate, and device-specific workarounds for various SoCs (MediaTek, Huawei, Pixel 10 HDR). The UI includes a config screen with tabs for presets, video, and audio options, a settings screen with sub-settings for display, video, audio, presets, and about, and a filename builder with drag-and-drop tokens. The app is fully localized in 10+ languages via Crowdin, has no internet or storage permissions, and provides reproducible builds. The codebase demonstrates solid engineering practices: clean separation of concerns with model, viewmodel, and UI components; custom theming with a harmonized green palette; reusable UI components like InfoCard, CheckboxRow, SelectionChip; and utility classes for hardware detection, motion effects, and audio processing. The auto-adjust algorithm and device workarounds show deep understanding of Android video encoding quirks. However, the CompressorViewModel is large and handles many responsibilities, and test coverage is minimal, focusing mainly on unit tests for utilities and ViewModel. The app is actively maintained with CI workflows, Dependabot, and issue templates. Overall, Compressor is a well-crafted application that solves a specific problem (video compression on Android) with a focus on performance and user experience. It is not a data research project; it is purely an application with no data pipelines or analytics.