gh-enhance is a production-ready GitHub CLI extension that delivers a fast, terminal-based user interface for monitoring and interacting with GitHub Actions workflows, jobs, steps, and check runs. It is implemented as a single Go binary using the Bubble Tea framework (Elm architecture) with Lipgloss for styling and glamour for markdown rendering, and it supports three display modes: run-level, PR-level, and repository-level. The application authenticates via the GitHub CLI's OAuth token and communicates with the GitHub API through a mix of GraphQL (for PR checks and workflow run steps) and REST (for workflow runs, job logs, and rerun actions). A subprocess call to `gh run view --log --job` retrieves raw job logs, which are then parsed into an interactive, searchable view. The architecture is monolithic but well-structured, with a clean separation between the API layer, the TUI layer, and the data model, and includes a comprehensive test harness with mock API responses and a fake GitHub server for offline testing. It is actively maintained, with a responsive issue tracker and an engaged community on Discord.
callx is a Node.js CLI tool that serves as a unified runtime switcher and configuration manager for AI coding assistants like Claude Code and OpenCode. It allows users to define multiple AI 'sprites' (agent configurations) with different providers, models, skills, and MCP servers, all managed through a single `~/.config/callx` directory. The system provides two entry points: the `call` command for quick invocation of sprites, and `callcli`, a full-featured TUI built with Ink and React for managing providers, sprites, skills, MCP servers, and git worktrees. The architecture is a monolith CLI application with a clear separation between runtime utilities (`lib/runtime.js`), git worktree helpers (`lib/worktree.js`), and the TUI frontend (`lib/callcli/app.mjs`). The runtime module handles all configuration file I/O, provider normalization, skill syncing via symlinks, and MCP server configuration generation for both Claude Code and OpenCode formats. The TUI provides a Monokai-themed interface with list-based navigation, field-level editing, and multi-select for skills and MCP servers. Key data flows include: reading `providers.json` for API keys and endpoints, reading sprite `config.json` for CLI type and model selection, syncing skill packs from `skillpacks/` to sprite-specific `skills/` directories via symlinks, and generating MCP configuration files from `mcpservers/` definitions. The tool also integrates with git worktrees, providing an interactive flow to create new branches and worktrees with suggested naming conventions. External dependencies are minimal: Node.js 18+, Ink and React for the TUI, and the target AI CLI tools (opencode-ai, @anthropic-ai/claude-code).
datafusion-dft (dft) is a batteries-included Rust application that wraps Apache DataFusion into a multi-front-end SQL query and analysis tool. It provides four interfaces sharing one execution core: a scriptable CLI (file/command queries, benchmarking, FlightSQL client mode, CSV/JSON/Parquet/Vortex output), a ratatui terminal UI with SQL editor, paginated results, and history tabs, an Arrow FlightSQL gRPC server with full metadata and prepared-statement support, and an HTTP REST server. The core library (crates/datafusion-app) constructs a DataFusion SessionContext with a trait-based extension plugin system, dedicated CPU/IO executors, statistics collection, and observability hooks.
npkill is a TypeScript CLI/TUI application that scans filesystems to find node_modules (and other ecosystem build/dependency directories) consuming disk space, then interactively or programmatically deletes them. The core engine (Npkill class) exposes RxJS observable streams for scanning, size calculation, newest-file detection, deletion, and logging, with a worker_threads-based parallel directory traversal. The CLI layer adds a raw-mode interactive terminal UI with cursor navigation, multi-select deletion, search filtering, JSON/NDJSON output modes, --dry-run, .npkillrc config file support, and user-defined profiles. It ships both as a bin executable and as a programmatic Node library per API.md.
This is the playit.gg tunnel agent, a production-grade client-side daemon that exposes local servers (e.g., Minecraft, game servers, web services) to the internet through the playit.gg tunnel network. The system is organized as a Rust multi-package workspace comprising five main crates: `agent_core` (tunnel state machine, TCP/UDP proxying, control connection), `playitd` (background daemon with IPC server, stats, log rotation), `playit-cli` (CLI and TUI frontend using ratatui), `playit-ipc` (local IPC protocol with version negotiation), and `playitd-tray` (Windows system tray controller). It supports Linux, Windows, macOS, and FreeBSD, with platform-specific path handling (Unix sockets, named pipes, Windows service management). The architecture centers on a UDP control connection to playit.gg servers: the agent authenticates via HMAC-SHA256, receives tunnel assignments, then proxies TCP and UDP traffic between tunnel ingress points and local origin servers. The daemon runs as a background service (systemd, OpenRC, Windows service) and exposes a local IPC endpoint for the CLI/TUI to monitor logs, stats, and lifecycle status. Key entry points include `packages/playitd/src/bin/playitd.rs` (daemon binary), `packages/playitd/src/bin/playitd-service.rs` (Windows service host), `packages/playit-cli/src/main.rs` (CLI with attach/start/stop/claim commands), and `packages/playitd-tray/src/main.rs` (Windows tray application). External dependencies include tokio (async runtime), ratatui (TUI), crossterm (terminal), serde (serialization), reqwest (REST client), and ring (HMAC). The codebase demonstrates strong craftsmanship in low-level networking (zero-copy UDP packet pools, PROXY protocol, statically-sized control messages) and state machine design (connection recovery, MTU probing, address selection). However, it suffers from some production debt: panics in critical paths (UDP channel shutdown, flow invariants), duplicated code between `playitd-tray` and `playitd-windows-setup` startup shortcuts, and hardcoded configuration values (control port, protocol version). The build and release infrastructure is extensive (nfpm, WiX, Docker, Arch PKGBUILD, code signing) but shows signs of fragility (stale binary name in mac-deploy.sh, sed-based version overrides).
This is a monorepo for an AI coding assistant called T1 Code (a fork of T3 Code). It provides a unified chat-based interface that integrates multiple AI providers (Codex, Claude, Cursor, OpenCode) via a server-side orchestration engine. The server uses Effect-TS for functional effects, SQLite for persistence, and WebSocket for real-time communication. Clients include a web app (React with TanStack Router), a terminal UI (Ink/React), and a desktop app (Electron). The system supports git operations, terminal integration, source control providers (GitHub, GitLab, Bitbucket, Azure DevOps), checkpointing/diff tracking, and text generation for commit messages, PRs, and branch names. The architecture follows an event-sourcing/CQRS pattern with a projection pipeline for read models. The codebase is well-structured with extensive test coverage and reusable Effect-based service layers, but relies on beta versions of Effect-TS and other libraries, which introduces some technical drift risk.
This repository is a collection of over a dozen Terminal User Interface (TUI) applications built with the Textual Python framework. The apps serve educational and recreational purposes: interactive exercises for learning CLI tools (awk, sed, grep), Python regular expressions, Python programming fundamentals, and two original grid-based games (Connect Square, Square Tic Tac Toe). Each app is self-contained, with a similar architectural pattern: an App subclass defines widgets, binds keys, and handles user input. The exercise apps execute user commands via subprocess and compare output to expected results; the regex playground and Python exercises evaluate Python expressions in a sandbox; the games implement AI opponents using weight-based heuristics. The code is clean, well-structured, and consistently styled, though the exercise apps share a large amount of boilerplate. The repository is actively maintained (1015 stars, 0 open issues, recent commits) and demonstrates solid craftsmanship, particularly in the game AI algorithms and custom Textual widget subclasses.
This repository is an open-source terminal-based AI coding assistant built in Rust, clean-room reimplementing Anthropic's Claude Code. It provides an interactive TUI (ratatui) for multi-provider LLM conversation (Anthropic, OpenAI, Google, and 30+ OpenAI-compatible) with a rich tool ecosystem for file editing, bash execution, MCP integration, code analysis, web fetching, and agent orchestration. The architecture is modular: a provider abstraction layer (`LlmProvider` trait), plugin system, slash commands, session management, and an Agent Client Protocol (ACP) for external IDE integration. The codebase is organized into 12+ workspace crates with clear separation of concerns, but many modules are still in active refactoring (issue #232) with stubs, TODOs, and incomplete feature gates (36 experimental features). The permission system, tool budget enforcement, and streaming decoders demonstrate strong engineering, while dual feature flag systems and global mutable state introduce maintenance risk. Overall, it is a feature-rich, well-architected application with some rough edges from ongoing migration.
termbox-go is a minimalistic Go library for building text-based user interfaces (TUIs). It provides a clean API for cell-based screen manipulation, keyboard and mouse input, and multiple output modes (normal, 256, 216, grayscale, RGB). The library abstracts over Unix terminals (via terminfo and ANSI escape codes) and the Windows console (via Win32 API). Architecture uses double-buffering: a back buffer is modified by the user, then flushed to a front buffer and rendered to the terminal. Input events are processed asynchronously via a goroutine and channel. The library is stable and widely used (godit, termui, gocui, etc.) but the README explicitly states it is no longer actively maintained; users may consider gdamore/tcell as a more modern alternative. The codebase is well-organized with platform-specific files using Go build tags, though it exhibits some global state and sparse test coverage.
turm is a terminal user interface (TUI) application for monitoring and managing Slurm workload manager jobs. It provides real-time job tracking, log viewing, and job control capabilities through a keyboard-driven interface. The application architecture centers around two main background threads: a job watcher that periodically executes `squeue` to gather job information, and a file watcher that monitors job output files for changes using efficient tail-like reading with polling fallback for network filesystems. The UI is built with ratatui and handles user input via crossterm, offering features like job filtering, sorting, scrollable logs, and interactive dialogs for job control operations. The project includes mock implementations of Slurm commands for local development and testing without requiring an actual Slurm cluster.
term39 is a cross-platform terminal multiplexer and emulator built in Rust, featuring a retro MS-DOS aesthetic. It provides a full-screen text interface with window management (drag, resize, minimize, maximize, auto-tiling), terminal emulation via VTE ANSI parsing and PTY integration, session persistence through a Unix daemon, a lockscreen with OS-level authentication (PAM, macOS DS, Windows Security, PIN), and an optional Linux framebuffer backend for direct console rendering. The application supports multiple platforms including Linux, macOS, Windows, FreeBSD, NetBSD, OpenBSD, and Android/Termux, with feature-gated builds via Cargo features. The architecture is modular: an event loop drives input handling (keyboard, mouse) and rendering through a `RenderBackend` trait that abstracts terminal (crossterm) and framebuffer backends. The UI is composed of widgets (top bar, battery, network, system menu) and dialogs (config, prompt, toast, info). Terminal state is managed by `TerminalGrid` and `TerminalEmulator`, with ANSI escape sequences parsed by `AnsiHandler`. Session persistence uses a client/daemon pattern over Unix domain sockets, allowing windows to be detached and reattached. The lockscreen supports multiple authentication backends via a factory pattern. While the codebase is feature-rich and well-structured in many areas, it exhibits some technical drift: dead code artifacts (e.g., a disabled restore line in main.rs), heavy use of `#[allow(dead_code)]`, platform-specific code duplication, and unsafe operations in forking and signal handling. The rapid version history (0.1.0 to 1.6.0 in about a year) suggests fast iteration, which may have introduced some technical debt. Nonetheless, the project demonstrates strong engineering in its abstraction layers, widget system, and cross-platform support.
go-chromecast is a Go application and library for discovering and controlling Google Cast (Chromecast) devices on a local network. It implements the CastV2 protocol using protobuf messages over TLS, with mDNS/DNS-SD discovery. The CLI, built with Cobra, exposes commands for status, playback, volume, text-to-speech, and a terminal UI; the same functionality is available programmatically through the application and cast packages.
ytsurf is a single-file Bash script that turns the terminal into a YouTube frontend. It scrapes YouTube search results and channel pages via curl and perl, parses the embedded JSON with jq, and presents results in a fuzzy-finder (fzf, rofi, sentaku, or tv) with thumbnail previews rendered via chafa. Once a video is selected, the script delegates playback to mpv (or iina/syncplay) and downloading to yt-dlp. The tool supports audio-only mode, format selection, subscription management with a personalized feed, watch history, playlists, and queueing. It caches search results and feed data to avoid redundant network calls, uses a config file for persistent settings, and offers multi-selector support. While functionally rich and well‑structured for a shell script, the codebase is tightly coupled into a single file (∼1400 lines), lacks unit tests beyond basic CI sanity checks, and relies on scraping fragile YouTube HTML. The packaging (Nix, Homebrew, AUR) and CI (ShellCheck on Linux/macOS) demonstrate good distribution and quality assurance.
SmallCode is an open-source AI coding assistant CLI designed to run locally on consumer hardware with small language models (8B–35B parameters). It provides a full-screen terminal UI with streaming output, tool execution, and multi-turn agent loops. The system compensates for small-model limitations through a context budget engine, forgiving JSON parser, patch-first editing, early-stop detection, and TODO-driven planning. It supports multiple LLM providers (Ollama, LM Studio, llama.cpp, OpenAI, Anthropic, DeepSeek) with automatic escalation to stronger models on hard failure. The architecture is a monolith agent loop with modular subsystems: a plugin system for tools, commands, and hooks; a skill system for reusable prompt templates; a knowledge injection system for contextual notes; a memory store with SQLite/FTS5; a RAG index for code snippet retrieval; and an MCP client/server for tool interoperability. The codebase includes a compiled MarrowScript cognition layer with typed prompts, output validation, and budget tracking, though the dual implementation (hand-ported JS alongside MarrowScript sources) introduces drift risk. Key entry points include bin/smallcode.js (main CLI), src/tui/fullscreen.js (zero-dependency TUI), and src/compiled/cognition/ (prompts, routers, validation). The agent loop orchestrates user input, model calls, tool dispatch, and improvement loops. The repository also includes benchmark harnesses, trace recording, evaluation runners, and a provider wizard for configuration. Despite being marked as 'dead' in the README, the codebase exhibits high craftsmanship in several reusable components, though the large feature surface and experimental nature suggest maintenance challenges.
C-EDIT is a terminal-based text editor implemented in C without using ncurses. It features a modular architecture with separate components for terminal handling (rterm), screen buffer management (scbuf), keyboard input (keyb), text buffer management (edbuf), file operations (fileb), and user interface elements (ui, menu). The editor provides standard text editing capabilities including file open/save, cursor navigation, basic editing operations, and syntax highlighting. A key innovation is its double screen buffer system that minimizes flicker during updates. The application uses ANSI escape codes for terminal control and implements custom keyboard handling for special keys and accents. The project shows active maintenance with recent commits and ongoing development as indicated in TODO files.
This repository is the archived reference implementation of the CAI (Cybersecurity AI) framework by Alias Robotics. It is a comprehensive, open-source platform for building and deploying AI-powered offensive and defensive security automation. The codebase provides a full-stack agent framework including a Python SDK (Agent, Runner, tools, handoffs, guardrails, tracing, voice, MCP), a CLI/REPL with rich interactive features, a Textual-based TUI, a FastAPI REST API server, and a benchmarking suite (CAIBench) with cyber ranges and CTF challenges. The framework supports multiple LLM providers (OpenAI, LiteLLM, custom) and includes specialized agents for red teaming, blue teaming, bug bounty, DFIR, network analysis, and more. It also features continuous operations (24/7 autonomous loops), session management, cost tracking, and extensive refusal testing (400+ scenarios). While the repository is now archived and will not receive further updates, the SDK components (function_tool decorator, Handoff abstraction, tracing processors, voice pipeline) are well-crafted and could be extracted for reuse in other agent-based projects. The codebase is large and monolithic, with some global mutable state and test duplication, but overall demonstrates strong engineering practices in the cybersecurity AI domain.