feat: Add --library flag to list built-in agents

- Add --library flag to `aofctl get agents` command
- Scans library/ directory for all 30 production-ready agents
- Displays domain (category), agent name, status, and model
- Supports filtering by agent name: `aofctl get agents pod-doctor --library`
- Supports all output formats: wide (default), json, yaml, name
- Updated CLI reference documentation

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: gouravjshah

CHANGELOG.md

@@ -14,6 +14,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Agent nodes now report input/output tokens
   - Flow completion summary shows total token usage
   - Script nodes correctly show 0 tokens (no LLM usage)
+- `--library` flag for `aofctl get agents` to list built-in agents
+  - Shows all 30 production-ready agents from the library
+  - Displays domain (category), agent name, status, and model
+  - Supports filtering by agent name: `aofctl get agents pod-doctor --library`
+  - Supports JSON/YAML output formats
 
 ### Fixed
 - Script node YAML field naming (`scriptConfig` camelCase)

crates/aofctl/src/cli.rs

@@ -70,6 +70,10 @@ pub enum Commands {
         /// Show all namespaces
         #[arg(long)]
         all_namespaces: bool,
+
+        /// List resources from the built-in library
+        #[arg(long)]
+        library: bool,
     },
 
     /// Apply configuration from file (verb-first: apply -f config.yaml)
@@ -248,8 +252,9 @@ impl Cli {
                 name,
                 output,
                 all_namespaces,
+                library,
             } => {
-                commands::get::execute(&resource_type, name.as_deref(), &output, all_namespaces)
+                commands::get::execute(&resource_type, name.as_deref(), &output, all_namespaces, library)
                     .await
             }
             Commands::Apply { file, namespace } => {

crates/aofctl/src/commands/get.rs

@@ -7,13 +7,21 @@ pub async fn execute(
     name: Option<&str>,
     output: &str,
     all_namespaces: bool,
+    library: bool,
 ) -> Result<()> {
     // Parse resource type
     let rt = ResourceType::from_str(resource_type)
         .ok_or_else(|| anyhow::anyhow!("Unknown resource type: {}", resource_type))?;
 
-    // Build resource list (placeholder until persistent storage is implemented)
-    let resources = get_mock_resources(&rt, name, all_namespaces);
+    // Build resource list - either from library or mock data
+    let resources = if library {
+        get_library_resources(&rt, name)?
+    } else {
+        get_mock_resources(&rt, name, all_namespaces)
+    };
+
+    // When listing library, always show domains (namespaces)
+    let show_namespaces = all_namespaces || library;
 
     // Format and display output
     match output {
@@ -45,16 +53,115 @@ pub async fn execute(
         }
         "wide" | _ => {
             // Table format (default)
-            print_table_header(&rt, all_namespaces);
+            print_table_header(&rt, show_namespaces);
             for resource in resources {
-                print_table_row(&rt, &resource, all_namespaces);
+                print_table_row(&rt, &resource, show_namespaces);
             }
         }
     }
 
     Ok(())
 }
 
+/// Get resources from the built-in library directory
+fn get_library_resources(
+    rt: &ResourceType,
+    name: Option<&str>,
+) -> Result<Vec<serde_json::Value>> {
+    // Only agents are in the library currently
+    if !matches!(rt, ResourceType::Agent) {
+        return Ok(vec![]);
+    }
+
+    // Find the library directory - check common locations
+    let library_path = find_library_path()?;
+    let mut resources = Vec::new();
+
+    // Scan all subdirectories (domains) for agent YAML files
+    if let Ok(entries) = std::fs::read_dir(&library_path) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                let domain = path.file_name()
+                    .and_then(|n| n.to_str())
+                    .unwrap_or("unknown")
+                    .to_string();
+
+                // Scan for YAML files in each domain
+                if let Ok(files) = std::fs::read_dir(&path) {
+                    for file in files.flatten() {
+                        let file_path = file.path();
+                        if file_path.extension().map_or(false, |e| e == "yaml" || e == "yml") {
+                            if let Ok(content) = std::fs::read_to_string(&file_path) {
+                                if let Ok(agent) = serde_yaml::from_str::<serde_json::Value>(&content) {
+                                    let agent_name = agent
+                                        .get("metadata")
+                                        .and_then(|m| m.get("name"))
+                                        .and_then(|n| n.as_str())
+                                        .unwrap_or("unknown");
+
+                                    // Filter by name if provided
+                                    if let Some(filter) = name {
+                                        if agent_name != filter {
+                                            continue;
+                                        }
+                                    }
+
+                                    // Add domain to metadata
+                                    let mut enriched = agent.clone();
+                                    if let Some(metadata) = enriched.get_mut("metadata") {
+                                        if let Some(obj) = metadata.as_object_mut() {
+                                            obj.insert("namespace".to_string(), serde_json::json!(domain));
+                                        }
+                                    }
+
+                                    // Add status for display
+                                    if let Some(obj) = enriched.as_object_mut() {
+                                        obj.insert("status".to_string(), serde_json::json!({
+                                            "phase": "Available"
+                                        }));
+                                    }
+
+                                    resources.push(enriched);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(resources)
+}
+
+/// Find the library directory - check multiple possible locations
+fn find_library_path() -> Result<std::path::PathBuf> {
+    // Check common locations
+    let candidates = [
+        std::path::PathBuf::from("library"),
+        std::path::PathBuf::from("./library"),
+        std::env::current_exe()
+            .ok()
+            .and_then(|p| p.parent().map(|p| p.join("library")))
+            .unwrap_or_default(),
+        std::env::current_exe()
+            .ok()
+            .and_then(|p| p.parent().and_then(|p| p.parent()).map(|p| p.join("library")))
+            .unwrap_or_default(),
+    ];
+
+    for candidate in candidates {
+        if candidate.exists() && candidate.is_dir() {
+            return Ok(candidate);
+        }
+    }
+
+    Err(anyhow::anyhow!(
+        "Library directory not found. Make sure you're running from the project root or the library is installed."
+    ))
+}
+
 fn get_mock_resources(
     rt: &ResourceType,
     name: Option<&str>,
@@ -115,11 +222,11 @@ fn print_table_header(rt: &ResourceType, all_namespaces: bool) {
     match rt {
         ResourceType::Agent => {
             if all_namespaces {
-                println!("\nNAMESPACE    NAME              STATUS    MODEL              AGE");
-                println!("{}", "=".repeat(75));
+                println!("\n{:<14} {:<24} {:<11} {:<24} {}", "DOMAIN", "NAME", "STATUS", "MODEL", "AGE");
+                println!("{}", "=".repeat(80));
             } else {
-                println!("\nNAME              STATUS    MODEL              AGE");
-                println!("{}", "=".repeat(60));
+                println!("\n{:<24} {:<11} {:<24} {}", "NAME", "STATUS", "MODEL", "AGE");
+                println!("{}", "=".repeat(65));
             }
         }
         ResourceType::Workflow => {
@@ -171,14 +278,28 @@ fn print_table_row(rt: &ResourceType, resource: &serde_json::Value, all_namespac
         .and_then(|p| p.as_str())
         .unwrap_or("Unknown");
 
-    let age = "5m"; // Placeholder
+    // Get model from spec if available (for library agents)
+    let model = resource
+        .get("spec")
+        .and_then(|s| s.get("model"))
+        .and_then(|m| m.as_str())
+        .unwrap_or("claude-sonnet-4");
+
+    // Truncate model name if too long
+    let model_display = if model.len() > 24 {
+        format!("{}...", &model[..21])
+    } else {
+        model.to_string()
+    };
+
+    let age = "-"; // Library agents don't have age
 
     match rt {
         ResourceType::Agent => {
             if all_namespaces {
-                println!("{:<12} {:<16} {:<9} {:<18} {}", namespace, name, status, "claude-sonnet-4", age);
+                println!("{:<14} {:<24} {:<11} {:<24} {}", namespace, name, status, model_display, age);
             } else {
-                println!("{:<16} {:<9} {:<18} {}", name, status, "claude-sonnet-4", age);
+                println!("{:<24} {:<11} {:<24} {}", name, status, model_display, age);
             }
         }
         ResourceType::Workflow => {

docs/reference/aofctl.md

@@ -63,6 +63,7 @@ aofctl get <resource_type> [name] [flags]
 **Flags:**
 - `-o, --output string` - Output format: json|yaml|wide|name (default: wide)
 - `--all-namespaces` - Show resources across all namespaces
+- `--library` - List resources from the built-in agent library
 
 **Examples:**
 ```bash
@@ -77,16 +78,46 @@ aofctl get agent my-agent -o yaml
 
 # All namespaces
 aofctl get agent --all-namespaces
+
+# List built-in library agents
+aofctl get agents --library
+
+# Get specific library agent
+aofctl get agents pod-doctor --library
+
+# Get library agents as JSON
+aofctl get agents --library -o json
 ```
 
-**Output:**
+**Output (default):**
 ```
 NAME              MODEL           STATUS    AGE
 k8s-helper        google:gemini-2.5-flash    Running   5d
 slack-bot         anthropic:claude-3-5-sonnet-20241022   Running   2d
 incident-responder google:gemini-2.5-flash   Running   1d
 ```
 
+**Output (--library):**
+```
+DOMAIN         NAME                     STATUS      MODEL                    AGE
+================================================================================
+kubernetes     pod-doctor               Available   google:gemini-2.5-flash  -
+kubernetes     resource-optimizer       Available   google:gemini-2.5-flash  -
+incident       rca-agent                Available   google:gemini-2.5-flash  -
+cicd           pipeline-doctor          Available   google:gemini-2.5-flash  -
+security       security-scanner         Available   google:gemini-2.5-flash  -
+observability  alert-manager            Available   google:gemini-2.5-flash  -
+cloud          cost-optimizer           Available   google:gemini-2.5-flash  -
+```
+
+The library contains 30 production-ready agents across 6 domains:
+- **kubernetes** - Pod diagnostics, resource optimization, HPA tuning, etc.
+- **incident** - RCA, incident command, escalation, postmortems
+- **cicd** - Pipeline troubleshooting, build optimization, releases
+- **security** - Vulnerability scanning, secret rotation, compliance
+- **observability** - Alerts, logging, tracing, SLO monitoring
+- **cloud** - Cost optimization, drift detection, IAM auditing
+
 ---
 
 ## describe