feat: update -C flag support for changing directory (#95)

Author: wislertt

.cursor/rules/cli-implementation.mdc

@@ -0,0 +1,141 @@
+---
+description: CLI implementation standards for zerv including core commands, pipeline architecture, argument structures, and format validation patterns
+globs: **/*.rs,**/src/cli/**/*.rs,**/tests/**/*.rs
+alwaysApply: true
+---
+
+# CLI Implementation Standards
+
+## Core Commands
+
+### `zerv version [OPTIONS]`
+
+Main version processing pipeline with composable operations.
+
+### `zerv check <version> [OPTIONS]`
+
+Validation-only command for version strings.
+
+## Pipeline Architecture
+
+```
+Input → Version Object → Zerv Object → Transform → Output Version Object → Display
+```
+
+## Key Implementation Patterns
+
+### Version Command Args Structure
+
+```rust
+#[derive(Parser)]
+struct VersionArgs {
+    version: Option<String>,
+    #[arg(long, default_value = "git")]
+    source: String,
+    #[arg(long, default_value = "zerv-default")]
+    schema: String,
+    #[arg(long)]
+    schema_ron: Option<String>,
+    #[arg(long)]
+    output_format: Option<String>,
+}
+```
+
+### Check Command Args Structure
+
+```rust
+#[derive(Parser)]
+struct CheckArgs {
+    version: String,
+    #[arg(long)]
+    format: Option<String>,  // pep440, semver, auto-detect (default)
+}
+```
+
+### Core Pipeline Function
+
+```rust
+pub fn run_version_pipeline(args: VersionArgs) -> Result<String> {
+    // 1. Get VCS data
+    let vcs_data = detect_vcs(current_dir())?.get_vcs_data()?;
+
+    // 2. Convert to ZervVars
+    let vars = vcs_data_to_zerv_vars(vcs_data)?;
+
+    // 3. Apply schema and output format
+    match args.output_format.as_deref() {
+        Some("pep440") => Ok(PEP440::from_zerv(&vars)?.to_string()),
+        Some("semver") => Ok(SemVer::from_zerv(&vars)?.to_string()),
+        _ => Ok(vars.to_string()),
+    }
+}
+```
+
+## State-Based Versioning Tiers
+
+**Tier 1** (Tagged, clean): `major.minor.patch`
+**Tier 2** (Distance, clean): `major.minor.patch.post<distance>+branch.<commit>`
+**Tier 3** (Dirty): `major.minor.patch.dev<timestamp>+branch.<commit>`
+
+## Format Flag Validation Pattern
+
+```rust
+// Error if conflicting format flags used
+if args.format.is_some() && (args.input_format.is_some() || args.output_format.is_some()) {
+    return Err(ZervError::ConflictingFlags(
+        "Cannot use --format with --input-format or --output-format".to_string()
+    ));
+}
+```
+
+## Check Command Auto-Detection Pattern
+
+```rust
+fn run_check_command(args: CheckArgs) -> Result<()> {
+    match args.format.as_deref() {
+        Some("pep440") => {
+            PEP440::parse(&args.version)?;
+            println!("✓ Valid PEP440 version");
+        }
+        Some("semver") => {
+            SemVer::parse(&args.version)?;
+            println!("✓ Valid SemVer version");
+        }
+        None => {
+            // Auto-detect format
+            let pep440_valid = PEP440::parse(&args.version).is_ok();
+            let semver_valid = SemVer::parse(&args.version).is_ok();
+
+            match (pep440_valid, semver_valid) {
+                (true, false) => println!("✓ Valid PEP440 version"),
+                (false, true) => println!("✓ Valid SemVer version"),
+                (true, true) => {
+                    println!("✓ Valid PEP440 version");
+                    println!("✓ Valid SemVer version");
+                }
+                (false, false) => return Err(ZervError::InvalidVersion(args.version)),
+            }
+        }
+        Some(format) => return Err(ZervError::UnknownFormat(format.to_string())),
+    }
+    Ok(())
+}
+```
+
+## Essential CLI Options
+
+### Input Sources
+
+-   `--source git` (default) - Auto-detect Git
+-   `--source string <version>` - Parse version string
+
+### Schema Control
+
+-   `--schema zerv-default` (default) - Tier-aware schema
+-   `--schema-ron <ron>` - Custom RON schema
+
+### Output Control
+
+-   `--output-format <format>` - Target format: pep440, semver
+-   `--output-template <template>` - Custom template string
+-   `--output-prefix [prefix]` - Add prefix (defaults to "v")

.cursor/rules/dev-workflow.mdc

@@ -0,0 +1,100 @@
+---
+description: Development workflow standards and processes for the zerv project including git practices, testing, and deployment
+globs: **/*.rs,**/*.md,**/*.yml,**/*.yaml,**/*.toml,**/Makefile
+alwaysApply: true
+---
+
+# Development Workflow Rules
+
+## MANDATORY: Always Check .dev First
+
+Before performing ANY coding task, **read `.dev/00-README.md`** for complete project context and workflow.
+
+## .dev Document Numbering
+
+**Rule**: All .dev documents use sequential numbering to indicate creation order:
+
+-   `00-***.md`: Created at same point in time (current state)
+-   `01-***.md`: Next development phase
+-   `02-***.md`: Following phase
+-   etc.
+
+**Higher numbers = more recent/updated plans**
+
+Always verify against actual codebase - higher numbered docs are more likely to be current.
+
+## Essential Commands
+
+✅ Use `make` commands (defined in `.dev/00-README.md`)
+⚠️ Ensure `make lint` and `make test` always pass before committing
+
+## Testing Strategy
+
+**For Amazon Q (AI Assistant):**
+
+-   ALWAYS use `make lint` and `make test` for validation
+
+## Error Handling Standards
+
+-   Use `zerv::error::ZervError` for all custom errors
+-   Implement proper error propagation with `?` operator
+-   Include context in error messages for debugging
+-   Use `io::Error::other()` instead of `io::Error::new(io::ErrorKind::Other, ...)`
+
+## Performance Standards
+
+-   Parse 1000+ versions in <100ms
+-   Minimal VCS command calls (batch when possible)
+-   Use compiled regex patterns for speed
+-   Zero-copy string operations where possible
+
+## Architecture Patterns
+
+-   **Universal Format**: Component-based system with variable references
+-   **Multi-Format Support**: PEP440, SemVer, template-based custom formats
+-   **State-Based Tiers**: Tagged/Distance/Dirty states determine version components
+-   **Pipeline Architecture**: Input → Parse → Transform → Output
+
+**Error Standard Violations Check:**
+
+When user mentions:
+
+-   "check error standards"
+-   "find error violations"
+-   "audit error handling"
+-   "error compliance check"
+
+→ Search codebase for violations:
+
+-   `io::Error::new(io::ErrorKind::Other` patterns
+-   Missing `ZervError` usage in custom error cases
+-   Direct `unwrap()` or `expect()` in production code
+-   Error messages without context
+
+## Code Reuse Standards
+
+**ALWAYS check existing utilities first:**
+
+-   Check `src/test_utils/` before creating new test utilities
+-   Reuse `TestDir`, `GitOperations` trait, and other existing infrastructure
+-   Use `get_git_impl()` for environment-aware Git operations
+-   Prefer `GitOperations` trait methods over direct Docker/Native calls
+-   Avoid duplicating code across different files
+-   Look for existing helper functions before implementing new ones
+
+**Code Reuse Violations Check:**
+
+When user mentions:
+
+-   "check code reuse"
+-   "find duplicated code"
+-   "audit code duplication"
+-   "redundant code check"
+
+→ Search codebase for violations:
+
+-   Duplicated test setup patterns
+-   Direct `DockerGit`/`NativeGit` usage instead of `get_git_impl()`
+-   Reimplemented Git operations instead of using `GitOperations` trait
+-   Similar helper functions across files
+-   Unused existing utilities in `src/test_utils/git/`