feat: auto-discover and recompile all agentic pipelines (#96)

Running \�do-aw compile\ with no path argument now auto-discovers all
existing compiled YAML files via the \# @ado-aw source=...\ header,
resolves each source markdown path, and recompiles the pipeline.

- Make \path\ argument optional in the Compile CLI command
- Add \compile_all_pipelines()\ that reuses \detect::detect_pipelines()\
- Gracefully skip missing source files (warn but continue batch)
- Reject \--output\ in auto-discovery mode (ambiguous with multiple files)
- Add integration tests for auto-discover recompile and missing source

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: jamesadevine

src/compile/mod.rs

@@ -106,6 +106,80 @@ pub async fn compile_pipeline(input_path: &str, output_path: Option<&str>) -> Re
     Ok(())
 }
 
+/// Auto-discover and recompile all agentic pipelines in the current directory.
+///
+/// Scans for compiled YAML files containing the `# @ado-aw source=...` header,
+/// resolves each source markdown path, and recompiles. Pipelines whose source
+/// files are missing are reported but don't abort the batch.
+pub async fn compile_all_pipelines() -> Result<()> {
+    let root = Path::new(".");
+    info!("Auto-discovering agentic pipelines for recompilation");
+
+    let detected = crate::detect::detect_pipelines(root).await?;
+
+    if detected.is_empty() {
+        println!("No agentic pipelines found in the current directory.");
+        println!("To compile a single file, run: ado-aw compile <path>");
+        return Ok(());
+    }
+
+    println!("Found {} agentic pipeline(s):", detected.len());
+    for p in &detected {
+        println!(
+            "  {} (source: {}, version: {})",
+            p.yaml_path.display(),
+            p.source,
+            p.version
+        );
+    }
+    println!();
+
+    let mut success_count = 0;
+    let mut skip_count = 0;
+    let mut fail_count = 0;
+
+    for pipeline in &detected {
+        let source_path = root.join(&pipeline.source);
+        let yaml_output_path = root.join(&pipeline.yaml_path);
+
+        if !source_path.exists() {
+            eprintln!(
+                "  Warning: source '{}' not found for {}, skipping",
+                pipeline.source,
+                pipeline.yaml_path.display()
+            );
+            skip_count += 1;
+            continue;
+        }
+
+        let source_str = source_path.to_string_lossy();
+        let output_str = yaml_output_path.to_string_lossy();
+
+        match compile_pipeline(&source_str, Some(&output_str)).await {
+            Ok(()) => success_count += 1,
+            Err(e) => {
+                eprintln!(
+                    "  Error compiling '{}': {}",
+                    pipeline.source, e
+                );
+                fail_count += 1;
+            }
+        }
+    }
+
+    println!();
+    println!(
+        "Done: {} compiled, {} skipped, {} failed.",
+        success_count, skip_count, fail_count
+    );
+
+    if fail_count > 0 {
+        anyhow::bail!("{} pipeline(s) failed to compile", fail_count);
+    }
+
+    Ok(())
+}
+
 /// Check that a compiled pipeline YAML matches its source markdown.
 ///
 /// Compiles the source markdown fresh and compares (whitespace-normalized)

src/main.rs

@@ -29,10 +29,11 @@ enum Commands {
         #[arg(short, long)]
         output: Option<PathBuf>,
     },
-    /// Compile markdown to pipeline definition
+    /// Compile markdown to pipeline definition (or recompile all detected pipelines)
     Compile {
-        /// Path to the input markdown file
-        path: String,
+        /// Path to the input markdown file. If omitted, auto-discovers and
+        /// recompiles all existing agentic pipelines in the current directory.
+        path: Option<String>,
         /// Optional output path for the generated YAML file
         #[arg(short, long)]
         output: Option<String>,
@@ -142,9 +143,18 @@ async fn main() -> Result<()> {
             Commands::Create { output } => {
                 create::create_agent(output).await?;
             }
-            Commands::Compile { path, output } => {
-                compile::compile_pipeline(&path, output.as_deref()).await?;
-            }
+            Commands::Compile { path, output } => match path {
+                Some(p) => compile::compile_pipeline(&p, output.as_deref()).await?,
+                None => {
+                    if output.is_some() {
+                        anyhow::bail!(
+                            "--output cannot be used with auto-discovery mode. \
+                             Specify a path to compile a single file with a custom output."
+                        );
+                    }
+                    compile::compile_all_pipelines().await?
+                }
+            },
             Commands::Check { source, pipeline } => {
                 compile::check_pipeline(&source, &pipeline).await?;
             }

tests/compiler_tests.rs

@@ -1520,3 +1520,143 @@ fn test_compiled_output_has_header_comment() {
 
     let _ = fs::remove_dir_all(&temp_dir);
 }
+
+/// Test that `compile` with no path argument auto-discovers and recompiles all pipelines
+#[test]
+fn test_compile_auto_discover_recompiles_detected_pipelines() {
+    let temp_dir = std::env::temp_dir().join(format!(
+        "agentic-pipeline-autodiscover-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&temp_dir);
+    fs::create_dir_all(&temp_dir).expect("Failed to create temp directory");
+
+    // Create a source markdown file at agents/my-agent.md
+    let agents_dir = temp_dir.join("agents");
+    fs::create_dir_all(&agents_dir).expect("Failed to create agents directory");
+
+    let source_content = r#"---
+name: "Auto Discover Agent"
+description: "An agent for testing auto-discovery"
+---
+
+## Auto Discover Agent
+
+This agent tests the auto-discovery feature.
+"#;
+    fs::write(agents_dir.join("my-agent.md"), source_content)
+        .expect("Failed to write source markdown");
+
+    // Step 1: Compile the source file to create the initial YAML with header
+    let binary_path = PathBuf::from(env!("CARGO_BIN_EXE_ado-aw"));
+    let output = std::process::Command::new(&binary_path)
+        .args([
+            "compile",
+            "agents/my-agent.md",
+        ])
+        .current_dir(&temp_dir)
+        .output()
+        .expect("Failed to run initial compile");
+
+    assert!(
+        output.status.success(),
+        "Initial compile should succeed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    // Verify the YAML was created with the header
+    let yaml_path = agents_dir.join("my-agent.yml");
+    assert!(yaml_path.exists(), "Compiled YAML should exist");
+    let initial_yaml = fs::read_to_string(&yaml_path).expect("Should read initial YAML");
+    assert!(
+        initial_yaml.contains("# @ado-aw"),
+        "Initial YAML should contain @ado-aw header"
+    );
+
+    // Step 2: Run compile with no arguments (auto-discover mode)
+    let output = std::process::Command::new(&binary_path)
+        .args(["compile"])
+        .current_dir(&temp_dir)
+        .output()
+        .expect("Failed to run auto-discover compile");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(
+        output.status.success(),
+        "Auto-discover compile should succeed.\nstdout: {}\nstderr: {}",
+        stdout, stderr
+    );
+
+    assert!(
+        stdout.contains("Found 1 agentic pipeline"),
+        "Should report finding 1 pipeline, got stdout: {}",
+        stdout
+    );
+
+    assert!(
+        stdout.contains("1 compiled"),
+        "Should report 1 compiled, got stdout: {}",
+        stdout
+    );
+
+    // The YAML should still exist and be valid
+    let recompiled_yaml = fs::read_to_string(&yaml_path).expect("Should read recompiled YAML");
+    assert!(
+        recompiled_yaml.contains("# @ado-aw"),
+        "Recompiled YAML should still contain @ado-aw header"
+    );
+    assert!(
+        recompiled_yaml.contains("Auto Discover Agent"),
+        "Recompiled YAML should contain agent name"
+    );
+
+    let _ = fs::remove_dir_all(&temp_dir);
+}
+
+/// Test that auto-discover mode gracefully skips missing source files
+#[test]
+fn test_compile_auto_discover_skips_missing_source() {
+    let temp_dir = std::env::temp_dir().join(format!(
+        "agentic-pipeline-autodiscover-missing-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&temp_dir);
+    fs::create_dir_all(&temp_dir).expect("Failed to create temp directory");
+
+    // Create a YAML file with a @ado-aw header pointing to a source that doesn't exist
+    let version = env!("CARGO_PKG_VERSION");
+    let fake_yaml = format!(
+        "# This file is auto-generated by ado-aw. Do not edit manually.\n\
+         # @ado-aw source=\"agents/nonexistent.md\" version={}\n\
+         name: fake-pipeline\n",
+        version
+    );
+    fs::write(temp_dir.join("orphaned.yml"), fake_yaml).expect("Failed to write fake YAML");
+
+    let binary_path = PathBuf::from(env!("CARGO_BIN_EXE_ado-aw"));
+    let output = std::process::Command::new(&binary_path)
+        .args(["compile"])
+        .current_dir(&temp_dir)
+        .output()
+        .expect("Failed to run auto-discover compile");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    // Should succeed (skips, doesn't fail)
+    assert!(
+        output.status.success(),
+        "Should succeed even with missing source.\nstdout: {}\nstderr: {}",
+        stdout, stderr
+    );
+
+    assert!(
+        stderr.contains("not found") || stdout.contains("skipped"),
+        "Should warn about missing source.\nstdout: {}\nstderr: {}",
+        stdout, stderr
+    );
+
+    let _ = fs::remove_dir_all(&temp_dir);
+}