How neovateai/neovate-code works
Project type and purpose
• Neovate Code is an open-source, multi-platform coding agent.
• It provides a CLI (“neovate” / “neo”) that developers run in the terminal.
• It also includes an optional browser-based UI and a VSCode extension.
• Under the hood it spins up a local server process to orchestrate LLM calls, file I/O, and tool executions.
File structure
• Top-level “src”—implements the core CLI application, server, commands, message bus, providers (LLMs), tools, plugins, slash-commands, session management, and utilities.
• “browser” folder—a standalone React/Vite web client that calls the server’s REST/WebSocket routes.
• “vscode-extension”—a VSCode extension that embeds an “mcp-server” (multi-channel protocol) to speak with the core.
• “e2e”, “examples”, “scripts” and tests—end-to-end fixtures and helper scripts for CI and examples.
• Configuration files: pnpm-workspace.yaml (monorepo), tsconfigs, GitHub Actions workflow.
README for additional insights
• Describes end-user flows: install CLI, run /login, /model, then free-form prompts.
• Mentions API key management, provider selection, tool invocation, code review, fix, generation.
1. CLI Client (neovate CLI binary)
2. Local Server Process
• HTTP / WebSocket API Layer (routes: app-data, files, completions, mcp, settings, tool-approval)
• Core Engine (messageBus, session, command parser, slash-commands)
• LLM Providers (GitHub Copilot, OpenAI, etc.)
• Tool Executor (shell commands, file read/write, git, external editor)
• Plugins & Output Style modules
3. Browser UI (React / Vite App)
4. VSCode Extension (mcp-server shim, extension.ts)
5. External Services
• LLM APIs
• GitHub (for git operations)
6. File System & Developer Project (workspace files)
• CLI Client → Local Server (IPC/child process stdio or HTTP)
• Browser UI → Local Server (HTTP / WebSocket)
• VSCode Extension → Local Server (mcp protocol over stdio or websocketTransport)
• Local Server → LLM Providers (HTTPS)
• Local Server → File System & git (tools via plugin/tool-executor)
• Core Engine ↔ Message Bus (internal event propagation)
c. Architectural patterns and design principles:
• Modular monorepo with clear separation between UI, server, and core logic.
• Plugin pattern for tools and output-styles (src/plugins & src/output-style).
• Slash-commands engine for extendable CLI commands (src/slash-commands).
• Event-driven message bus for decoupling CLI inputs, server operations, and tool calls.
• REST/WebSocket hybrid for browser UI performance and real-time updates.
d. Key technologies/frameworks:
• Node.js + TypeScript
• pnpm monorepo
• React + Vite + Tailwind (browser client)
• VSCode Extension API + esbuild
• Express-style server (custom)
• Lexical for chat input editing
• Vitest for unit tests / e2e fixtures