ProxyAI (formerly CodeGPT) is a JetBrains IDE plugin that provides AI-powered code assistance including chat, inline editing, code completions, agent-based task execution, commit message generation, and next-edit suggestions. The plugin integrates with multiple LLM providers (OpenAI, Anthropic, Google, Mistral, Ollama, llama.cpp, custom OpenAI-compatible, and its own ProxyAI cloud) and supports local inference via a bundled llama.cpp submodule. It implements an agent framework with a tool system (read, write, edit, bash, web search, diagnostics, debugger control), MCP (Model Context Protocol) client for external tool servers, and ACP (Agent Client Protocol) for external agent integration. The architecture follows IntelliJ Platform conventions: services, actions, tool windows, settings via PersistentStateComponent, and editor listeners. The codebase is a mix of Kotlin (dominant) and Java, with Gradle build system and extensive use of coroutines for async operations.
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 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.
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.
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.
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.