crynta/terax-ai

1. Terax is a desktop application with a split architecture: a React/Vite frontend in src/ and a Rust/Tauri backend in src-tauri/. The frontend owns layout, state, and most user interaction; the Rust side provides native capabilities such as PTY, filesystem access, git execution, process control, secrets storage, and platform integration.

2. The app shell is centered around a workspace-oriented IDE layout rather than a single document model. The main UI in src/app composes the top-level window, workspace bar, OS/window controls, and workspace surface. Most visible features are mounted as module-level panes, and the workspace/subspace model is the primary unit of context for tabs, terminals, and AI activity.

3. The terminal subsystem is one of the core foundations. On the frontend, src/modules/terminal handles pane layout, renderer state, block-based shell interaction, history, completion, drag/drop, and terminal-specific keyboard handling. On the backend, src-tauri/src/modules/pty manages native PTY sessions, shell initialization, and agent/shell detection. Data flows from the Rust PTY into the xterm/WebGL renderer and back through user input and command execution.

4. The editor subsystem is another major boundary. src/modules/editor wraps CodeMirror 6 with language resolution, themes, Vim mode, autocomplete, diff caches, and file synchronization. It is paired with AI diff views for review/accept/reject workflows. The editor is not a standalone IDE core; it is tightly linked to workspace files, git diffs, and AI-generated edits.

5. File system and project navigation are handled through a dedicated explorer layer. src/modules/explorer provides tree rendering, fuzzy search, inline rename, context actions, drag-and-drop, and git status decoration. The Rust backend exposes file/tree/search/watch/mutate operations under src-tauri/src/modules/fs, so the frontend can read, search, and change project files while keeping native file watching and mutation centralized.

6. Git/source control is split between frontend orchestration and backend command execution. The Rust src-tauri/src/modules/git package wraps git commands, parsing, operations, and process utilities. The frontend source-control and history modules present branch state, staged/unstaged changes, commit flows, and a commit graph view. The data flow is: native git command output -> parsed Rust types -> UI panels and graph rendering.

7. AI is a first-class subsystem, not just a chat widget. src/modules/ai contains chat UI, composer, agent registry, snippet/file/context picking, tool approvals, mini-window behavior, sessions, model preferences, transport, redaction/security, speech-to-text, and persistence stores. It also defines tool adapters for filesystem, shell, terminal, search, edits, subagents, and todos. The architecture supports both BYOK cloud providers and local endpoints, with key material stored in the OS keychain via the Rust/native layer.

8. Agent handling is separated from generic chat. The agents modules manage agent definitions, notifications, routing, review flows, and store state; ai/agents includes subagent execution and registry logic. This lets Terax treat “agent runs” as durable activities with status, notifications, and reviewable output, rather than ephemeral chat messages.

9. The preview, history, and source-control areas extend the “dev workspace” concept beyond editing. src/modules/preview auto-detects local servers and opens them in a preview pane, while the git-history module renders a commit graph and remote URL links. These features depend on project context and native process/state knowledge, but are presented as separate panes in the same workspace surface.

10. Global application concerns are handled through smaller cross-cutting modules: theme manages app/editor themes and background images; spaces persists workspace collections and active-space state; tabs manages tab identity, ordering, and window title; statusbar, header, and sidebar provide shared chrome; shortcuts centralizes global keybindings; settings opens a separate settings window. These modules define how the desktop workspace behaves across panes.

11. The Rust backend is organized as capability modules exposed to the frontend through Tauri commands/events. In addition to FS, git, and PTY, it includes history parsing, network/process helpers, secrets, workspace handling, and shell/agent support. This backend is the trust boundary for native operations: the UI requests actions, and Rust performs the privileged work.

12. The repository also contains a separate settings app entrypoint and native packaging/tooling. src/settings is a distinct React app for configuration, while src-tauri contains platform manifests, icons, entitlements, installer hooks, and capability definitions. Build and release automation is handled by GitHub Actions plus Nix/flake files, which matter mainly for reproducible packaging across macOS, Linux, and Windows.