nexus-workshops/weevil
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases 7 Wiki Activity

docs: Update documentation for v1.1.0 template system release

Browse Source 
Comprehensively updates all documentation to reflect the template system
feature shipped in v1.1.0 and plans for v1.2.0 package ecosystem.

README.md:
- Add prominent "What's New in v1.1.0" section highlighting templates
- Expand template documentation with detailed examples and use cases
- Show testing template's 45 tests and professional patterns
- Position templates as "game changer" for FTC learning
- Update command reference and quick start guides
- Add template deep dive section with usage recommendations

TEMPLATE-PACKAGE-SPEC.md:
- Mark Part 1 (Templates) as ✅ COMPLETE in v1.1.0
- Document actual implementation (embedded templates, variable substitution)
- Add "Lessons Learned" section from template development
- Update Part 2 (Packages) to reflect v1.2.0 planning
- Show transition from design to implementation reality
- Maintain comprehensive `weevil add` specification for v1.2.0

ROADMAP.md:
- Mark template system complete in v1.1.0 section
- Add "THE GAME CHANGER" designation for templates
- Feature `weevil add` package system as v1.2.0 "THE NEXT BIG THING"
- List initial 15 packages planned for v1.2.0 launch
- Add "Recent Accomplishments" celebrating v1.1.0 delivery
- Update success metrics with actual achievements
- Show clear progression: templates → packages → debugging

Impact:
- Documentation now reflects production reality (templates shipped!)
- Clear roadmap shows v1.2.0 package ecosystem as next major milestone
- Positions Weevil as transformative for FTC software engineering
- Comprehensive reference for teams learning from template system

All documentation ready for v1.1.0 release tag.
This commit is contained in:
Eric Ratliff
2026-02-02 23:35:20 -06:00
parent df338987b6
commit 59f8a7faa3
3 changed files with 910 additions and 1101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

698
README.md
View File

@@ -28,20 +28,100 @@ This approach works against standard software engineering practices and creates
- ✅ Are actually testable and maintainable
- ✅ Work seamlessly with Android Studio
- ✅ Support proxy/air-gapped environments
- ✅ **Start from professional templates with working code** ⭐ NEW in v1.1.0!
Students focus on building robots, not navigating SDK internals.
---
## ⭐ What's New in v1.1.0
### Professional Templates - The Game Changer!
**Start with working, tested code instead of empty files!**
```bash
# Create with our professional testing showcase
weevil new my-robot --template testing
cd my-robot
./gradlew test # 45 tests pass in < 2 seconds ✓
```
**You get:**
- ✅ 3 complete, working subsystems
- ✅ Full hardware abstraction layer
- ✅ 45 passing tests demonstrating best practices
- ✅ Professional documentation (6 files)
- ✅ Real patterns used in competition
**Why this matters:** Most FTC teams start with empty projects and learn by trial-and-error on hardware. Now you can learn from professional code, run tests instantly on your PC, and modify working examples for your robot.
This is the kind of code students would write if they had years of experience. Now they can START with it.
---
## Features
### 🎯 Professional Templates (v1.1.0)
```bash
# List available templates
weevil new --list-templates
# Create with basic template (minimal)
weevil new my-robot
# Create with testing template (professional showcase)
weevil new my-robot --template testing
```
**Available Templates:**
| Template | Description | Files | Tests | Perfect For |
|----------|-------------|-------|-------|-------------|
| `basic` | Minimal starting point | ~10 | 1 | Starting from scratch |
| `testing` | Professional showcase | ~30 | 45 | Learning best practices |
**Testing Template Includes:**
**Subsystems** (3 complete implementations):
- `MotorCycler` - State machine for motor cycling with timing
- `WallApproach` - Sensor-based wall approach with deceleration
- `TurnController` - Gyro-based turning with angle wraparound
**Hardware Layer** (interfaces + implementations + mocks):
- Motor controllers with FTC wrappers
- Distance sensors with test mocks
- Gyro sensors with simulation
- Clean abstraction enabling unit testing
**Tests** (45 tests, < 2 second runtime):
- Unit tests for each subsystem
- Integration tests for system behaviors
- Mock-based testing (no hardware required!)
**Documentation** (professional quality):
- `DESIGN_AND_TEST_PLAN.md` - Complete architecture
- `TESTING_GUIDE.md` - How to write tests
- `TESTING_SHOWCASE.md` - What's included
- `SOLUTION.md` - Problem-solving patterns
- `ARCHITECTURE.md` - Design decisions
- `QUICKSTART.md` - Get started in 5 minutes
### 🎯 Clean Project Structure
```
my-robot/
├── src/
│ ├── main/java/robot/ # Your robot code lives here
│ │ ├── hardware/ # Hardware interfaces (in testing template)
│ │ ├── subsystems/ # Robot subsystems (in testing template)
│ │ └── opmodes/ # OpModes
│ └── test/java/robot/ # Unit tests (run on PC!)
├── .idea/ # Android Studio integration (auto-generated)
│ ├── hardware/ # Hardware mocks (in testing template)
│ └── subsystems/ # Subsystem tests (in testing template)
├── docs/ # Documentation (in testing template)
├── .idea/ # Android Studio integration
├── build.sh / build.bat # One command to build
├── deploy.sh / deploy.bat # One command to deploy
└── .weevil.toml # Project configuration
@@ -53,7 +133,8 @@ my-robot/
weevil setup
# Create a new robot project
weevil new awesome-robot
weevil new awesome-robot # Basic template
weevil new awesome-robot --template testing # Testing showcase
# Test your code (no robot required!)
cd awesome-robot
@@ -102,13 +183,14 @@ 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
- **One-click deployment** - Run configurations appear automatically
- **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
- **Professional templates** - Start with tested, working code ⭐ NEW!
- **Per-project SDK configuration** - Different projects can use different SDK versions
- **Automatic Gradle wrapper** - No manual setup required
- **Cross-platform** - Works on Linux, macOS, and Windows
@@ -147,14 +229,7 @@ export PATH="$PATH:$(pwd)/target/release"
### 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:
@@ -165,69 +240,149 @@ Weevil will:
### 2. Create Your First Project
**Recommended: Start with the testing template**
```bash
weevil new my-robot --template testing
cd my-robot
```
**Or start minimal:**
```bash
weevil new my-robot
cd my-robot
```
Weevil generates:
- Clean project structure
- Android Studio run configurations
- Example test files
- Build and deploy scripts
- Git repository with `.gitignore`
### 3. Write Some Code
Create `src/main/java/robot/MyOpMode.java`:
```java
package robot;
import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
@TeleOp(name="My OpMode")
public class MyOpMode extends LinearOpMode {
@Override
public void runOpMode() {
telemetry.addData("Status", "Initialized");
telemetry.update();
waitForStart();
while (opModeIsActive()) {
telemetry.addData("Status", "Running");
telemetry.update();
}
}
}
```
### 4. Test Locally (No Robot!)
### 3. Run Tests (Testing Template)
```bash
./gradlew test
```
Write unit tests in `src/test/java/robot/` that run on your PC. No need to deploy to a robot for every code change!
Output:
```
BasicTest > testBasic() PASSED
MotorCyclerTest > testInitialState() PASSED
MotorCyclerTest > testCycleFromOnToOff() PASSED
... 42 more tests ...
### 5. Deploy to Robot
BUILD SUCCESSFUL in 1s
45 tests passed
```
**All tests run on your PC - no robot required!**
### 4. Explore the Code (Testing Template)
```bash
# Build APK
./build.sh
# Read the overview
cat QUICKSTART.md
# Deploy via USB
./deploy.sh --usb
# Study a subsystem
cat src/main/java/robot/subsystems/WallApproach.java
# Deploy via WiFi
./deploy.sh --wifi -i 192.168.49.1
# See how it's tested
cat src/test/java/robot/subsystems/WallApproachTest.java
# Auto-detect (tries USB, falls back to WiFi)
./deploy.sh
# Check the architecture
cat DESIGN_AND_TEST_PLAN.md
```
### 5. Modify for Your Robot
```bash
# The testing template gives you working patterns to modify
# Option 1: Modify existing subsystems
vim src/main/java/robot/subsystems/WallApproach.java
# Option 2: Copy and adapt
cp src/main/java/robot/subsystems/WallApproach.java \
src/main/java/robot/subsystems/MyApproach.java
# Run tests to verify
./gradlew test
```
### 6. Deploy to Robot
```bash
./build.sh
./deploy.sh --wifi
```
---
## Template System
### Listing Templates
```bash
weevil new --list-templates
```
Output:
```
Available templates:
basic (default)
Minimal FTC project structure
Perfect for: Teams starting from scratch
Files: ~10 | Code: ~50 lines
testing
Professional testing showcase with examples
Perfect for: Learning best practices
Files: ~30 | Code: ~2,500 lines | Tests: 45
Includes:
• 3 complete subsystems (MotorCycler, WallApproach, TurnController)
• Hardware abstraction layer with mocks
• 45 passing tests (< 2 seconds)
• Comprehensive documentation
Usage:
weevil new <project-name> # Uses basic template
weevil new <project-name> --template testing # Uses testing template
```
### Basic Template
**Use when:** Starting from scratch, want minimal boilerplate
**What you get:**
- Clean directory structure
- Placeholder OpMode
- Basic test file
- Build/deploy scripts
- Documentation
**Files:** ~10
**Code:** ~50 lines
**Tests:** 1
### Testing Template
**Use when:** Want to learn professional patterns, need working examples
**What you get:**
| Category | What's Included |
|----------|-----------------|
| **Subsystems** | 3 complete implementations demonstrating real patterns |
| **Hardware** | 6 interfaces + FTC wrappers + test mocks |
| **Tests** | 45 comprehensive tests (unit + integration) |
| **Docs** | 6 professional documentation files |
| **Patterns** | State machines, hardware abstraction, testing strategies |
**Files:** ~30
**Code:** ~2,500 lines
**Tests:** 45 (< 2 second runtime)
**Perfect for:**
- Learning how professional FTC code is structured
- Understanding test-driven development
- Seeing working examples before writing your own
- Teaching your team best practices
- Workshops and training sessions
---
## Android Studio Setup
@@ -236,44 +391,29 @@ Write unit tests in `src/test/java/robot/` that run on your PC. No need to deplo
1. Launch Android Studio
2. Choose **Open** (not "New Project")
3. Navigate to your project directory (e.g., `my-robot`)
3. Navigate to your project directory
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
You'll see:
- Clean file tree (only your code visible)
- Run configurations in dropdown
- One-click deployment
### First-Time Setup: Shell Script Plugin
### First-Time: Install 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.
1. **File → Settings** (Ctrl+Alt+S)
2. **Plugins → Marketplace**
3. Search **"Shell Script"**
4. Install plugin (by JetBrains)
5. Restart Android Studio
### 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
1. Select configuration (Test, Build, Deploy)
2. Click green play button (▶)
3. Watch output in Run panel
**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
**That's it!** Deploy to robot without leaving IDE.
---
@@ -281,128 +421,68 @@ After restart, the run configurations will work.
### Proxy Configuration
#### Corporate Environments
```bash
# Set proxy for all Weevil operations
# Corporate proxy
weevil --proxy http://proxy.company.com:8080 setup
weevil --proxy http://proxy.company.com:8080 new robot-project
# Or use environment variables (auto-detected)
# Environment variable (auto-detected)
export HTTPS_PROXY=http://proxy:8080
export HTTP_PROXY=http://proxy:8080
weevil setup # Automatically uses proxy
```
weevil setup
#### 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)
# Bypass proxy
weevil --no-proxy setup
```
### Multiple SDK Versions
Working with multiple SDK versions? No problem:
```bash
# Create project with specific SDK
# Create with specific SDK
weevil new experimental-bot --ftc-sdk /path/to/sdk-v11.0
# Later, switch SDKs
# Switch SDKs later
weevil config experimental-bot --set-sdk /path/to/sdk-v11.1
# Rebuild with new SDK
weevil upgrade experimental-bot
cd experimental-bot
./build.sh
```
### Upgrading Projects
When Weevil releases new features:
```bash
weevil upgrade my-robot
```
This updates:
- Build scripts
- Deployment scripts
- Gradle configuration
- Android Studio run configurations
- Project templates
Updates build scripts, Gradle config, and IDE integration.
**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
weevil doctor # Check system health
weevil uninstall --dry-run # Preview uninstall
weevil uninstall --only 1 # Remove specific component
```
### Cross-Platform Development
All scripts work on Windows, Linux, and macOS:
**Linux/Mac:**
```bash
./build.sh
./deploy.sh --wifi
```
**Windows:**
```cmd
build.bat
deploy.bat
```
**Android Studio:** Works identically on all platforms
---
## Project Configuration
Each project has a `.weevil.toml` file:
`.weevil.toml`:
```toml
[project]
project_name = "my-robot"
created = "2026-02-02T10:30:00Z"
weevil_version = "1.1.0"
template = "testing"
ftc_sdk_path = "/home/user/.weevil/ftc-sdk"
ftc_sdk_version = "v10.1.1"
android_sdk_path = "/home/user/.weevil/android-sdk"
[ftc]
sdk_version = "v10.1.1"
[build]
gradle_version = "8.5"
```
You can edit this manually or use:
Manage with:
```bash
weevil config my-robot # View config
weevil config my-robot # View
weevil config my-robot --set-sdk /new/sdk # Change SDK
```
@@ -413,60 +493,44 @@ weevil config my-robot --set-sdk /new/sdk # Change SDK
### Recommended Git Workflow
```bash
# Create project
weevil new competition-bot
weevil new competition-bot --template testing
cd competition-bot
# Project is already a git repo!
# Already a git repo!
git remote add origin https://nxgit.dev/team/robot.git
git push -u origin main
# Make changes
# ... edit code ...
./gradlew test
git commit -am "Add autonomous mode"
# Development cycle
./gradlew test # Test locally
git commit -am "Add feature"
git push
# Deploy to robot
./deploy.sh
./deploy.sh # Deploy to robot
```
### Testing Strategy
### Learning from the Testing Template
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
```bash
./build.sh
./deploy.sh --usb
# Run via Driver Station
```
### Team Collaboration
**Project Structure is Portable:**
```bash
# Team member clones repo
git clone https://nxgit.dev/team/robot.git
cd robot
# Create learning project
weevil new learning --template testing
cd learning
# Check SDK location
weevil config .
# Study the architecture
cat DESIGN_AND_TEST_PLAN.md
# Set SDK to local path (if different from .weevil.toml)
weevil config . --set-sdk ~/ftc-sdk
# Run tests and see patterns
./gradlew test
# Build and deploy
./build.sh
./deploy.sh
# Read a subsystem
cat src/main/java/robot/subsystems/MotorCycler.java
# Read its tests
cat src/test/java/robot/subsystems/MotorCyclerTest.java
# Copy patterns for your robot
cp src/main/java/robot/subsystems/MotorCycler.java \
src/main/java/robot/subsystems/MySystem.java
```
**Android Studio users:** Just open the project. The `.idea/` folder contains all run configurations.
---
## Command Reference
@@ -475,48 +539,47 @@ weevil config . --set-sdk ~/ftc-sdk
| 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 |
| `weevil doctor` | Check system health |
| `weevil setup` | Install FTC SDK, Android SDK |
| `weevil setup --ftc-sdk <path>` | Install to custom location |
| `weevil uninstall` | Remove all components |
| `weevil uninstall --dry-run` | Preview uninstall |
| `weevil uninstall --only <N>` | Remove specific component |
### Project Commands
| Command | Description |
|---------|-------------|
| `weevil new <name>` | Create new FTC project |
| `weevil new <name> --ftc-sdk <path>` | Create with specific SDK |
| `weevil new <name>` | Create project (basic template) |
| `weevil new <name> --template <t>` | Create with template |
| `weevil new --list-templates` | Show available templates |
| `weevil upgrade <path>` | Update project infrastructure |
| `weevil config <path>` | View project configuration |
| `weevil config <path> --set-sdk <sdk>` | Change FTC SDK path |
| `weevil config <path>` | View configuration |
| `weevil config <path> --set-sdk <sdk>` | Change FTC SDK |
### SDK Commands
| Command | Description |
|---------|-------------|
| `weevil sdk status` | Show SDK locations and status |
| `weevil sdk status` | Show SDK status |
| `weevil sdk install` | Download and install SDKs |
| `weevil sdk update` | Update SDKs to latest versions |
| `weevil sdk update` | Update to latest SDKs |
### Global Flags
| Flag | Description |
|------|-------------|
| `--proxy <url>` | Use HTTP proxy for all network operations |
| `--no-proxy` | Bypass proxy (ignore HTTPS_PROXY env vars) |
| `--proxy <url>` | Use HTTP proxy |
| `--no-proxy` | Bypass proxy |
### Deployment Options
**`deploy.sh` / `deploy.bat` flags:**
| Flag | Description |
|------|-------------|
| `--usb` | Force USB deployment |
| `--wifi` | Force WiFi deployment |
| `-i <ip>` | Custom Control Hub IP |
| `--timeout <sec>` | WiFi connection timeout |
| `--usb` | Force USB |
| `--wifi` | Force WiFi |
| `-i <ip>` | Custom IP |
| `--timeout <sec>` | WiFi timeout |
---
@@ -525,166 +588,91 @@ weevil config . --set-sdk ~/ftc-sdk
### How It Works
1. **Project Generation**
- Creates standalone Java project structure
- Generates Gradle build files that reference FTC SDK
- Creates standalone Java project
- Optionally overlays template (basic/testing)
- Generates build files referencing FTC SDK
- Sets up deployment scripts
- Creates Android Studio run configurations
- Creates Android Studio integration
2. **Build Process**
- Runs `deployToSDK` Gradle task
- Copies your code to FTC SDK's `TeamCode` directory
- Builds APK using SDK's Android configuration
- Leaves your project directory clean
- Copies code to FTC SDK's TeamCode
- Builds APK using SDK
- Leaves project directory clean
3. **Deployment**
- Finds built APK in 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
- Finds APK in SDK
- Connects to Control Hub (USB/WiFi)
- Installs using `adb`
### 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
- Build infrastructure: `*.gradle.kts`
- FTC SDK: System installation
- Templates: Starting points
**Benefits:**
- Test code without SDK complications
- Multiple projects per SDK installation
- 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)
- Test without SDK complications
- Multiple projects per SDK
- SDK updates don't break projects
- Proper version control
- Industry-standard structure
- Learn from professional examples
---
## Testing
Weevil includes comprehensive tests:
```bash
# Run all tests
cargo test
# Run specific test suites
cargo test --test integration
cargo test --test project_lifecycle
cargo test --test proxy_integration
cargo test config_tests
cargo test # All tests
cargo test --test integration # Integration tests
cargo test --test template_tests # Template tests
```
**Test Coverage:**
- ✅ Project creation and structure
- ✅ Configuration persistence
- ✅ SDK detection and validation
- ✅ Build script generation
- ✅ Upgrade workflow
- ✅ CLI commands
- ✅ Proxy configuration and network operations
- ✅ Environment setup and health checks
**Coverage:**
- ✅ Project creation
- ✅ Template extraction
- ✅ Configuration
- ✅ SDK detection
- ✅ Build scripts
- ✅ Proxy support
- ✅ 62 tests passing
---
## Troubleshooting
### "FTC SDK not found"
```bash
# Check system health
weevil doctor
# Install SDK
weevil setup
# Or specify custom location
weevil new my-robot --ftc-sdk /custom/path/to/sdk
```
### "adb: command not found"
Install Android platform-tools:
**Linux:**
```bash
# Weevil can install it for you
weevil setup
# Or install manually
sudo apt install android-tools-adb
weevil setup # Installs Android SDK with adb
```
**macOS:**
```bash
brew install android-platform-tools
```
**Windows:**
Download Android SDK Platform Tools from Google or run `weevil setup`.
### "Build failed"
```bash
# Clean and rebuild
cd my-robot
./gradlew clean
./build.sh
# Check SDK path
weevil config .
# Verify system health
weevil doctor
```
### "Deploy failed - No devices"
**USB:** `./deploy.sh --usb`
**WiFi:** `./deploy.sh -i 192.168.43.1`
**USB:**
1. Connect robot via USB
2. Run `adb devices` to verify connection
3. Try `./deploy.sh --usb`
**WiFi:**
1. Connect to robot's WiFi network
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
```
### "Unknown run configuration type ShellScript"
Install Shell Script plugin in Android Studio (see [Android Studio Setup](#android-studio-setup))
---
## Contributing
Contributions welcome! Please:
1. Fork the repository
2. Create a feature branch
3. Write tests for new features
4. Ensure `cargo test` passes with zero warnings
5. Submit a pull request
### Development Setup
Contributions welcome!
```bash
git clone https://www.nxgit.dev/nexus-workshops/weevil.git
@@ -693,7 +681,7 @@ cargo build
cargo test
# Run locally
cargo run -- new test-project
cargo run -- new test-project --template testing
```
---
@@ -702,22 +690,23 @@ cargo run -- new test-project
**Why "Weevil"?**
Like the boll weevil that bores through complex cotton bolls to reach the valuable fibers inside, this tool bores through the complexity of the FTC SDK structure to help students reach what matters: building robots and learning to code.
Like the boll weevil boring through cotton bolls to reach valuable fibers, this tool bores through SDK complexity to help students reach what matters: building robots and learning to code.
**Design Principles:**
1. **Students first** - Minimize cognitive load for learners
1. **Students first** - Minimize cognitive load
2. **Industry practices** - Teach real software engineering
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
3. **Testability** - Enable TDD workflows
4. **Simplicity** - One command, one purpose
5. **Transparency** - Students understand what's happening
6. **Tool compatibility** - Work with familiar tools
7. **Learn from examples** - Provide professional code to study
---
## License
MIT License - See [LICENSE](LICENSE) file for details.
MIT License - See [LICENSE](LICENSE)
---
@@ -725,7 +714,7 @@ MIT License - See [LICENSE](LICENSE) file for details.
Created by Eric Ratliff for [Nexus Workshops LLC](https://nexusworkshops.com)
Built with frustration at unnecessarily complex robotics frameworks, and hope that students can focus on robotics instead of build systems.
Built with frustration at unnecessarily complex frameworks, and hope that students can focus on robotics instead of build systems.
**For FIRST Tech Challenge teams everywhere** - may your builds be fast and your deployments successful. 🤖
@@ -736,24 +725,25 @@ Built with frustration at unnecessarily complex robotics frameworks, and hope th
**Current Version:** 1.1.0
**What Works:**
- ✅ Project generation
- ✅ Project generation with templates
- ✅ Professional testing showcase template
- ✅ Cross-platform build/deploy
- ✅ SDK management and auto-install
- ✅ Configuration management
- ✅ Project upgrades
- ✅ Local unit testing
- ✅ System diagnostics (`weevil doctor`)
- ✅ System diagnostics
- ✅ Selective uninstall
- ✅ Proxy support for corporate/air-gapped environments
- ✅ Android Studio integration with one-click deployment
- ✅ Proxy support
- ✅ Android Studio integration
**Roadmap:**
- 📋 Package management for FTC libraries
- 📋 Template system for common robot configurations
- 📋 `weevil add` - Package management system (v1.2.0)
- 📋 Community package repository
- 📋 Additional templates (mecanum, vision)
- 📋 VS Code integration
- 📋 Team collaboration features
- 📋 Automated testing on robot hardware
- 📋 Multi-robot support (manage multiple Control Hubs)
- 📋 Multi-robot support
---