feat: smart command validation with fallback (ADR-010)

Implements intelligent runner selection based on command support:
- Validates if runner supports the requested command before selecting
- npm/yarn/pnpm/bun: Parses package.json scripts section
- cargo: Checks against built-in subcommands list
- make: Parses Makefile targets
- composer: Parses composer.json scripts
- gradle: Built-in tasks + custom tasks from build.gradle
- dotnet: Built-in commands list

Selection priority: Supported > Unknown > NotSupported
Falls back to Unknown runners if none explicitly support the command.

Example: 'run precommit' in Rust project with Makefile now correctly
runs 'make precommit' instead of failing with 'cargo precommit'.

New files:
- src/validators.rs: Command validation logic

Test summary:
- 78 unit tests (+5 for validators)
- 60 integration tests (+4 for fallback behavior)
- 16 proptest tests
- Total: 154 tests passing

ADR-010 documents this architectural decision.
Fixes the issue where Cargo was selected for Makefile targets.

Author: insign

ADR.md

@@ -99,3 +99,21 @@
 - **tempfile** for isolated test environments
 - All tests run via `cargo test` and `make precommit`
 **Consequences**: Comprehensive coverage (145+ tests) with fast feedback. Property tests catch edge cases that example-based tests miss.
+
+### ADR-010: Smart Command Validation with Fallback
+
+**Status**: ✅ Accepted
+**Context**: When multiple runners are detected (e.g., Cargo.toml + Makefile), the tool should intelligently select the runner that actually supports the requested command.
+**Decision**: 
+- Before selecting a runner, validate if it supports the requested command
+- For **npm/yarn/pnpm/bun**: Parse `package.json` and check if script exists
+- For **cargo**: Check against list of built-in subcommands (build, test, clippy, etc.)
+- For **make**: Parse Makefile and extract target names
+- For **composer**: Parse `composer.json` scripts section
+- For **gradle**: Check built-in tasks + parse `build.gradle` for custom tasks
+- For **dotnet**: Check against built-in commands
+- Commands return `Supported`, `NotSupported`, or `Unknown` status
+- Selection priority: `Supported` > `Unknown` > skip `NotSupported`
+- Fallback to first `Unknown` if none explicitly support the command
+**Example**: `run precommit` in a Rust project with Makefile correctly runs `make precommit` instead of failing with `cargo precommit`.
+**Consequences**: Smarter runner selection that matches user intent. Eliminates need for `--ignore` flag in common fallback scenarios.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "run-cli"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 authors = ["Verseles"]
 description = "Universal task runner for modern development - automatically detects and runs project commands"

ROADMAP.md

@@ -123,6 +123,18 @@ Description: Comprehensive testing and code quality improvements
 - [x] 9.08 Set up code coverage reporting with cargo-tarpaulin - Commit: (pending)
 - [x] 9.09 Add property-based tests with proptest (16 tests) - Commit: (pending)
 
+### Feature 9.5: Smart Command Validation
+Description: Validate if runner supports the command before selecting it
+
+- [x] 9.5.01 Create validators module with CommandSupport enum - Commit: (pending)
+- [x] 9.5.02 Implement npm/yarn/pnpm/bun validation (parse package.json scripts) - Commit: (pending)
+- [x] 9.5.03 Implement cargo validation (built-in commands list) - Commit: (pending)
+- [x] 9.5.04 Implement make validation (parse Makefile targets) - Commit: (pending)
+- [x] 9.5.05 Implement composer/gradle/dotnet validation - Commit: (pending)
+- [x] 9.5.06 Add select_runner function with fallback logic - Commit: (pending)
+- [x] 9.5.07 Add integration tests for fallback behavior - Commit: (pending)
+- [x] 9.5.08 Document in ADR-010 - Commit: (pending)
+
 ### Feature 10: MVP Polish - Documentation & Demos
 Description: Visual demos and enhanced documentation
 

src/error.rs

@@ -31,6 +31,9 @@ pub enum RunError {
     #[error("Tool not installed: {0}")]
     ToolNotInstalled(String),
 
+    #[error("Command '{0}' not supported by any detected runner ({1:?})")]
+    CommandNotSupported(String, Vec<String>),
+
     #[error("Command execution failed: {0}")]
     CommandFailed(String),
 

src/lib.rs

@@ -23,6 +23,7 @@ pub mod error;
 pub mod output;
 pub mod runner;
 pub mod update;
+pub mod validators;
 
 pub use cli::Cli;
 pub use config::Config;

src/main.rs

@@ -15,7 +15,7 @@ use run_cli::cli::{Cli, Commands};
 use run_cli::config::Config;
 use run_cli::error::exit_codes;
 use run_cli::output;
-use run_cli::runner::{check_conflicts, execute, search_runners};
+use run_cli::runner::{check_conflicts, execute, search_runners, select_runner};
 use run_cli::update;
 use std::env;
 use std::io;
@@ -108,9 +108,15 @@ fn main() {
         }
     };
 
-    // Check for conflicts and select runner
+    // Check for conflicts and select runner based on command support
     let runner = match check_conflicts(&runners, verbose) {
-        Ok(r) => r,
+        Ok(_) => match select_runner(&runners, &command, &working_dir, verbose) {
+            Ok(r) => r,
+            Err(e) => {
+                output::error(&e.to_string());
+                process::exit(e.exit_code());
+            }
+        },
         Err(e) => {
             output::error(&e.to_string());
             process::exit(e.exit_code());

src/runner.rs

@@ -12,6 +12,7 @@
 use crate::detectors::{detect_all, is_tool_installed, DetectedRunner, Ecosystem};
 use crate::error::RunError;
 use crate::output;
+use crate::validators::CommandSupport;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::process::{Command, ExitStatus, Stdio};
@@ -138,6 +139,55 @@ pub fn check_conflicts(
     Ok(runners[0].clone())
 }
 
+pub fn select_runner(
+    runners: &[DetectedRunner],
+    command: &str,
+    working_dir: &Path,
+    verbose: bool,
+) -> Result<DetectedRunner, RunError> {
+    if runners.is_empty() {
+        return Err(RunError::RunnerNotFound(0));
+    }
+
+    let mut supported_runners: Vec<&DetectedRunner> = Vec::new();
+    let mut unknown_runners: Vec<&DetectedRunner> = Vec::new();
+
+    for runner in runners {
+        match runner.supports_command(command, working_dir) {
+            CommandSupport::Supported => {
+                if verbose {
+                    output::info(&format!("{} supports command '{}'", runner.name, command));
+                }
+                supported_runners.push(runner);
+            }
+            CommandSupport::NotSupported => {
+                if verbose {
+                    output::info(&format!(
+                        "{} does not support command '{}'",
+                        runner.name, command
+                    ));
+                }
+            }
+            CommandSupport::Unknown => {
+                unknown_runners.push(runner);
+            }
+        }
+    }
+
+    if let Some(runner) = supported_runners.first() {
+        return Ok((*runner).clone());
+    }
+
+    if let Some(runner) = unknown_runners.first() {
+        return Ok((*runner).clone());
+    }
+
+    Err(RunError::CommandNotSupported(
+        command.to_string(),
+        runners.iter().map(|r| r.name.clone()).collect(),
+    ))
+}
+
 /// Execute a command with the detected runner
 pub fn execute(
     runner: &DetectedRunner,