docs: Update README and CLAUDE.md for current architecture

- Remove all rusty-data references (crate deleted)
- Update framework reference: GPUI -> Iced
- Add arni as database access layer in architecture docs
- Add module map, icon usage guide, CI notes
- Update supported databases (MongoDB/SQL Server now fully supported)
- Update build commands and local CI instructions

Author: aaroncroberts

CLAUDE.md

@@ -4,111 +4,104 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-rusty-app is a universal database tool written in Rust using GPUI. The goal is to create a powerful, cross-platform database management application that supports multiple database systems with a modern, performant UI. In spirit similar to universal database tools like DBeaver, but with its own approach and identity.
-
-## System Requirements
-
-### All Platforms
-- Rust toolchain (stable)
-- Platform-specific graphics drivers for GPU acceleration (Iced uses wgpu)
+rusty-app is a universal database tool written in Rust using [Iced](https://github.com/iced-rs/iced). The goal is a powerful, cross-platform database management application supporting multiple database systems with a modern, performant UI — similar in spirit to DBeaver but with its own identity.
 
 ## Common Commands
 
 ```bash
-# Build the project
-cargo build
-
-# Run the application
+# Build and run
 cargo run
 
-# Check for errors without building
+# Check for errors (fast)
 cargo check
 
-# Run linter
-cargo clippy
+# Lint (CI-equivalent — all warnings are errors)
+cargo clippy --features postgres,mysql,sqlite,mongodb,mssql -- -D warnings
 
-# Format code
+# Format
 cargo fmt
 
-# Run tests
-cargo test
+# Test
+cargo test --features postgres,mysql,sqlite,mongodb,mssql
+
+# Full local CI check (mirrors GitHub Actions exactly)
+bash scripts/ci-check.sh
 ```
 
+> **Note**: Oracle requires native Oracle Instant Client libraries. Omit `oracle` from `--features` if not installed. The `default` feature set includes oracle; CI excludes it.
+
 ## Architecture
 
 ### UI Framework: Iced
 
-The application uses Iced, a cross-platform GUI library which provides:
-- GPU-accelerated rendering via wgpu for high performance
-- Elm-inspired architecture with declarative UI
-- Clean, modern aesthetic suitable for polished applications
-- Native feel with cross-platform support (Windows, macOS, Linux)
+- GPU-accelerated rendering via wgpu
+- Elm-inspired architecture: `Message` enum → `update()` → `view()`
+- Declarative, stateless view functions
+- Cross-platform: macOS, Linux, Windows
 
-### Target Database Systems
+### Database Access: arni
 
-Priority support for:
-- **PostgreSQL** - Full-featured relational database
-- **MySQL/MariaDB** - Popular open-source RDBMS
-- **SQLite** - Embedded database for local files
-- **MongoDB** - Document-oriented NoSQL
-- **Redis** - In-memory data structure store
-- **SQL Server** - Microsoft's enterprise database (future)
+All database I/O goes through the [arni](https://github.com/aaroncroberts/arni) library via the `DbAdapter` trait. rusty-app never talks to databases directly.
 
-### Core Modules (Planned Architecture)
+- `connection_manager.rs` — owns `ActiveConnection` (wraps `Arc<Mutex<Box<dyn DbAdapter>>>`)
+- `make_adapter()` — feature-gated factory dispatching to arni's per-database adapters
+- Supported: PostgreSQL, MySQL, SQLite, MongoDB, SQL Server, Oracle
 
-- **Connection Manager** - Handle database connections, credential storage, connection pooling
-- **Query Editor** - SQL/query editor with syntax highlighting, autocomplete, execution
-- **Result Viewer** - Display query results in grid/table format with pagination
-- **Schema Browser** - Tree view of databases, tables, columns, indexes, relationships
-- **Data Editor** - In-place editing of table data
-- **Query History** - Track and replay previous queries
-- **Export/Import** - Data migration tools for various formats (CSV, JSON, SQL)
+### Module Map
 
-### Layout Structure (Planned)
+| Module | Purpose |
+|---|---|
+| `main.rs` | App entry point, `DatabaseIDE` state, `Message` enum, `update()`, `view()` |
+| `connection_manager.rs` | Active connections, `ActiveConnection`, `ConnectionManager` |
+| `left_panel.rs` | Collapsible left panel with tab bar (28px icon rail when collapsed) |
+| `components/` | Reusable UI components: `ServerListComponent`, `TableListComponent`, `PropertiesComponent`, `ConnectionFormComponent` |
+| `icons.rs` | Nerd Font (Codicons) icon helpers — all icon functions return `String` glyphs |
+| `theme.rs` | `ThemeColors` struct — Tokyo Night Storm palette |
+| `button_styles.rs` | Shared button style helpers (`primary`, `secondary`, `danger`, `disabled`) |
+| `settings/` | User settings, persistence, `SettingsManager` |
+| `container/` | Podman container management for local dev databases |
+| `views.rs` | `ViewRegistry` — maps `RegionId` to enabled components |
+
+### Layout
 
 ```
-┌─────────────────────────────────────────────┐
-│ Menu Bar & Toolbar                          │
-├──────────┬──────────────────┬───────────────┤
-│          │                  │               │
-│ Database │  Query Editor    │  Auxiliary    │
-│ Navigator│  or              │  Panel        │
-│ (Tree)   │  Result Grid     │               │
-│          │                  │               │
-└──────────┴──────────────────┴───────────────┘
+┌──────────────────────────────────────────┐
+│ Menu Bar                                 │
+├──────────┬───────────────────────────────┤
+│          │                               │
+│ Left     │  Main Panel                  │
+│ Panel    │  (Query Editor / Results)    │
+│ (tabs)   │                               │
+│          │                               │
+└──────────┴───────────────────────────────┘
+│ Status Bar                               │
+└──────────────────────────────────────────┘
 ```
 
-### Key Design Principles
+The left panel collapses to a 28px icon rail (`left_panel::ICON_RAIL_WIDTH`). Toggle via `Message::ToggleLeftPanel`.
 
-1. **Async-First** - All database operations use `tokio` for non-blocking I/O
-2. **Connection Pooling** - Efficient connection management per database
-3. **Plugin Architecture** - Each database driver is a separate module with a common trait
-4. **Result Streaming** - Handle large result sets without loading everything into memory
-5. **Cross-Platform** - Support macOS, Linux, and Windows
+### Icons
 
-## Development Workflow
+```rust
+use rusty_app::icons;
+text(icons::database()).font(icons::font()).size(14).color(theme.accent)
+```
 
-### Adding a New Database Driver
+Font must be registered at app startup via `.font(icons::FONT_BYTES)` on the iced application builder (already wired in `main.rs`).
 
-1. Create module in `src/drivers/` (e.g., `postgres.rs`)
-2. Implement the `DatabaseDriver` trait
-3. Add connection string parsing
-4. Implement query execution and result mapping
-5. Add schema introspection queries
+### Key Design Principles
 
-### GPUI Component Pattern
+1. **Async-First** — All database operations are `async`, driven by `tokio`
+2. **Adapter trait** — `DbAdapter` from arni; swap databases without changing UI code
+3. **Feature flags** — Each database adapter is a Cargo feature; oracle excluded from CI
+4. **No dead code in CI** — `clippy -D warnings` is enforced; all warnings are errors
 
-Components in GPUI:
-- Define state using structs
-- Implement rendering via the `Render` trait
-- Use actions for user interactions
-- Leverage reactive updates when state changes
+## CI
 
-## Dependencies (Current/Planned)
+GitHub Actions runs on every push and PR to `main`:
+- `cargo fmt --check`
+- `cargo check`
+- `cargo clippy -- -D warnings`
+- `cargo test`
 
-- **iced** - Cross-platform GUI framework with GPU acceleration
-- **tokio** - Async runtime for database operations
-- **serde / serde_json** - Serialization for configuration files
-- **mongodb** - MongoDB Rust driver (planned)
-- **sqlx** - SQL database driver with compile-time query checking (planned)
-- **redis** - Redis client (planned)
+Oracle excluded from CI (requires native OCI libs not available on runners).

README.md

@@ -1,71 +1,74 @@
 # rusty-app
 
-Universal database management tool written in Rust with GPUI.
+Universal database management tool written in Rust using [Iced](https://github.com/iced-rs/iced).
 
 ## Overview
 
-rusty-app is a cross-platform database tool that provides a modern interface for managing multiple database systems. Built with Rust and GPUI for performance and a native feel.
+rusty-app is a cross-platform desktop application for managing multiple database systems. It provides a modern, GPU-accelerated UI built with Iced and delegates all database access to the [arni](https://github.com/aaroncroberts/arni) library.
 
 ## Project Structure
 
 ```
 rusty-app/
 ├── rusty-app/          # UI application crate
-├── rusty-data/         # Data access library crate
-│   ├── src/
-│   │   ├── adapters/   # Database adapters (PostgreSQL, MySQL, SQLite)
-│   │   ├── adapter.rs  # DatabaseAdapter trait
-│   │   ├── config.rs   # Configuration management
-│   │   └── error.rs    # Error types
-│   └── podman-compose.yml  # Database testing containers
+│   └── src/
+│       ├── components/ # Reusable UI components (ServerList, TableList, Properties, ...)
+│       ├── container/  # Podman container management for local dev databases
+│       ├── settings/   # Configuration and user preferences
+│       ├── icons.rs    # Nerd Font (Codicons) icon helpers
+│       ├── theme.rs    # Color theme (dark mode)
+│       └── main.rs     # Application entry point
+├── rusty-logging/      # Structured logging configuration crate
+├── scripts/
+│   └── ci-check.sh     # Local CI verification script
 └── docs/               # Documentation
-    ├── README.md       # Documentation overview
-    └── database/       # Database-specific docs
-        └── testing.md  # Testing environment setup
 ```
 
 ## Supported Databases
 
-- **PostgreSQL** - Full-featured relational database
-- **MySQL/MariaDB** - Popular open-source RDBMS
-- **SQLite** - Embedded database for local files
-- **MongoDB** - Document-oriented NoSQL (planned)
-- **SQL Server** - Microsoft's enterprise database (planned)
+| Database | Status |
+|---|---|
+| PostgreSQL | ✅ Supported |
+| MySQL / MariaDB | ✅ Supported |
+| SQLite | ✅ Supported |
+| MongoDB | ✅ Supported |
+| SQL Server | ✅ Supported |
+| Oracle | ✅ Supported (requires Oracle Instant Client) |
 
 ## Getting Started
 
 ### Prerequisites
 
-- Rust (latest stable)
-- Xcode Command Line Tools (macOS)
-- Metal Toolchain (macOS, for GPUI GPU acceleration)
-- Podman (for database testing containers)
+- Rust stable toolchain
+- macOS: Xcode Command Line Tools
 
 ### Build and Run
 
 ```bash
-# Build the project
-cargo build
-
-# Run the application
+# Build and run (all adapters including Oracle)
 cargo run
 
-# Run tests
-cargo test
+# Build without Oracle (no Instant Client required)
+cargo run --no-default-features --features postgres,mysql,sqlite,mongodb,mssql
 
-# Run tests with database features
-cargo test --features all-databases
+# Run tests
+cargo test --features postgres,mysql,sqlite,mongodb,mssql
 ```
 
-### Database Testing Environment
+### Local CI Check
+
+Mirrors the GitHub Actions CI pipeline exactly:
+
+```bash
+bash scripts/ci-check.sh
+```
 
-See [Database Testing Documentation](docs/database/testing.md) for setting up local database containers using podman-compose.
+Runs: `cargo fmt --check` → `cargo check` → `cargo clippy -D warnings` → `cargo test`.
 
 ## Documentation
 
-- **[Documentation Index](docs/README.md)** - Complete documentation overview
-- **[Database Testing](docs/database/testing.md)** - Setup testing databases
-- **[CLAUDE.md](CLAUDE.md)** - Guidelines for AI assistants working with this codebase
+- **[CLAUDE.md](CLAUDE.md)** — Architecture notes and development guidelines
+- **[docs/](docs/)** — Additional documentation
 
 ## License