This is a Go application that runs an SSH server at jobs.hackclub.com, presenting Hack Club's open job positions as a virtual filesystem. Users connect via SSH and interact with a terminal-based shell supporting commands like `ls`, `cat`, `help`, and `exit`. Job listings are fetched from Polymer's hire API, converted from HTML to Markdown, and rendered in the terminal with support for light/dark themes, autocomplete, paging, and an animated intro sequence. The project is a playful developer-facing tool rather than a traditional web app or data pipeline.
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.
unslop is a CLI tool that empirically detects repetitive defaults in AI-generated outputs (text or visual) and produces a reusable instruction file (skill.md) to eliminate those patterns. It works by generating a set of prompts for a given domain, running them through Claude Code to produce samples, analyzing the samples for repeated patterns (phrases, structures, visual defaults), and writing a focused 'unslop profile' that tells the model what to avoid. The tool supports both text domains (blog writing, emails, tutorials) and visual domains (landing pages, UI mockups) with optional screenshot rendering via Playwright. The architecture is a single Python script (unslop.py) that orchestrates a multi-step pipeline: prompt generation, sample generation via parallel Claude Code calls, screenshot rendering (visual only), pattern analysis, skill file generation, and a before/after comparison. It uses asyncio for concurrency, a custom terminal UI with live spinners and progress bars, and a robust subprocess wrapper for the Claude CLI that handles streaming JSON output, timeouts, retries, and permission denials. Key entry points are the CLI arguments (--domain, --type, --count, --concurrency, etc.) and the main async run() function. External dependencies are the Claude Code CLI (claude command), Python 3.10+, and optionally Playwright for visual domains. The output is a directory (unslop-output/) containing the skill file, analysis, prompts, samples, screenshots, and before/after comparison. The code demonstrates solid async patterns, clean separation of concerns within a single file, and a well-designed terminal UI abstraction. It is not a library but a self-contained tool that could be adapted for other AI model backends by replacing the claude() function.
This repository is a fork and local enhancement of Anthropic's Claude Code CLI, branded as 'claude-code-tudou' (土豆版). It is a production-grade terminal AI coding assistant that provides an interactive AI agent within the terminal, capable of reading/writing files, executing shell commands, searching code, managing git operations, and orchestrating multi-agent teams. The system features a dual UI: a rich terminal interface built with React and Ink (custom terminal rendering framework) and an optional Electron desktop application with Vue 3 frontend. It supports third-party API providers (OpenRouter, MiniMax, Gemini, Bedrock, Vertex) via environment variables, making it a versatile alternative to the official Claude Code. The architecture is modular with clear separation: tool definitions (Bash, FileEdit, Glob, Grep, LSP, MCP, etc.), a plugin marketplace system, MCP (Model Context Protocol) integration, permission/security engine, session memory, and a swarm multi-agent subsystem. The codebase includes a custom Ink-based terminal UI framework with yoga layout, ANSI parsing, and event handling. It also provides a comprehensive settings system with multiple sources (user, project, managed), keybinding configuration, and analytics/telemetry infrastructure. While the code is well-structured and functional, it carries significant upstream Anthropic markers ('ANT-ONLY' imports, conditional internal features) and ad-hoc modifications for local execution stability. The fork adds value through configurable API endpoints, desktop UI, and stability fixes, but inherits complexity from the upstream codebase. The project is actively maintained with recent commits and demonstrates professional engineering standards.
WarriorJS is a terminal-based educational game that teaches JavaScript and TypeScript through interactive coding challenges. Players write a `Player` class with a `playTurn(warrior)` method to control a warrior navigating grid-based towers filled with enemies, captives, and stairs. The game runs as a CLI application using Ink (React for terminal UI) and relies on a sandboxed code execution environment via Node's `vm` module and esbuild. The monorepo structure includes a CLI app, game engine (`@warriorjs/core`), abilities library (`@warriorjs/abilities`), units library (`@warriorjs/units`), scoring module, spatial math helpers, effects, and two sample towers. The codebase demonstrates clean architecture with well-separated concerns, extensive test coverage, and reusable patterns such as the ability/effect binding factory and sensed space wrappers. However, the project has been inactive since 2018 (last release v0.14.0), the documentation website uses the deprecated Docusaurus v1, and there are some mixed module system usages. Despite being stale, the game engine and ability system remain functional and could be extracted for similar turn-based coding games or sandboxed code execution.
kimi-cli is MoonshotAI's Python AI coding assistant CLI, now explicitly archived and replaced by the TypeScript Kimi Code CLI. The pyproject.toml declares Development Status :: 7 - Inactive, the README states no further releases or security fixes will ship, and the final release (1.52.0) is a deprecation shim: every entry point short-circuits to a notice that downloads and installs the successor via a CDN script. Tests in the repo actively enforce that the legacy Typer CLI is unreachable. In its working life it was a full-featured terminal agent with interactive shell (prompt_toolkit/Rich), print mode, file editing tools, shell execution, web fetch/search, subagents, plan mode, approval workflows, background tasks, hooks, plugins, MCP server management, OAuth, and session persistence.
This is a leaked internal source of 'Claude Code', a terminal-based AI coding assistant CLI built by Anthropic. The application is a monolith written in TypeScript with React/Ink for terminal UIs, running on the Bun runtime. In production, it provides an interactive REPL that connects to Claude LLMs to perform software engineering tasks: reading/writing files, executing bash/PowerShell commands, searching code with grep/glob, managing git operations, spawning sub-agents, running MCP servers, and more. It features a sophisticated permission engine, plugin ecosystem, skill system, IDE bridge (VS Code/JetBrains), and remote session support. The architecture is centered around a QueryEngine that orchestrates LLM API calls with streaming, tool loops, and retries. There are ~40+ tools (BashTool, FileEditTool, MCPTool, etc.) and ~50+ slash commands (/commit, /review, /config, /doctor). The codebase is extremely large (~1900 files, 512K+ lines) with significant internal complexity. However, it contains many stubs for removed internal packages (@ant/*, @anthropic-ai/mcpb, etc.), heavy use of bun:bundle feature flags, and countless ant-only conditionals (process.env.USER_TYPE === 'ant') that gate internal-only features. This means the source cannot be run as-is without Anthropic's infrastructure. While the engineering quality is high in places (clean TypeScript with Zod schemas, well-structured tool pipelines, a custom Ink renderer with Yoga layout), the codebase is not designed for external reuse or portability. It requires Bun, has many hardcoded internal service URLs, and the stubbed packages would need real implementations. For learning and inspiration, however, it offers excellent examples of: terminal UI architecture, permission engines, plugin systems, and AI agent tool frameworks.
cursor-vip is a client-side Go/TUI application that lets users share Cursor IDE Pro accounts. At runtime it presents a terminal wizard: it fingerprints the machine (MAC-based device ID + machine-id), contacts a private licensing backend (hardcoded hosts: cursor.jeter.eu.org), prints the user's promotion stats, expiry, and payment links, then starts one of several "modes" that make the locally installed Cursor app authenticate as a shared Pro user. Mode 1 is the minimalist mode; modes 2-4 run a local MITM proxy (go-mitmproxy fork) that requires the user to install a trusted root certificate and intercepts Cursor's API traffic, with mode 3 doing free-trial account rotation and mode 4 providing a dedicated "exclusive" account. The core Cursor-manipulation code lives in an `auth/` package absent from this snapshot - go.mod shows it vendors local forks of `machineid` and `go-mitmproxy` - so the visible code is only the client shell, payment flow, and OS plumbing. Architecturally it is a monolith split into packages: `tui` (terminal UI with embedded i18n locale files for 7 languages), `tui/client` (HTTP client using beego v1's httplib against the private API), `tui/shortcut` (a global keyboard hook recognizing typed 3-letter codes like `sm1`/`u3d`/`buy` to switch modes, refresh accounts, or buy access), and `tui/tool` (OS utilities: locale detection, system-proxy configuration for Windows/macOS/Linux, flock-based single-instance enforcement, and MAC fingerprinting). The build script targets 3 OSes x 3 architectures and obfuscates most binaries with `garble`, consistent with a grey-market licensing tool that expects to be reverse-engineered. The project is actively maintained (last commit March 2026) and clearly works for its user base, but the code is average quality: global mutable state in a `params` package, string-concatenated endpoint paths, no tests or CI, an unconditional `mode = 3` override bug in `GetConfig`, and deprecated dependencies (beego v1, dgrijalva/jwt-go v3.x). It also has a questionable security posture - it instructs Mac users to disable SIP, asks for a trusted root CA for the MITM proxy, and requires Windows admin privileges. Engineers should not reuse this codebase as-is for legitimate licensing work; the genuinely extractable parts are the cross-platform OS utilities (locale detection, proxy toggling, single-instance lock, device fingerprinting).