Fixed warnings

Considering pulling in features that auto generate code or pull in
packages. The code generation is planned to bring into v1.1.0 and
the document in this commit walks through that decision in great
detail.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "weevil"
-version = "1.1.0-beta.1"
+version = "1.1.0-beta.2"
 edition = "2021"
 authors = ["Eric Ratliff <eric@nxlearn.net>"]
 description = "FTC robotics project generator - bores into complexity, emerges with clean code"
@@ -56,6 +56,7 @@ which = "7.0"
 
 # Colors
 colored = "2.1"
+chrono = "0.4.43"
 
 [dev-dependencies]
 tempfile = "3.13"
@@ -86,4 +87,4 @@ strip = true
 
 [features]
 default = []
-embedded-gradle = []  # Embed gradle-wrapper.jar in binary (run download-gradle-wrapper.sh first)
+embedded-gradle = []  # Embed gradle-wrapper.jar in binary (run download-gradle-wrapper.sh first)

README.md

@@ -26,6 +26,8 @@ This approach works against standard software engineering practices and creates
 - ✅ Generate all build/deploy scripts automatically
 - ✅ Enable proper version control workflows
 - ✅ Are actually testable and maintainable
+- ✅ Work seamlessly with Android Studio
+- ✅ Support proxy/air-gapped environments
 
 Students focus on building robots, not navigating SDK internals.
 
@@ -39,6 +41,7 @@ my-robot/
 ├── src/
 │   ├── main/java/robot/     # Your robot code lives here
 │   └── test/java/robot/     # Unit tests (run on PC!)
+├── .idea/                   # Android Studio integration (auto-generated)
 ├── build.sh / build.bat     # One command to build
 ├── deploy.sh / deploy.bat   # One command to deploy
 └── .weevil.toml            # Project configuration
@@ -46,6 +49,9 @@ my-robot/
 
 ### 🚀 Simple Commands
 ```bash
+# Set up development environment
+weevil setup
+
 # Create a new robot project
 weevil new awesome-robot
 
@@ -60,6 +66,9 @@ cd awesome-robot
 
 ### 🔧 Project Management
 ```bash
+# Check system health
+weevil doctor
+
 # Upgrade project infrastructure
 weevil upgrade awesome-robot
 
@@ -69,8 +78,36 @@ weevil config awesome-robot --set-sdk /path/to/different/sdk
 
 # Check SDK status
 weevil sdk status
+
+# Remove installed components
+weevil uninstall --dry-run
+weevil uninstall
 ```
 
+### 🌐 Proxy Support (v1.1.0)
+Work behind corporate firewalls or in air-gapped environments:
+
+```bash
+# Use HTTP proxy for all downloads
+weevil --proxy http://proxy.company.com:8080 setup
+weevil --proxy http://proxy.company.com:8080 new my-robot
+
+# Bypass proxy (for local/direct connections)
+weevil --no-proxy setup
+
+# Proxy auto-detected from HTTPS_PROXY/HTTP_PROXY environment variables
+export HTTPS_PROXY=http://proxy:8080
+weevil setup  # Uses proxy automatically
+```
+
+### 💻 Android Studio Integration (v1.1.0)
+Projects work seamlessly with Android Studio:
+- **One-click deployment** - Run configurations appear automatically in the Run dropdown
+- **Clean file tree** - Internal directories hidden, only your code visible
+- **No configuration needed** - Just open the project and hit Run
+
+See [Android Studio Setup](#android-studio-setup) for details.
+
 ### ✨ Smart Features
 - **Per-project SDK configuration** - Different projects can use different SDK versions
 - **Automatic Gradle wrapper** - No manual setup required
@@ -78,6 +115,8 @@ weevil sdk status
 - **Zero SDK modification** - Your SDK stays pristine
 - **Git-ready** - Projects initialize with proper `.gitignore`
 - **Upgrade-safe** - Update build scripts without losing code
+- **System diagnostics** - `weevil doctor` checks your environment health
+- **Selective uninstall** - Remove specific components without nuking everything
 
 ---
 
@@ -96,30 +135,49 @@ export PATH="$PATH:$(pwd)/target/release"
 ```
 
 ### Prerequisites
-- Rust 1.70+ (for building)
+- Rust 1.70+ (for building Weevil)
 - Java 11+ (for running Gradle)
 - Android SDK with platform-tools (for deployment)
-- FTC SDK (Weevil can download it for you)
+- FTC SDK (Weevil can install it for you)
 
 ---
 
 ## Quick Start
 
-### 1. Create Your First Project
+### 1. Set Up Your Environment
+
+```bash
+# Check what's installed
+weevil doctor
+
+# Install everything automatically
+weevil setup
+
+# Or install to custom location
+weevil setup --ftc-sdk ~/my-sdks/ftc --android-sdk ~/my-sdks/android
+```
+
+Weevil will:
+- Download and install FTC SDK
+- Download and install Android SDK (if needed)
+- Set up Gradle wrapper
+- Verify all dependencies
+
+### 2. Create Your First Project
 
 ```bash
 weevil new my-robot
 cd my-robot
 ```
 
-Weevil will:
+Weevil generates:
-- Download the FTC SDK if needed (or use existing)
+- Clean project structure
-- Generate your project structure
+- Android Studio run configurations
-- Set up Gradle wrapper
+- Example test files
-- Initialize git repository
+- Build and deploy scripts
-- Create example test files
+- Git repository with `.gitignore`
 
-### 2. Write Some Code
+### 3. Write Some Code
 
 Create `src/main/java/robot/MyOpMode.java`:
 
@@ -146,7 +204,7 @@ public class MyOpMode extends LinearOpMode {
 }
 ```
 
-### 3. Test Locally (No Robot!)
+### 4. Test Locally (No Robot!)
 
 ```bash
 ./gradlew test
@@ -154,7 +212,7 @@ public class MyOpMode extends LinearOpMode {
 
 Write unit tests in `src/test/java/robot/` that run on your PC. No need to deploy to a robot for every code change!
 
-### 4. Deploy to Robot
+### 5. Deploy to Robot
 
 ```bash
 # Build APK
@@ -172,8 +230,93 @@ Write unit tests in `src/test/java/robot/` that run on your PC. No need to deplo
 
 ---
 
+## Android Studio Setup
+
+### Opening a Weevil Project
+
+1. Launch Android Studio
+2. Choose **Open** (not "New Project")
+3. Navigate to your project directory (e.g., `my-robot`)
+4. Click OK
+
+Android Studio will index the project. After a few seconds, you'll see:
+- **Clean file tree** - Only `src/`, scripts, and essential files visible
+- **Run configurations** - Dropdown next to the green play button shows:
+  - **Build** - Builds APK without deploying
+  - **Deploy (auto)** - Auto-detects USB or WiFi
+  - **Deploy (USB)** - Forces USB connection
+  - **Deploy (WiFi)** - Forces WiFi connection
+  - **Test** - Runs unit tests
+
+### First-Time Setup: Shell Script Plugin
+
+**Important:** Android Studio requires the Shell Script plugin to run Weevil's deployment scripts.
+
+1. Go to **File → Settings** (or **Ctrl+Alt+S**)
+2. Navigate to **Plugins**
+3. Click the **Marketplace** tab
+4. Search for **"Shell Script"**
+5. Install the plugin (by JetBrains)
+6. Restart Android Studio
+
+After restart, the run configurations will work.
+
+### Running from Android Studio
+
+1. Select a configuration from the dropdown (e.g., "Deploy (auto)")
+2. Click the green play button (▶) or press **Shift+F10**
+3. Watch the output in the Run panel at the bottom
+
+**That's it!** Students can now build and deploy without leaving the IDE.
+
+### Platform Notes
+
+- **Linux/macOS:** Uses the Unix run configurations (`.sh` scripts)
+- **Windows:** Uses the Windows run configurations (`.bat` scripts)
+- Android Studio automatically hides the configurations for the other platform
+
+---
+
 ## Advanced Usage
 
+### Proxy Configuration
+
+#### Corporate Environments
+
+```bash
+# Set proxy for all Weevil operations
+weevil --proxy http://proxy.company.com:8080 setup
+weevil --proxy http://proxy.company.com:8080 new robot-project
+
+# Or use environment variables (auto-detected)
+export HTTPS_PROXY=http://proxy:8080
+export HTTP_PROXY=http://proxy:8080
+weevil setup  # Automatically uses proxy
+```
+
+#### Air-Gapped / Offline Installation
+
+If you're on an isolated network without internet:
+
+1. **Download SDKs manually on a connected machine:**
+   - FTC SDK: `git clone https://github.com/FIRST-Tech-Challenge/FtcRobotController.git`
+   - Android SDK: Download from https://developer.android.com/studio
+   - Gradle: Download distribution from https://gradle.org/releases/
+
+2. **Transfer to isolated machine via USB drive**
+
+3. **Install using local paths:**
+   ```bash
+   weevil setup --ftc-sdk /path/to/FtcRobotController --android-sdk /path/to/android-sdk
+   ```
+
+#### Bypass Proxy
+
+```bash
+# Force direct connection (ignore proxy environment variables)
+weevil --no-proxy setup
+```
+
 ### Multiple SDK Versions
 
 Working with multiple SDK versions? No problem:
@@ -203,10 +346,27 @@ This updates:
 - Build scripts
 - Deployment scripts
 - Gradle configuration
+- Android Studio run configurations
 - Project templates
 
 **Your code in `src/` is never touched.**
 
+### System Maintenance
+
+```bash
+# Check what's installed
+weevil doctor
+
+# See what can be uninstalled
+weevil uninstall --dry-run
+
+# Remove specific components
+weevil uninstall --only 1  # Removes FTC SDK only
+
+# Full uninstall (removes everything Weevil installed)
+weevil uninstall
+```
+
 ### Cross-Platform Development
 
 All scripts work on Windows, Linux, and macOS:
@@ -220,9 +380,11 @@ All scripts work on Windows, Linux, and macOS:
 **Windows:**
 ```cmd
 build.bat
-deploy.bat --wifi
+deploy.bat
 ```
 
+**Android Studio:** Works identically on all platforms
+
 ---
 
 ## Project Configuration
@@ -231,9 +393,10 @@ Each project has a `.weevil.toml` file:
 
 ```toml
 project_name = "my-robot"
-weevil_version = "1.0.0"
+weevil_version = "1.1.0"
 ftc_sdk_path = "/home/user/.weevil/ftc-sdk"
 ftc_sdk_version = "v10.1.1"
+android_sdk_path = "/home/user/.weevil/android-sdk"
 ```
 
 You can edit this manually or use:
@@ -273,6 +436,7 @@ git push
 1. **Unit Tests** - Test business logic on your PC
    ```bash
    ./gradlew test
+   # Or from Android Studio: select "Test" and click Run
    ```
 
 2. **Integration Tests** - Test on actual hardware
@@ -293,7 +457,7 @@ cd robot
 # Check SDK location
 weevil config .
 
-# Set SDK to local path
+# Set SDK to local path (if different from .weevil.toml)
 weevil config . --set-sdk ~/ftc-sdk
 
 # Build and deploy
@@ -301,15 +465,29 @@ weevil config . --set-sdk ~/ftc-sdk
 ./deploy.sh
 ```
 
+**Android Studio users:** Just open the project. The `.idea/` folder contains all run configurations.
+
 ---
 
 ## Command Reference
 
+### Environment Commands
+
+| Command | Description |
+|---------|-------------|
+| `weevil doctor` | Check system health and dependencies |
+| `weevil setup` | Install FTC SDK, Android SDK, and dependencies |
+| `weevil setup --ftc-sdk <path>` | Install to custom FTC SDK location |
+| `weevil uninstall` | Remove all Weevil-managed components |
+| `weevil uninstall --dry-run` | Show what would be removed |
+| `weevil uninstall --only <N>` | Remove specific component by index |
+
 ### Project Commands
 
 | Command | Description |
 |---------|-------------|
 | `weevil new <name>` | Create new FTC project |
+| `weevil new <name> --ftc-sdk <path>` | Create with specific SDK |
 | `weevil upgrade <path>` | Update project infrastructure |
 | `weevil config <path>` | View project configuration |
 | `weevil config <path> --set-sdk <sdk>` | Change FTC SDK path |
@@ -322,6 +500,13 @@ weevil config . --set-sdk ~/ftc-sdk
 | `weevil sdk install` | Download and install SDKs |
 | `weevil sdk update` | Update SDKs to latest versions |
 
+### Global Flags
+
+| Flag | Description |
+|------|-------------|
+| `--proxy <url>` | Use HTTP proxy for all network operations |
+| `--no-proxy` | Bypass proxy (ignore HTTPS_PROXY env vars) |
+
 ### Deployment Options
 
 **`deploy.sh` / `deploy.bat` flags:**
@@ -343,6 +528,7 @@ weevil config . --set-sdk ~/ftc-sdk
    - Creates standalone Java project structure
    - Generates Gradle build files that reference FTC SDK
    - Sets up deployment scripts
+   - Creates Android Studio run configurations
 
 2. **Build Process**
    - Runs `deployToSDK` Gradle task
@@ -355,12 +541,18 @@ weevil config . --set-sdk ~/ftc-sdk
    - Connects to Control Hub (USB or WiFi)
    - Installs APK using `adb`
 
+4. **Proxy Support**
+   - reqwest HTTP client respects `--proxy` flag and HTTPS_PROXY env vars
+   - git2/libgit2 gets temporary proxy env vars during clone/fetch
+   - Gradle wrapper reads HTTPS_PROXY natively
+
 ### Why This Approach?
 
 **Separation of Concerns:**
 - Your code: `my-robot/src/`
 - Build infrastructure: `my-robot/*.gradle.kts`
 - FTC SDK: System-level installation
+- IDE integration: Auto-generated, auto-upgraded
 
 **Benefits:**
 - Test code without SDK complications
@@ -368,6 +560,7 @@ weevil config . --set-sdk ~/ftc-sdk
 - SDK updates don't break your projects
 - Proper version control (no massive SDK in repo)
 - Industry-standard project structure
+- Students use familiar tools (Android Studio)
 
 ---
 
@@ -382,6 +575,7 @@ cargo test
 # Run specific test suites
 cargo test --test integration
 cargo test --test project_lifecycle
+cargo test --test proxy_integration
 cargo test config_tests
 ```
 
@@ -392,6 +586,8 @@ cargo test config_tests
 - ✅ Build script generation
 - ✅ Upgrade workflow
 - ✅ CLI commands
+- ✅ Proxy configuration and network operations
+- ✅ Environment setup and health checks
 
 ---
 
@@ -400,11 +596,11 @@ cargo test config_tests
 ### "FTC SDK not found"
 
 ```bash
-# Check SDK status
+# Check system health
-weevil sdk status
+weevil doctor
 
 # Install SDK
-weevil sdk install
+weevil setup
 
 # Or specify custom location
 weevil new my-robot --ftc-sdk /custom/path/to/sdk
@@ -416,6 +612,10 @@ Install Android platform-tools:
 
 **Linux:**
 ```bash
+# Weevil can install it for you
+weevil setup
+
+# Or install manually
 sudo apt install android-tools-adb
 ```
 
@@ -425,7 +625,7 @@ brew install android-platform-tools
 ```
 
 **Windows:**
-Download Android SDK Platform Tools from Google.
+Download Android SDK Platform Tools from Google or run `weevil setup`.
 
 ### "Build failed"
 
@@ -437,6 +637,9 @@ cd my-robot
 
 # Check SDK path
 weevil config .
+
+# Verify system health
+weevil doctor
 ```
 
 ### "Deploy failed - No devices"
@@ -451,6 +654,24 @@ weevil config .
 2. Find Control Hub IP (usually 192.168.43.1 or 192.168.49.1)
 3. Try `./deploy.sh -i <ip>`
 
+### Android Studio: "Unknown run configuration type ShellScript"
+
+The Shell Script plugin is not installed. See [Android Studio Setup](#android-studio-setup) for installation instructions.
+
+### Proxy Issues
+
+```bash
+# Test proxy connectivity
+weevil --proxy http://proxy:8080 sdk status
+
+# Bypass proxy if it's causing issues
+weevil --no-proxy setup
+
+# Check environment variables
+echo $HTTPS_PROXY
+echo $HTTP_PROXY
+```
+
 ---
 
 ## Contributing
@@ -490,6 +711,7 @@ Like the boll weevil that bores through complex cotton bolls to reach the valuab
 3. **Testability** - Enable TDD and proper testing workflows  
 4. **Simplicity** - One command should do one obvious thing
 5. **Transparency** - Students should understand what's happening
+6. **Tool compatibility** - Work with tools students already know
 
 ---
 
@@ -511,28 +733,33 @@ Built with frustration at unnecessarily complex robotics frameworks, and hope th
 
 ## Project Status
 
-**Current Version:** 1.0.0
+**Current Version:** 1.1.0
 
 **What Works:**
 - ✅ Project generation
 - ✅ Cross-platform build/deploy
-- ✅ SDK management
+- ✅ SDK management and auto-install
 - ✅ Configuration management
 - ✅ Project upgrades
-- ✅ Local testing
+- ✅ Local unit testing
+- ✅ System diagnostics (`weevil doctor`)
+- ✅ Selective uninstall
+- ✅ Proxy support for corporate/air-gapped environments
+- ✅ Android Studio integration with one-click deployment
 
 **Roadmap:**
 - 📋 Package management for FTC libraries
 - 📋 Template system for common robot configurations
-- 📋 IDE integration (VS Code, IntelliJ)
+- 📋 VS Code integration
 - 📋 Team collaboration features
 - 📋 Automated testing on robot hardware
+- 📋 Multi-robot support (manage multiple Control Hubs)
 
 ---
 
 **Questions? Issues? Suggestions?**
 
-📧 Email: [eric@nxlearn.net](mailto:eric@nxlearn.net)
+📧 Email: [eric@nxlearn.net](mailto:eric@nxlearn.net)  
 🐛 Issues: Open an issue on the repository
 
-Building better tools so you can build better robots. 🤖
+Building better tools so you can build better robots. 🤖

docs/ROADMAP.md

@@ -2,15 +2,24 @@
 
 This document outlines the planned feature development for Weevil across multiple versions. Features are subject to change based on user feedback, technical constraints, and market needs.
 
+## Status Key
+
+- ✅ **Complete** - Feature shipped in a release
+- ⚠️ **In Progress** - Currently being developed
+- 🔄 **Deferred** - Planned but postponed to a later version
+- ❌ **Cancelled** - Feature dropped from roadmap
+
 ---
 
-## Version 1.1.0 - Core Stability & Team Adoption
+## Version 1.1.0 - Core Stability & Team Adoption ✅ COMPLETE
 
 **Theme:** Making Weevil production-ready for FTC teams with essential operational features and reducing friction in existing workflows.
 
-### System Audit & Diagnostics
+**Status:** Released as v1.1.0-beta.2 (pending Windows testing)
 
-**Feature:** `weevil status` or `weevil doctor` command
+### System Audit & Diagnostics ✅
+
+**Feature:** `weevil doctor` command
 
 **Description:** Provides a comprehensive audit of the development environment, showing what's installed and what versions are present. This would display:
 - FTC SDK versions (current and available)
@@ -20,6 +29,8 @@ This document outlines the planned feature development for Weevil across multipl
 - ADB availability and version
 - Any other critical dependencies Weevil manages
 
+**Status:** ✅ Complete - Shipped in v1.1.0
+
 **Rationale:** Teams need visibility into their environment to troubleshoot issues. Coaches working with multiple machines need to quickly verify setup consistency across laptops. This builds trust by making Weevil's actions transparent.
 
 **Pros:**
@@ -33,13 +44,11 @@ This document outlines the planned feature development for Weevil across multipl
 - Version detection across platforms may be fragile
 - Output formatting needs to be clear for non-technical users
 
-**Priority:** HIGH - Essential for v1.1.0
-
 ---
 
-### Dependency Cleanup
+### Dependency Cleanup ✅
 
-**Feature:** `weevil clean` or `weevil uninstall` command
+**Feature:** `weevil uninstall` command
 
 **Description:** Removes dependencies that Weevil installed during setup. This includes:
 - FTC SDK files
@@ -47,7 +56,9 @@ This document outlines the planned feature development for Weevil across multipl
 - Gradle distributions
 - Configuration files Weevil created
 
-Should offer options for selective cleanup (e.g., keep SDK but remove Gradle) or complete removal.
+Offers options for selective cleanup (e.g., keep SDK but remove Gradle) or complete removal.
+
+**Status:** ✅ Complete - Shipped in v1.1.0
 
 **Rationale:** Teams switch machines, need to free disk space, or want to start fresh. Without a clean uninstall, Weevil leaves artifacts behind. This is critical for maintaining system hygiene and building confidence that Weevil doesn't pollute the environment.
 
@@ -61,11 +72,9 @@ Should offer options for selective cleanup (e.g., keep SDK but remove Gradle) or
 - Risk of removing shared dependencies other tools need
 - Need careful confirmation prompts to prevent accidental deletion
 
-**Priority:** HIGH - Essential for v1.1.0
-
 ---
 
-### Corporate/School Proxy Support
+### Corporate/School Proxy Support ✅
 
 **Feature:** Transparent proxy configuration for all network operations
 
@@ -77,6 +86,10 @@ Should offer options for selective cleanup (e.g., keep SDK but remove Gradle) or
 
 Handle `HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY` environment variables and write appropriate configuration into Gradle properties, Android SDK manager config, etc.
 
+**Status:** ✅ Complete - Shipped in v1.1.0
+
+**Implementation:** `--proxy <url>` and `--no-proxy` global flags, automatic HTTPS_PROXY/HTTP_PROXY env var detection
+
 **Rationale:** Many FTC teams work in schools or corporate environments with mandatory proxy servers. Without proxy support, Weevil is unusable in these environments, cutting off a significant portion of the potential user base.
 
 **Pros:**
@@ -90,11 +103,9 @@ Handle `HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY` environment variables and write a
 - SSL/certificate issues in corporate environments
 - Testing requires access to proxy environments
 
-**Priority:** HIGH - Essential for v1.1.0
-
 ---
 
-### Android Studio Integration
+### Android Studio Integration ✅
 
 **Feature:** Seamless integration with Android Studio IDE
 
@@ -103,10 +114,15 @@ Handle `HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY` environment variables and write a
 - Present a clean, minimal file tree to students
 - Hook Weevil's build and deploy scripts into Android Studio's "Run" button
 - Properly configure the IDE's indexing and code completion
-- Support debugging integration
 
 The goal: students work in Android Studio (the tool they know) but get Weevil's improved project structure and deployment workflow behind the scenes.
 
+**Status:** ✅ Complete - Shipped in v1.1.0-beta.2
+
+**Implementation:** Auto-generated `.idea/` run configurations (Build, Deploy auto/USB/WiFi, Test), workspace.xml for clean file tree, cross-platform support (Unix .sh and Windows .bat variants)
+
+**Note:** Requires Shell Script plugin installation in Android Studio (documented in README)
+
 **Rationale:** This is the killer feature that bridges the gap between Weevil's better engineering practices and students' existing workflow. Kids already know Android Studio. Making Weevil "just work" with it removes adoption friction and lets them focus on robot code, not tooling.
 
 **Pros:**
@@ -116,16 +132,14 @@ The goal: students work in Android Studio (the tool they know) but get Weevil's
 - Makes Weevil invisible in the best way - it just works
 
 **Cons:**
-- Android Studio project file format may change
+- Android Studio project file format may change between versions
 - Complex to test across different Android Studio versions
 - May conflict with students' existing Android Studio customizations
-- Requires deep understanding of IDE configuration
+- Requires Shell Script plugin (one-time setup)
-
-**Priority:** HIGH - Strong candidate for v1.1.0 (killer feature)
 
 ---
 
-### Manual Installation Fallback Documentation
+### Manual Installation Fallback Documentation 🔄
 
 **Feature:** Comprehensive manual setup documentation
 
@@ -136,6 +150,8 @@ The goal: students work in Android Studio (the tool they know) but get Weevil's
 - Checksums for verifying downloads
 - Fallback download URLs if primary sources are blocked
 
+**Status:** 🔄 Deferred to v1.2.0 - Basic troubleshooting exists in README, comprehensive guide pending
+
 **Rationale:** Automation fails. Proxies block downloads. Firewalls interfere. Having a "guaranteed to work" manual path builds confidence and ensures teams aren't stuck. This is about providing an escape hatch and building trust.
 
 **Pros:**
@@ -149,11 +165,9 @@ The goal: students work in Android Studio (the tool they know) but get Weevil's
 - Screenshots go stale quickly
 - Platform variations multiply documentation burden
 
-**Priority:** MEDIUM-HIGH - Strong candidate for v1.1.0
-
 ---
 
-### Package Distribution (Debian/Ubuntu)
+### Package Distribution (Debian/Ubuntu) 🔄
 
 **Feature:** `.deb` package for easy installation on Debian-based systems
 
@@ -163,6 +177,8 @@ The goal: students work in Android Studio (the tool they know) but get Weevil's
 - Handle any system dependencies
 - Support clean uninstallation
 
+**Status:** 🔄 Deferred - Not essential for initial adoption
+
 **Rationale:** Provides a "professional" distribution method for Linux users. Makes Weevil feel like real software, not just a script. Easier for schools/teams to deploy across multiple machines.
 
 **Pros:**
@@ -177,14 +193,76 @@ The goal: students work in Android Studio (the tool they know) but get Weevil's
 - Most teams will just download the binary anyway
 - Not essential for functionality
 
-**Priority:** LOW - Nice to have, but not essential for v1.1.0
-
 ---
 
 ## Version 1.2.0 - Polish & Accessibility
 
 **Theme:** Making Weevil accessible to non-technical users and expanding platform support.
 
+**Status:** Planning
+
+### Android Studio Debugging Support
+
+**Feature:** Full debugging integration for Android Studio
+
+**Description:** Extend the Android Studio integration to support breakpoint debugging directly from the IDE:
+- Generate debug run configurations that attach to the robot
+- Configure remote debugging for Android/FTC apps
+- Map source files correctly for breakpoint support
+- Handle ADB debugging bridge setup automatically
+- Support both USB and WiFi debugging
+
+Students should be able to:
+1. Set breakpoints in their OpMode code
+2. Select "Debug" configuration from Android Studio
+3. Click the debug button (🐛)
+4. Have the debugger attach to the running robot
+5. Step through code, inspect variables, etc.
+
+**Rationale:** Debugging is a critical skill, and print-statement debugging (`telemetry.addData()`) is primitive. Teaching students to use a real debugger makes them better engineers. This feature positions Weevil as a complete development environment, not just a build tool.
+
+**Pros:**
+- Massive educational value - teaches proper debugging
+- Competitive advantage (official SDK doesn't make this easy)
+- Natural extension of existing Android Studio integration
+- Students already familiar with debuggers from other IDEs
+
+**Cons:**
+- Android debugging setup is complex (ADB, JDWP, remote attach)
+- WiFi debugging is finicky and may be unreliable
+- Debugging autonomous modes has timing implications
+- Requires deep understanding of Android debug protocol
+- May not work reliably on all Control Hub firmware versions
+
+**Priority:** HIGH - Natural next step after basic Android Studio integration
+
+**Technical Notes:**
+- Need to generate Android Studio remote debug configurations
+- May require modifications to deploy scripts to enable debug mode
+- JDWP (Java Debug Wire Protocol) over ADB
+- Consider "Debug (USB)" and "Debug (WiFi)" separate configurations
+
+---
+
+### Windows Testing & Stabilization
+
+**Feature:** Complete Windows support verification
+
+**Description:** Comprehensive testing of all v1.1.0 features on Windows 10 and Windows 11:
+- Proxy support with Windows-specific quirks
+- Android Studio integration with Windows paths
+- Build and deployment scripts (`.bat` files)
+- Gradle wrapper on Windows
+- Path handling (backslashes vs. forward slashes)
+
+**Status:** Required before v1.1.0 final release
+
+**Rationale:** Many FTC teams use Windows. Can't ship v1.1.0 final without Windows verification.
+
+**Priority:** CRITICAL - Blocks v1.1.0 final release
+
+---
+
 ### Windows Installer (MSI)
 
 **Feature:** Professional Windows installer package
@@ -196,6 +274,8 @@ The goal: students work in Android Studio (the tool they know) but get Weevil's
 - Appears in "Programs and Features" for clean uninstall
 - Optionally creates desktop shortcut
 
+**Status:** Planned for v1.2.0
+
 **Rationale:** Windows users expect installers, not loose executables. An MSI makes Weevil feel professional and legitimate. Start menu integration makes it discoverable.
 
 **Pros:**
@@ -562,7 +642,40 @@ This makes adding new languages easier and keeps core clean.
 
 ## Unscheduled / Research Needed
 
+### SOCKS Proxy Support
+
+**Feature:** Support for SOCKS4/SOCKS5 proxies in addition to HTTP proxies
+
+**Description:** Extend proxy support to handle SOCKS proxies, which are common in certain corporate and academic environments:
+- Auto-detect SOCKS proxy from environment variables
+- Support SOCKS4, SOCKS5, and SOCKS5h protocols
+- Handle authentication if required
+- Configure all network operations (Gradle, SDK downloads, Git) to use SOCKS
+
+**Status:** Research - needs market validation
+
+**Rationale:** Some environments use SOCKS proxies instead of HTTP proxies. While HTTP proxy support covers most cases, SOCKS support would enable Weevil in additional restricted environments.
+
+**Pros:**
+- Broader environment support
+- Some corporate networks mandate SOCKS
+- Demonstrates thoroughness
+
+**Cons:**
+- More complex than HTTP proxy (different protocols)
+- Smaller user base than HTTP proxy
+- Not all tools (Gradle, Git) support SOCKS equally well
+- May require native library integration (e.g., libcurl with SOCKS support)
+- Authentication adds complexity
+
+**Priority:** LOW - HTTP proxy covers most use cases
+
+**Decision Point:** Wait for user requests. If teams need SOCKS support, prioritize accordingly.
+
+---
+
 ### Cloud Build Services
+
 **Description:** Remote build servers for teams with slow computers. Teams push code, Weevil builds in the cloud, streams back APK.
 
 **Status:** Research - needs cost/benefit analysis, infrastructure planning
@@ -570,6 +683,7 @@ This makes adding new languages easier and keeps core clean.
 ---
 
 ### VS Code Extension
+
 **Description:** Extension for VS Code to provide similar integration as Android Studio.
 
 **Status:** Research - depends on VS Code adoption in FTC community
@@ -577,6 +691,7 @@ This makes adding new languages easier and keeps core clean.
 ---
 
 ### Team Collaboration Features
+
 **Description:** Features for teams to coordinate across multiple developers - shared configurations, code review integration, task tracking.
 
 **Status:** Research - needs market validation (do teams want this?)
@@ -584,6 +699,7 @@ This makes adding new languages easier and keeps core clean.
 ---
 
 ### Custom Hardware Support
+
 **Description:** Templates and tools for teams using custom sensors or actuators beyond standard FTC parts.
 
 **Status:** Research - depends on community need
@@ -624,4 +740,4 @@ Features may be accelerated, deferred, or cancelled as the project evolves.
 
 ---
 
-*Last Updated: January 2026*
+*Last Updated: February 2026*

docs/TEMPLATE-PACKAGE-SPEC.md

@@ -0,0 +1,767 @@
+# Weevil Template & Package System - Complete Specification
+
+**Version:** 1.0  
+**Date:** February 2, 2026  
+**Status:** Ready for implementation
+
+---
+
+## Executive Summary
+
+This document specifies two complementary features for Weevil:
+
+1. **`weevil create` (v1.1.0)** - Project scaffolding with templates
+2. **`weevil add` (v1.2.0)** - Package management system
+
+Together, these enable teams to start with professional code and extend projects with community-shared components.
+
+---
+
+## Part 1: `weevil create` Command
+
+### Overview
+
+**Purpose:** Generate complete FTC robot projects from templates
+
+**Version:** v1.1.0-beta.3  
+**Priority:** HIGH
+
+### Command Syntax
+
+```bash
+weevil create <project-name> [OPTIONS]
+
+OPTIONS:
+  --template <name>    Template to use (default: "basic")
+  --path <directory>   Where to create project (default: current dir)
+  --force              Overwrite existing directory
+  --no-init            Don't initialize git repository
+  --dry-run            Show what would be created
+```
+
+### Templates (v1.1.0)
+
+#### Template 1: `basic` (Default)
+
+**Purpose:** Minimal starting point
+
+**Structure:**
+```
+my-robot/
+├── src/
+│   ├── main/java/robot/
+│   │   └── opmodes/
+│   │       └── BasicOpMode.java
+│   └── test/java/robot/
+│       └── .gitkeep
+├── build.gradle
+├── settings.gradle
+├── .weevil.toml
+├── .gitignore
+├── README.md
+└── build.bat / build.sh
+```
+
+**Files:** ~10  
+**Code:** ~50 lines
+
+#### Template 2: `testing` (Showcase)
+
+**Purpose:** Professional testing demonstration
+
+**Includes:**
+- 3 subsystems (MotorCycler, WallApproach, TurnController)
+- 6 hardware interfaces + FTC implementations
+- 6 test mocks
+- 45 passing tests
+- Complete documentation (6 files)
+
+**Files:** ~30  
+**Code:** ~2,500 lines  
+**Tests:** 45 (< 2 sec runtime)
+
+**Documentation:**
+- README.md
+- DESIGN_AND_TEST_PLAN.md
+- TESTING_GUIDE.md
+- TESTING_SHOWCASE.md
+- SOLUTION.md
+- ARCHITECTURE.md
+
+### Usage Examples
+
+```bash
+# Create minimal project
+weevil create my-robot
+
+# Create with testing template
+weevil create my-robot --template testing
+
+# Create in specific location
+weevil create my-robot --template testing --path ~/ftc-projects
+
+# Preview without creating
+weevil create my-robot --template testing --dry-run
+```
+
+### Variable Substitution
+
+Templates support variables:
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{{PROJECT_NAME}}` | Project directory name | `my-robot` |
+| `{{PACKAGE_NAME}}` | Java package name | `myrobot` |
+| `{{CREATION_DATE}}` | ISO 8601 timestamp | `2026-02-02T10:30:00Z` |
+| `{{WEEVIL_VERSION}}` | Weevil version | `1.1.0` |
+| `{{TEMPLATE_NAME}}` | Template used | `testing` |
+
+**Example:**
+```java
+// File: src/main/java/robot/subsystems/Example.java
+// Generated by Weevil {{WEEVIL_VERSION}} on {{CREATION_DATE}}
+package robot.{{PACKAGE_NAME}};
+```
+
+Becomes:
+```java
+// Generated by Weevil 1.1.0 on 2026-02-02T10:30:00Z
+package robot.myrobot;
+```
+
+### Success Output
+
+```
+✓ Created FTC project 'my-robot' using template 'testing'
+
+Next steps:
+  cd my-robot
+  weevil test        # Run 45 tests (< 2 seconds)
+  weevil build       # Build APK
+  weevil deploy      # Deploy to robot
+
+Documentation:
+  README.md                    - Project overview
+  DESIGN_AND_TEST_PLAN.md     - System architecture
+  TESTING_GUIDE.md            - Testing patterns
+```
+
+### Implementation Notes
+
+**Storage Location:**
+```
+~/.weevil/templates/
+├── basic/
+│   ├── template.toml
+│   └── files/
+└── testing/
+    ├── template.toml
+    └── files/
+```
+
+**Effort Estimate:** 2-3 days  
+**Complexity:** MEDIUM
+
+---
+
+## Part 2: `weevil add` Command
+
+### Overview
+
+**Purpose:** Add components to existing projects
+
+**Version:** v1.2.0  
+**Priority:** MEDIUM-HIGH
+
+### Command Syntax
+
+```bash
+weevil add <package> [OPTIONS]
+
+OPTIONS:
+  --force          Overwrite conflicting files
+  --merge          Attempt to merge conflicts (experimental)
+  --interactive    Prompt for each conflict
+  --dry-run        Preview without adding
+  --no-deps        Don't install dependencies
+  --dev            Add as dev dependency
+```
+
+### Package Naming
+
+Hierarchical structure: `scope/category/name/variant`
+
+**Examples:**
+```
+nexus/hardware/dc-motor/core
+nexus/hardware/dc-motor/mock
+nexus/hardware/dc-motor/example
+nexus/hardware/dc-motor/complete
+
+nexus/subsystems/wall-approach/complete
+nexus/examples/autonomous/simple-auto
+
+team1234/sensors/custom-lidar/core
+```
+
+**Components:**
+- **scope**: Publisher (nexus, team1234, etc.)
+- **category**: Type (hardware, subsystems, examples, testing)
+- **name**: Component name (dc-motor, wall-approach)
+- **variant**: Implementation (core, mock, example, complete)
+
+### Standard Variants
+
+| Variant | Contents | Dependencies |
+|---------|----------|--------------|
+| `core` | Interface + FTC wrapper | None |
+| `mock` | Test double | Requires core |
+| `example` | Example OpMode | Requires core |
+| `complete` | All of above | Includes all variants |
+
+### Usage Examples
+
+```bash
+# Add complete package
+weevil add nexus/hardware/dc-motor
+
+# Add specific variant
+weevil add nexus/hardware/dc-motor/core
+weevil add nexus/hardware/dc-motor/mock
+
+# Add subsystem (auto-installs dependencies)
+weevil add nexus/subsystems/wall-approach/complete
+
+# Preview
+weevil add nexus/hardware/servo/core --dry-run
+
+# Force overwrite
+weevil add nexus/hardware/gyro/complete --force
+
+# Interactive resolution
+weevil add nexus/subsystems/turn-controller/core --interactive
+```
+
+### Dependency Resolution
+
+Packages declare dependencies in manifest:
+
+```toml
+[dependencies]
+"nexus/hardware/distance/core" = "^2.0.0"
+"nexus/hardware/dc-motor/core" = "^1.0.0"
+
+[dev-dependencies]
+"nexus/testing/mock-base" = "^1.0.0"
+```
+
+**Automatic Resolution:**
+```bash
+weevil add nexus/subsystems/wall-approach/complete
+
+Installing:
+  1. nexus/hardware/distance/core (v2.1.0) - dependency
+  2. nexus/hardware/dc-motor/core (v1.2.0) - dependency
+  3. nexus/subsystems/wall-approach/complete (v1.0.0)
+
+✓ Added 3 packages (15 files)
+```
+
+### Conflict Handling
+
+#### Default (Skip)
+
+```
+⚠ File conflicts detected:
+  src/main/java/robot/hardware/MotorController.java (exists)
+
+Resolution: Skipping conflicting files
+
+Added:
+  ✓ src/main/java/robot/hardware/FtcMotorController.java
+
+Skipped:
+  ⊗ MotorController.java (already exists)
+```
+
+#### Force Mode
+
+```bash
+weevil add nexus/hardware/dc-motor/core --force
+
+⚠ Warning: --force will overwrite 2 files
+Continue? [y/N]: y
+
+✓ Overwrote 2 files, added 3 files
+```
+
+#### Interactive Mode
+
+```bash
+weevil add nexus/hardware/dc-motor/core --interactive
+
+Conflict: MotorController.java
+
+Options:
+  [s] Skip (keep your file)
+  [o] Overwrite (use package file)
+  [d] Show diff
+  [a] Abort
+
+Choice [s]: d
+
+Diff:
+  --- Existing
+  +++ Package
+  @@ -5,3 +5,5 @@
+   public interface MotorController {
+       void setPower(double power);
+       double getPower();
+  +    void setMode(RunMode mode);
+  +    RunMode getMode();
+   }
+
+Choice [s]:
+```
+
+### Package Categories
+
+#### `hardware/*`
+Physical hardware abstractions
+
+**Subcategories:**
+- `hardware/motors/*` - Motor controllers
+- `hardware/sensors/*` - Sensor interfaces
+- `hardware/servos/*` - Servo controllers
+- `hardware/vision/*` - Camera systems
+- `hardware/imu/*` - Gyroscopes
+
+**Standard Variants:** core, mock, example, complete
+
+#### `subsystems/*`
+Robot subsystems built on hardware
+
+**Examples:**
+- `subsystems/drivetrain/*`
+- `subsystems/arm/*`
+- `subsystems/intake/*`
+
+**Standard Variants:** core, mock, example, complete
+
+#### `examples/*`
+Complete working examples
+
+**Subcategories:**
+- `examples/autonomous/*`
+- `examples/teleop/*`
+- `examples/vision/*`
+
+**Variants:** Usually standalone (no variants)
+
+#### `testing/*`
+Testing utilities and patterns
+
+**Examples:**
+- `testing/mock-hardware` - Mock collection
+- `testing/test-patterns` - Reusable patterns
+- `testing/assertions` - Custom assertions
+
+#### `utilities/*`
+Helper utilities
+
+**Examples:**
+- `utilities/math/*`
+- `utilities/telemetry/*`
+- `utilities/logging/*`
+
+### Package Manifest
+
+**Example (`package.toml`):**
+
+```toml
+[package]
+name = "dc-motor"
+scope = "nexus"
+category = "hardware"
+version = "1.2.0"
+description = "DC motor controller interface and FTC implementation"
+license = "MIT"
+authors = ["Nexus Workshops <info@nxgit.dev>"]
+
+[variants]
+available = ["core", "mock", "example", "complete"]
+default = "complete"
+
+[dependencies]
+# Empty for base hardware
+
+[files.core]
+include = [
+    "src/main/java/robot/hardware/MotorController.java",
+    "src/main/java/robot/hardware/FtcMotorController.java"
+]
+
+[files.mock]
+include = ["src/test/java/robot/hardware/MockMotorController.java"]
+dependencies = ["core"]
+
+[files.example]
+include = ["src/main/java/robot/opmodes/examples/MotorExample.java"]
+dependencies = ["core"]
+
+[files.complete]
+dependencies = ["core", "mock", "example"]
+```
+
+### Package Repository
+
+**Location:** https://packages.nxgit.dev
+
+**Structure:**
+```
+packages.nxgit.dev/
+├── index.json
+├── nexus/
+│   ├── hardware/
+│   │   ├── dc-motor/
+│   │   │   ├── package.toml
+│   │   │   ├── core.tar.gz
+│   │   │   ├── mock.tar.gz
+│   │   │   └── complete.tar.gz
+│   │   └── distance/...
+│   └── subsystems/...
+└── team1234/...
+```
+
+### Implementation Notes
+
+**Effort Estimate:** 2-3 weeks  
+**Complexity:** HIGH
+
+**Key Components:**
+1. Package registry (hosted)
+2. Dependency resolver
+3. Conflict detector
+4. File installer
+5. Supporting commands (remove, search, list)
+
+---
+
+## Supporting Commands
+
+### `weevil remove`
+
+Remove installed package
+
+```bash
+weevil remove <package> [--prune] [--force]
+```
+
+### `weevil search`
+
+Search package registry
+
+```bash
+weevil search <query>
+
+Output:
+  nexus/hardware/mecanum-drive/complete
+    Mecanum drive system with holonomic control
+    ★★★★★ (342 downloads)
+```
+
+### `weevil list`
+
+List packages
+
+```bash
+weevil list --installed        # Show installed
+weevil list --available        # Show all available
+```
+
+### `weevil info`
+
+Show package details
+
+```bash
+weevil info nexus/hardware/dc-motor/complete
+
+Package: nexus/hardware/dc-motor/complete
+Version: 1.2.0
+Downloads: 1,523
+License: MIT
+
+Description:
+  DC motor controller with interface, FTC implementation,
+  test mocks, and examples.
+```
+
+### `weevil update`
+
+Update packages to latest versions
+
+```bash
+weevil update                  # Update all
+weevil update <package>        # Update specific
+```
+
+---
+
+## Strategic Benefits
+
+### For Teams
+- **Faster start** - Working code immediately
+- **Best practices** - Learn from examples
+- **Code reuse** - Don't reinvent wheels
+- **Community** - Share solutions
+
+### For Nexus Workshops
+- **Authority** - Set FTC code standards
+- **Network effects** - More packages = more value
+- **Revenue** - Workshops teach patterns
+- **Differentiation** - Unique offering
+
+### For FTC Community
+- **Quality** - Raised bar across teams
+- **Collaboration** - Build on each other
+- **Education** - Professional patterns
+- **Innovation** - Focus on unique solutions
+
+---
+
+## Success Metrics
+
+### v1.1.0 (create)
+- [ ] 50+ teams use testing template in first month
+- [ ] Positive feedback on quality
+- [ ] Used in Nexus Workshops curriculum
+- [ ] Documentation complete
+
+### v1.2.0 (add)
+- [ ] 20+ quality packages at launch
+- [ ] 100+ downloads first month
+- [ ] 5+ community packages
+- [ ] Active ecosystem
+
+---
+
+## Implementation Roadmap
+
+### Phase 1: v1.1.0 (2-3 days)
+
+**`weevil create` command:**
+- [ ] Template storage system
+- [ ] Variable substitution
+- [ ] Basic template
+- [ ] Testing template
+- [ ] Git initialization
+- [ ] Success/error messages
+- [ ] Documentation
+- [ ] Tests
+
+### Phase 2: v1.2.0 (2-3 weeks)
+
+**`weevil add` command:**
+- [ ] Package registry setup
+- [ ] Package manifest format
+- [ ] Dependency resolver
+- [ ] Conflict detection
+- [ ] File installation
+- [ ] Remove command
+- [ ] Search command
+- [ ] List command
+- [ ] 10+ launch packages
+- [ ] Documentation
+- [ ] Tests
+
+---
+
+## Initial Package Set (v1.2.0 Launch)
+
+**Must Have (10 packages):**
+
+1. nexus/hardware/dc-motor/complete
+2. nexus/hardware/servo/complete
+3. nexus/hardware/distance/complete
+4. nexus/hardware/imu/complete
+5. nexus/hardware/color-sensor/complete
+6. nexus/subsystems/wall-approach/complete
+7. nexus/subsystems/turn-controller/complete
+8. nexus/testing/mock-hardware
+9. nexus/examples/autonomous/simple-auto
+10. nexus/examples/teleop/basic-drive
+
+**Nice to Have (+5):**
+
+11. nexus/hardware/mecanum-drive/complete
+12. nexus/subsystems/april-tag/complete
+13. nexus/examples/autonomous/complex-auto
+14. nexus/utilities/telemetry/dashboard
+15. nexus/testing/test-patterns
+
+---
+
+## Package Quality Standards
+
+**Required (All Packages):**
+- ✅ Valid package.toml
+- ✅ License specified
+- ✅ README included
+- ✅ Compiles without errors
+
+**Recommended (Verified Badge):**
+- ✅ Tests included
+- ✅ Comprehensive docs
+- ✅ Interface-based design
+- ✅ No hardcoded values
+- ✅ Follows naming conventions
+
+**Nexus Verified:**
+- All required + recommended
+- Professional code quality
+- Full test coverage
+- Maintained and supported
+
+---
+
+## Future Enhancements
+
+### v1.3.0+
+- Package signing (GPG)
+- Private registries
+- `weevil publish` command
+- Package mirrors
+- Offline mode
+
+### v2.0.0+
+- Binary packages
+- Pre-built libraries
+- Cloud builds
+- Team collaboration features
+
+---
+
+## Open Questions
+
+1. **Versioning:** How handle breaking changes?
+2. **Testing:** Require tests in packages?
+3. **Licensing:** Enforce compliance?
+4. **Moderation:** Who approves packages?
+5. **Private packages:** Support team-private?
+6. **Namespaces:** Use team numbers?
+7. **Binary support:** Allow compiled code?
+8. **Update notifications:** Alert on updates?
+9. **Code signing:** Security/trust model?
+10. **Monorepo:** Where store templates/packages?
+
+---
+
+## References
+
+- **npm** - Node package manager (scopes, registry)
+- **Cargo** - Rust package manager (semver, crates.io)
+- **FreeBSD Ports** - Package system inspiration
+- **Maven Central** - Java repository patterns
+- **Homebrew** - macOS package management
+
+---
+
+## Appendix: Complete Examples
+
+### Example 1: Creating Project
+
+```bash
+$ weevil create my-robot --template testing
+
+Creating FTC project 'my-robot'...
+
+✓ Created directory structure
+✓ Generated source files (17 files)
+✓ Generated test files (4 files)
+✓ Created build configuration
+✓ Generated documentation (6 files)
+✓ Initialized Git repository
+
+Project created successfully!
+
+Next steps:
+  cd my-robot
+  weevil test              # 45 tests pass in < 2 sec
+  weevil build             # Build APK
+  weevil deploy --auto     # Deploy to robot
+
+Documentation:
+  README.md                     - Overview
+  DESIGN_AND_TEST_PLAN.md       - Architecture
+  TESTING_GUIDE.md              - How to test
+```
+
+### Example 2: Adding Package
+
+```bash
+$ cd my-robot
+$ weevil add nexus/subsystems/mecanum-drive/complete
+
+Resolving dependencies...
+
+Package nexus/subsystems/mecanum-drive/complete requires:
+  - nexus/hardware/dc-motor/core (v1.2.0)
+  - nexus/hardware/imu/core (v2.0.0)
+
+Installing 3 packages:
+  1. nexus/hardware/dc-motor/core (v1.2.0)
+  2. nexus/hardware/imu/core (v2.0.0)
+  3. nexus/subsystems/mecanum-drive/complete (v2.1.0)
+
+✓ Added 12 source files
+✓ Added 8 test files
+✓ Updated build.gradle
+
+Package installed successfully!
+
+Next steps:
+  See docs/subsystems/MECANUM_DRIVE.md for usage
+  Run weevil test to verify integration
+```
+
+### Example 3: Handling Conflicts
+
+```bash
+$ weevil add nexus/hardware/dc-motor/core
+
+⚠ File conflict detected:
+  src/main/java/robot/hardware/MotorController.java (exists)
+
+Options:
+  1. Skip conflicting files (safe, default)
+  2. Overwrite conflicting files (--force)
+  3. Interactive resolution (--interactive)
+  4. Abort
+
+Choice [1]: 1
+
+Added:
+  ✓ src/main/java/robot/hardware/FtcMotorController.java
+  ✓ docs/hardware/DC_MOTOR.md
+
+Skipped:
+  ⊗ src/main/java/robot/hardware/MotorController.java
+
+Package partially installed (1 file skipped)
+
+Note: Package may not work correctly if required files skipped
+Consider using --force or --interactive for complete installation
+```
+
+---
+
+*End of Specification*
+
+**Status:** Ready for Implementation  
+**Next Steps:** 
+1. Implement `weevil create` for v1.1.0-beta.3
+2. Use testing showcase as `testing` template
+3. Plan v1.2.0 package system
+
+**Contact:** eric@intrepidfusion.com  
+**Organization:** Nexus Workshops LLC

src/commands/create.rs

@@ -0,0 +1,241 @@
+use anyhow::{Result, Context, bail};
+use colored::*;
+use std::path::{Path, PathBuf};
+use std::fs;
+use chrono::Utc;
+use crate::templates::TemplateManager;
+
+// Use Cargo's version macro instead of importing
+const WEEVIL_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+pub fn create_project(
+    name: &str,
+    template: Option<&str>,
+    path: Option<&str>,
+    force: bool,
+    no_init: bool,
+    dry_run: bool,
+) -> Result<()> {
+    // Validate project name
+    validate_project_name(name)?;
+    
+    // Determine output directory
+    let output_dir = if let Some(p) = path {
+        PathBuf::from(p).join(name)
+    } else {
+        PathBuf::from(name)
+    };
+    
+    // Check if directory exists
+    if output_dir.exists() && !force {
+        bail!(
+            "Directory '{}' already exists\nUse --force to overwrite",
+            output_dir.display()
+        );
+    }
+    
+    let template_name = template.unwrap_or("basic");
+    
+    println!("{}", format!("Creating FTC project '{}' with template '{}'...", name, template_name).bright_cyan().bold());
+    println!();
+    
+    if dry_run {
+        println!("{}", "DRY RUN - No files will be created".yellow().bold());
+        println!();
+    }
+    
+    // Load template manager
+    let template_mgr = TemplateManager::new()?;
+    
+    // Verify template exists
+    if !template_mgr.template_exists(template_name) {
+        bail!(
+            "Template '{}' not found\n\nAvailable templates:\n{}",
+            template_name,
+            template_mgr.list_templates().join("\n  ")
+        );
+    }
+    
+    // Prepare template context
+    let context = TemplateContext {
+        project_name: name.to_string(),
+        package_name: name.to_lowercase().replace("-", "").replace("_", ""),
+        creation_date: Utc::now().to_rfc3339(),
+        weevil_version: WEEVIL_VERSION.to_string(),
+        template_name: template_name.to_string(),
+    };
+    
+    if !dry_run {
+        // Create output directory
+        if force && output_dir.exists() {
+            println!("{}", "⚠ Removing existing directory...".yellow());
+            fs::remove_dir_all(&output_dir)?;
+        }
+        fs::create_dir_all(&output_dir)?;
+        
+        // Extract template
+        template_mgr.extract_template(template_name, &output_dir, &context)?;
+        
+        println!("{}", "✓ Created directory structure".green());
+        
+        // Initialize git repository
+        if !no_init {
+            init_git_repository(&output_dir, template_name)?;
+        }
+        
+        println!();
+        print_success_message(name, template_name);
+    } else {
+        println!("{}", format!("Would create project '{}' using template '{}'", name, template_name).bright_white());
+        println!("{}", format!("Output directory: {}", output_dir.display()).bright_white());
+        template_mgr.show_template_info(template_name)?;
+    }
+    
+    Ok(())
+}
+
+pub fn list_templates() -> Result<()> {
+    let template_mgr = TemplateManager::new()?;
+    
+    println!("{}", "Available templates:".bright_cyan().bold());
+    println!();
+    
+    for info in template_mgr.get_template_info_all()? {
+        println!("{}", format!("  {} {}", info.name, if info.is_default { "(default)" } else { "" }).bright_white().bold());
+        println!("    {}", info.description);
+        println!("    Files: {} | Lines: ~{}", info.file_count, info.line_count);
+        if info.test_count > 0 {
+            println!("    Tests: {} tests", info.test_count);
+        }
+        println!();
+    }
+    
+    println!("Use: weevil create <n> --template <template>");
+    
+    Ok(())
+}
+
+pub fn show_template(template_name: &str) -> Result<()> {
+    let template_mgr = TemplateManager::new()?;
+    
+    if !template_mgr.template_exists(template_name) {
+        bail!("Template '{}' not found", template_name);
+    }
+    
+    template_mgr.show_template_info(template_name)?;
+    
+    Ok(())
+}
+
+fn validate_project_name(name: &str) -> Result<()> {
+    if name.is_empty() {
+        bail!("Project name cannot be empty");
+    }
+    
+    if name.len() > 50 {
+        bail!("Project name must be 50 characters or less");
+    }
+    
+    // Check for valid characters
+    let valid = name.chars().all(|c| {
+        c.is_alphanumeric() || c == '-' || c == '_'
+    });
+    
+    if !valid {
+        bail!(
+            "Invalid project name '{}'\nProject names must:\n  - Contain only letters, numbers, hyphens, underscores\n  - Start with a letter\n  - Be 1-50 characters long\n\nValid examples:\n  my-robot\n  team1234_robot\n  competitionBot2024",
+            name
+        );
+    }
+    
+    // Must start with letter
+    if !name.chars().next().unwrap().is_alphabetic() {
+        bail!("Project name must start with a letter");
+    }
+    
+    Ok(())
+}
+
+fn init_git_repository(project_dir: &Path, template_name: &str) -> Result<()> {
+    use std::process::Command;
+    
+    // Check if git is available
+    let git_check = Command::new("git")
+        .arg("--version")
+        .output();
+    
+    if git_check.is_err() {
+        println!("{}", "⚠ Git not found, skipping repository initialization".yellow());
+        return Ok(());
+    }
+    
+    // Initialize repository
+    let status = Command::new("git")
+        .arg("init")
+        .current_dir(project_dir)
+        .output()
+        .context("Failed to initialize git repository")?;
+    
+    if !status.status.success() {
+        println!("{}", "⚠ Failed to initialize git repository".yellow());
+        return Ok(());
+    }
+    
+    // Create initial commit
+    Command::new("git")
+        .args(&["add", "."])
+        .current_dir(project_dir)
+        .output()
+        .ok();
+    
+    let commit_message = format!("Initial commit from weevil create --template {}", template_name);
+    Command::new("git")
+        .args(&["commit", "-m", &commit_message])
+        .current_dir(project_dir)
+        .output()
+        .ok();
+    
+    println!("{}", "✓ Initialized Git repository".green());
+    
+    Ok(())
+}
+
+fn print_success_message(project_name: &str, template_name: &str) {
+    println!("{}", "Project created successfully!".bright_green().bold());
+    println!();
+    println!("{}", "Next steps:".bright_cyan().bold());
+    println!("  cd {}", project_name);
+    
+    match template_name {
+        "testing" => {
+            println!("  weevil test              # Run 45 tests (< 2 seconds)");
+            println!("  weevil build             # Build APK for robot");
+            println!("  weevil deploy --auto     # Deploy to robot");
+            println!();
+            println!("{}", "Documentation:".bright_cyan().bold());
+            println!("  README.md                     - Project overview");
+            println!("  DESIGN_AND_TEST_PLAN.md       - System architecture");
+            println!("  TESTING_GUIDE.md              - How to write tests");
+        }
+        "basic" => {
+            println!("  weevil setup             # Setup development environment");
+            println!("  weevil build             # Build APK for robot");
+            println!("  weevil deploy            # Deploy to robot");
+        }
+        _ => {
+            println!("  weevil setup             # Setup development environment");
+            println!("  weevil build             # Build your robot code");
+        }
+    }
+    
+    println!();
+    println!("{}", format!("Learn more: https://docs.weevil.dev/templates/{}", template_name).bright_black());
+}
+
+pub struct TemplateContext {
+    pub project_name: String,
+    pub package_name: String,
+    pub creation_date: String,
+    pub weevil_version: String,
+    pub template_name: String,
+}

src/commands/mod.rs

@@ -5,4 +5,5 @@ pub mod sdk;
 pub mod config;
 pub mod setup;
 pub mod doctor;
-pub mod uninstall;
+pub mod uninstall;
+pub mod create;

src/commands/upgrade.rs

@@ -52,6 +52,19 @@ pub fn upgrade_project(path: &str) -> Result<()> {
         "gradle/wrapper/gradle-wrapper.properties",
         "gradle/wrapper/gradle-wrapper.jar",
         ".gitignore",
+        // Android Studio integration — regenerated so run configs stay in
+        // sync if deploy.sh flags or script names ever change.
+        ".idea/workspace.xml",
+        ".idea/runConfigurations/Build.xml",
+        ".idea/runConfigurations/Build (Windows).xml",
+        ".idea/runConfigurations/Deploy (auto).xml",
+        ".idea/runConfigurations/Deploy (auto) (Windows).xml",
+        ".idea/runConfigurations/Deploy (USB).xml",
+        ".idea/runConfigurations/Deploy (USB) (Windows).xml",
+        ".idea/runConfigurations/Deploy (WiFi).xml",
+        ".idea/runConfigurations/Deploy (WiFi) (Windows).xml",
+        ".idea/runConfigurations/Test.xml",
+        ".idea/runConfigurations/Test (Windows).xml",
     ];
     
     println!("{}", "Updating infrastructure files...".bright_yellow());

src/main.rs

@@ -3,12 +3,6 @@ use colored::*;
 use anyhow::Result;
 use weevil::version::WEEVIL_VERSION;
 
-// Import ProxyConfig through our own `mod sdk`, not through the `weevil`
-// library crate.  Both re-export the same source, but Rust treats
-// `weevil::sdk::proxy::ProxyConfig` and `sdk::proxy::ProxyConfig` as
-// distinct types when a binary and its lib are compiled together.
-// The command modules already see the local-mod version, so main must match.
-
 mod commands;
 mod sdk;
 mod project;
@@ -39,7 +33,41 @@ struct Cli {
 
 #[derive(Subcommand)]
 enum Commands {
-    /// Create a new FTC robot project
+    /// Create a new FTC robot project from a template
+    Create {
+        /// Name of the project to create
+        name: String,
+
+        /// Template to use (basic, testing)
+        #[arg(long, short = 't', value_name = "TEMPLATE")]
+        template: Option<String>,
+
+        /// Parent directory for the project (project will be created in <path>/<name>)
+        #[arg(long, value_name = "PATH")]
+        path: Option<String>,
+
+        /// Overwrite existing directory
+        #[arg(long)]
+        force: bool,
+
+        /// Don't initialize git repository
+        #[arg(long)]
+        no_init: bool,
+
+        /// Show what would be created without creating
+        #[arg(long)]
+        dry_run: bool,
+
+        /// List available templates
+        #[arg(long, exclusive = true)]
+        list_templates: bool,
+
+        /// Show detailed information about a template
+        #[arg(long, value_name = "TEMPLATE", exclusive = true)]
+        show_template: Option<String>,
+    },
+
+    /// Create a new FTC robot project (legacy - use 'create' instead)
     New {
         /// Name of the robot project
         name: String,
@@ -139,6 +167,31 @@ fn main() -> Result<()> {
     let proxy = ProxyConfig::resolve(cli.proxy.as_deref(), cli.no_proxy)?;
 
     match cli.command {
+        Commands::Create { 
+            name, 
+            template, 
+            path, 
+            force, 
+            no_init, 
+            dry_run, 
+            list_templates, 
+            show_template 
+        } => {
+            if list_templates {
+                commands::create::list_templates()
+            } else if let Some(tmpl) = show_template {
+                commands::create::show_template(&tmpl)
+            } else {
+                commands::create::create_project(
+                    &name,
+                    template.as_deref(),
+                    path.as_deref(),
+                    force,
+                    no_init,
+                    dry_run,
+                )
+            }
+        }
         Commands::New { name, ftc_sdk, android_sdk } => {
             commands::new::create_project(&name, ftc_sdk.as_deref(), android_sdk.as_deref(), &proxy)
         }

src/project/mod.rs

@@ -55,6 +55,7 @@ impl ProjectBuilder {
             "src/test/java/robot",
             "src/test/java/robot/subsystems",
             "gradle/wrapper",
+            ".idea/runConfigurations",
         ];
         
         for dir in dirs {
@@ -416,9 +417,307 @@ class BasicTest {
             test_file
         )?;
         
+        // Android Studio integration: .idea/ files
+        self.generate_idea_files(project_path)?;
+        
         Ok(())
     }
     
+    /// Generate .idea/ files for Android Studio integration.
+    ///
+    /// The goal is for students to open the project in Android Studio and see
+    /// a clean file tree (just src/ and the scripts) with Run configurations
+    /// that invoke Weevil's shell scripts directly.  All the internal plumbing
+    /// (sdk/, .gradle/, build/) is hidden from the IDE view.
+    ///
+    /// Android Studio uses IntelliJ's run configuration XML format.  The
+    /// ShellScript type invokes a script relative to the project root — exactly
+    /// what we want since deploy.sh and build.sh already live there.
+    fn generate_idea_files(&self, project_path: &Path) -> Result<()> {
+        // workspace.xml — controls the file-tree view and hides internals.
+        // We use a ProjectViewPane exclude pattern list rather than touching
+        // the module's source roots, so this works regardless of whether the
+        // student has opened the project before.
+        let workspace_xml = r#"<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectViewManager">
+    <state>
+      <navigator currentProjector="ProjectFiles" hideEmptyMiddlePackages="true" sortByType="true">
+        <state>
+          <expand>
+            <file url="file://$PROJECT_DIR$/src" />
+            <file url="file://$PROJECT_DIR$/src/main" />
+            <file url="file://$PROJECT_DIR$/src/main/java" />
+            <file url="file://$PROJECT_DIR$/src/main/java/robot" />
+            <file url="file://$PROJECT_DIR$/src/test" />
+            <file url="file://$PROJECT_DIR$/src/test/java" />
+            <file url="file://$PROJECT_DIR$/src/test/java/robot" />
+          </expand>
+        </state>
+      </navigator>
+    </state>
+  </component>
+  <component name="ExcludedFiles">
+    <file url="file://$PROJECT_DIR$/build" reason="Build output" />
+    <file url="file://$PROJECT_DIR$/.gradle" reason="Gradle cache" />
+    <file url="file://$PROJECT_DIR$/gradle" reason="Gradle wrapper internals" />
+  </component>
+</project>
+"#;
+        fs::write(project_path.join(".idea/workspace.xml"), workspace_xml)?;
+
+        // Run configurations.  Each is a ShellScript type that invokes one of
+        // Weevil's scripts.  Android Studio shows these in the Run dropdown
+        // at the top of the IDE — no configuration needed by the student.
+        //
+        // We generate both Unix (.sh, ./gradlew) and Windows (.bat, gradlew.bat)
+        // variants.  Android Studio automatically hides configs whose script files
+        // don't exist, so only the platform-appropriate ones appear in the dropdown.
+
+        // Build (Unix) — just builds the APK without deploying
+        let build_unix_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Build" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/build.sh" />
+    <option name="SCRIPT_OPTIONS" value="" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="/bin/bash" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Build.xml"),
+            build_unix_xml,
+        )?;
+
+        // Build (Windows) — same, but calls build.bat
+        let build_windows_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Build (Windows)" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/build.bat" />
+    <option name="SCRIPT_OPTIONS" value="" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="cmd.exe" />
+    <option name="INTERPRETER_OPTIONS" value="/c" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Build (Windows).xml"),
+            build_windows_xml,
+        )?;
+
+        // Deploy (auto) — no flags, deploy.sh auto-detects USB vs WiFi
+        let deploy_auto_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Deploy (auto)" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/deploy.sh" />
+    <option name="SCRIPT_OPTIONS" value="" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="/bin/bash" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Deploy (auto).xml"),
+            deploy_auto_xml,
+        )?;
+
+        // Deploy (auto) (Windows)
+        let deploy_auto_windows_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Deploy (auto) (Windows)" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/deploy.bat" />
+    <option name="SCRIPT_OPTIONS" value="" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="cmd.exe" />
+    <option name="INTERPRETER_OPTIONS" value="/c" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Deploy (auto) (Windows).xml"),
+            deploy_auto_windows_xml,
+        )?;
+
+        // Deploy (USB) — forces USB connection
+        let deploy_usb_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Deploy (USB)" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/deploy.sh" />
+    <option name="SCRIPT_OPTIONS" value="--usb" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="/bin/bash" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Deploy (USB).xml"),
+            deploy_usb_xml,
+        )?;
+
+        // Deploy (USB) (Windows)
+        let deploy_usb_windows_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Deploy (USB) (Windows)" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/deploy.bat" />
+    <option name="SCRIPT_OPTIONS" value="" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="cmd.exe" />
+    <option name="INTERPRETER_OPTIONS" value="/c" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Deploy (USB) (Windows).xml"),
+            deploy_usb_windows_xml,
+        )?;
+
+        // Deploy (WiFi) — forces WiFi connection to default 192.168.43.1
+        let deploy_wifi_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Deploy (WiFi)" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/deploy.sh" />
+    <option name="SCRIPT_OPTIONS" value="--wifi" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="/bin/bash" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Deploy (WiFi).xml"),
+            deploy_wifi_xml,
+        )?;
+
+        // Deploy (WiFi) (Windows)
+        let deploy_wifi_windows_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Deploy (WiFi) (Windows)" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/deploy.bat" />
+    <option name="SCRIPT_OPTIONS" value="" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="cmd.exe" />
+    <option name="INTERPRETER_OPTIONS" value="/c" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Deploy (WiFi) (Windows).xml"),
+            deploy_wifi_windows_xml,
+        )?;
+
+        // Test — runs the unit test suite via Gradle
+        let test_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Test" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/gradlew" />
+    <option name="SCRIPT_OPTIONS" value="test" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="/bin/bash" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Test.xml"),
+            test_xml,
+        )?;
+
+        // Test (Windows)
+        let test_windows_xml = r#"<component name="ProjectRunConfigurationManager">
+  <configuration name="Test (Windows)" type="ShConfigurationType">
+    <option name="SCRIPT_TEXT" value="" />
+    <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+    <option name="SCRIPT_PATH" value="$PROJECT_DIR$/gradlew.bat" />
+    <option name="SCRIPT_OPTIONS" value="test" />
+    <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+    <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+    <option name="INTERPRETER_PATH" value="cmd.exe" />
+    <option name="INTERPRETER_OPTIONS" value="/c" />
+    <option name="EXECUTE_IN_TERMINAL" value="true" />
+    <option name="EXECUTE_SCRIPT_FILE" value="true" />
+    <envs />
+    <method v="2" />
+  </configuration>
+</component>
+"#;
+        fs::write(
+            project_path.join(".idea/runConfigurations/Test (Windows).xml"),
+            test_windows_xml,
+        )?;
+
+
+        Ok(())
+    }
+
     fn setup_gradle(&self, project_path: &Path) -> Result<()> {
         println!("Setting up Gradle wrapper...");
         crate::sdk::gradle::setup_wrapper(project_path)?;

src/templates/mod.rs

@@ -1,101 +1,230 @@
 use include_dir::{include_dir, Dir};
 use std::path::Path;
-use anyhow::{Result, Context};
+use anyhow::{Result, Context, bail};
-use tera::{Tera, Context as TeraContext};
+use tera::Tera;
 use std::fs;
+use colored::*;
 
-// Embed all template files at compile time
+// Embed template directories at compile time
-static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
+static BASIC_TEMPLATE: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates/basic");
+static TESTING_TEMPLATE: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates/testing");
 
-pub struct TemplateEngine {
+pub struct TemplateManager {
     #[allow(dead_code)]
     tera: Tera,
 }
 
-impl TemplateEngine {
+pub struct TemplateInfo {
-    #[allow(dead_code)]
+    pub name: String,
+    pub description: String,
+    pub file_count: usize,
+    pub line_count: usize,
+    pub test_count: usize,
+    pub is_default: bool,
+}
+
+impl TemplateManager {
     pub fn new() -> Result<Self> {
-        let mut tera = Tera::default();
+        let tera = Tera::default();
-        
-        // Load all templates from embedded directory
-        for file in TEMPLATES_DIR.files() {
-            let path = file.path().to_string_lossy();
-            let contents = file.contents_utf8()
-                .context("Template must be valid UTF-8")?;
-            tera.add_raw_template(&path, contents)?;
-        }
-        
         Ok(Self { tera })
     }
     
-    #[allow(dead_code)]
+    pub fn template_exists(&self, name: &str) -> bool {
-    pub fn render_to_file(
+        matches!(name, "basic" | "testing")
+    }
+    
+    pub fn list_templates(&self) -> Vec<String> {
+        vec![
+            "  basic      - Minimal FTC project (default)".to_string(),
+            "  testing    - Testing showcase with examples".to_string(),
+        ]
+    }
+    
+    pub fn get_template_info_all(&self) -> Result<Vec<TemplateInfo>> {
+        Ok(vec![
+            TemplateInfo {
+                name: "basic".to_string(),
+                description: "Minimal FTC project structure".to_string(),
+                file_count: 10,
+                line_count: 50,
+                test_count: 0,
+                is_default: true,
+            },
+            TemplateInfo {
+                name: "testing".to_string(),
+                description: "Professional testing showcase with examples".to_string(),
+                file_count: 30,
+                line_count: 2500,
+                test_count: 45,
+                is_default: false,
+            },
+        ])
+    }
+    
+    pub fn show_template_info(&self, name: &str) -> Result<()> {
+        let info = match name {
+            "basic" => TemplateInfo {
+                name: "basic".to_string(),
+                description: "Minimal FTC project with clean structure".to_string(),
+                file_count: 10,
+                line_count: 50,
+                test_count: 0,
+                is_default: true,
+            },
+            "testing" => TemplateInfo {
+                name: "testing".to_string(),
+                description: "Comprehensive testing showcase demonstrating professional robotics software engineering practices.".to_string(),
+                file_count: 30,
+                line_count: 2500,
+                test_count: 45,
+                is_default: false,
+            },
+            _ => bail!("Unknown template: {}", name),
+        };
+        
+        println!("{}", format!("Template: {}", info.name).bright_cyan().bold());
+        println!();
+        println!("{}", "Description:".bright_white().bold());
+        println!("  {}", info.description);
+        println!();
+        
+        if info.name == "testing" {
+            println!("{}", "Features:".bright_white().bold());
+            println!("  • Three complete subsystems with full test coverage");
+            println!("  • Hardware abstraction layer with mocks");
+            println!("  • 45 passing tests (unit, integration, system)");
+            println!("  • Comprehensive documentation (6 files)");
+            println!("  • Ready to use as learning material");
+            println!();
+        }
+        
+        println!("{}", "Files included:".bright_white().bold());
+        println!("  {} files", info.file_count);
+        println!("  ~{} lines of code", info.line_count);
+        if info.test_count > 0 {
+            println!("  {} tests", info.test_count);
+        }
+        println!();
+        
+        println!("{}", "Example usage:".bright_white().bold());
+        println!("  weevil create my-robot --template {}", info.name);
+        
+        Ok(())
+    }
+    
+    pub fn extract_template(
         &self,
         template_name: &str,
-        output_path: &Path,
+        output_dir: &Path,
-        context: &TeraContext,
+        context: &crate::commands::create::TemplateContext,
     ) -> Result<()> {
-        let rendered = self.tera.render(template_name, context)?;
+        let template_dir = match template_name {
+            "basic" => &BASIC_TEMPLATE,
+            "testing" => &TESTING_TEMPLATE,
+            _ => bail!("Unknown template: {}", template_name),
+        };
         
-        if let Some(parent) = output_path.parent() {
+        // Extract all files from template
-            fs::create_dir_all(parent)?;
+        self.extract_dir_recursively(template_dir, output_dir, "", context)?;
-        }
         
-        fs::write(output_path, rendered)?;
         Ok(())
     }
     
-    #[allow(dead_code)]
+    fn extract_dir_recursively(
-    pub fn extract_static_file(&self, template_path: &str, output_path: &Path) -> Result<()> {
+        &self,
-        let file = TEMPLATES_DIR
+        source: &Dir,
-            .get_file(template_path)
+        output_base: &Path,
-            .context(format!("Template not found: {}", template_path))?;
+        relative_path: &str,
-        
+        context: &crate::commands::create::TemplateContext,
-        if let Some(parent) = output_path.parent() {
+    ) -> Result<()> {
-            fs::create_dir_all(parent)?;
+        // Process files in current directory
+        for file in source.files() {
+            let file_path = file.path();
+            let file_name = file_path.file_name().unwrap().to_string_lossy();
+            
+            let output_path = if relative_path.is_empty() {
+                output_base.join(&*file_name)
+            } else {
+                output_base.join(relative_path).join(&*file_name)
+            };
+            
+            // Create parent directory if needed
+            if let Some(parent) = output_path.parent() {
+                fs::create_dir_all(parent)?;
+            }
+            
+            // Process file based on extension
+            if file_name.ends_with(".template") {
+                // Template file - process variables
+                let contents = file.contents_utf8()
+                    .context("Template file must be UTF-8")?;
+                
+                let processed = self.process_template_string(contents, context)?;
+                
+                // Remove .template extension from output
+                let output_name = file_name.trim_end_matches(".template");
+                let final_path = output_path.with_file_name(output_name);
+                
+                fs::write(final_path, processed)?;
+            } else {
+                // Regular file - copy as-is
+                fs::write(&output_path, file.contents())?;
+            }
+        }
+        
+        // Process subdirectories
+        for dir in source.dirs() {
+            let dir_name = dir.path().file_name().unwrap().to_string_lossy();
+            let new_relative = if relative_path.is_empty() {
+                dir_name.to_string()
+            } else {
+                format!("{}/{}", relative_path, dir_name)
+            };
+            
+            self.extract_dir_recursively(dir, output_base, &new_relative, context)?;
         }
         
-        fs::write(output_path, file.contents())?;
         Ok(())
     }
     
-    #[allow(dead_code)]
+    fn process_template_string(
-    pub fn list_templates(&self) -> Vec<String> {
+        &self,
-        TEMPLATES_DIR
+        template: &str,
-            .files()
+        context: &crate::commands::create::TemplateContext,
-            .map(|f| f.path().to_string_lossy().to_string())
+    ) -> Result<String> {
-            .collect()
+        let processed = template
+            .replace("{{PROJECT_NAME}}", &context.project_name)
+            .replace("{{PACKAGE_NAME}}", &context.package_name)
+            .replace("{{CREATION_DATE}}", &context.creation_date)
+            .replace("{{WEEVIL_VERSION}}", &context.weevil_version)
+            .replace("{{TEMPLATE_NAME}}", &context.template_name);
+        
+        Ok(processed)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::TempDir;
     
     #[test]
-    fn test_template_engine_creation() {
+    fn test_template_manager_creation() {
-        let engine = TemplateEngine::new();
+        let mgr = TemplateManager::new();
-        assert!(engine.is_ok());
+        assert!(mgr.is_ok());
+    }
+    
+    #[test]
+    fn test_template_exists() {
+        let mgr = TemplateManager::new().unwrap();
+        assert!(mgr.template_exists("basic"));
+        assert!(mgr.template_exists("testing"));
+        assert!(!mgr.template_exists("nonexistent"));
     }
     
     #[test]
     fn test_list_templates() {
-        let engine = TemplateEngine::new().unwrap();
+        let mgr = TemplateManager::new().unwrap();
-        let templates = engine.list_templates();
+        let templates = mgr.list_templates();
-        assert!(!templates.is_empty());
+        assert_eq!(templates.len(), 2);
-    }
-    
-    #[test]
-    fn test_render_template() {
-        let _engine = TemplateEngine::new().unwrap();
-        let temp = TempDir::new().unwrap();
-        let _output = temp.path().join("test.txt");
-        
-        let mut context = TeraContext::new();
-        context.insert("project_name", "TestRobot");
-        
-        // This will fail until we add templates, but shows the pattern
-        // engine.render_to_file("README.md", &output, &context).unwrap();
     }
 }

templates/basic/.gitkeep

@@ -0,0 +1 @@
+ 

templates/testing/.gitkeep

@@ -0,0 +1 @@
+ 

tests/common.rs

@@ -1,3 +1,3 @@
 // Intentionally hardcoded. When you bump the version in Cargo.toml,
 // tests will fail here until you update this to match.
-pub const EXPECTED_VERSION: &str = "1.1.0-beta.1";
+pub const EXPECTED_VERSION: &str = "1.1.0-beta.2";