gnd: Fix --from-example to clone from graph-tooling repo

The init_from_example function had two bugs:
- Defaulted to "ethereum-gravatar" instead of requiring the example name
- Used hardcoded URL to example-subgraph repo, ignoring the example variable

Now:
- Example name is mandatory (error with link to available examples)
- Uses sparse checkout to fetch only the specific example from
  https://github.com/graphprotocol/graph-tooling/tree/main/examples
- Legacy name "ethereum/gravatar" is converted to "ethereum-gravatar"

Author: lutter

docs/specs/gnd-cli-expansion.md

@@ -303,6 +303,13 @@ gnd init [directory]
 | `--allow-simple-name` | | `false` | Allow simple subgraph names |
 | `--help` | `-h` | | Show help |
 
+**Example Subgraphs:**
+
+The `--from-example <name>` flag clones from `https://github.com/graphprotocol/graph-tooling/tree/main/examples`.
+The example name is **required** - no default is provided. Available examples include:
+`ethereum-gravatar`, `aggregations`, `ethereum-basic-event-handlers`, `substreams-powered-subgraph`, etc.
+Legacy name `ethereum/gravatar` is automatically converted to `ethereum-gravatar`.
+
 **Behavior:**
 
 1. Prompt for missing information (protocol, network, contract, etc.)

gnd/Cargo.toml

@@ -69,6 +69,9 @@ which = "7"
 # Interactive prompts
 inquire = "0.7"
 
+# Temp directories for init
+tempfile = "3"
+
 # Browser opening for publish command
 open = "5"
 

gnd/src/commands/init.rs

@@ -385,24 +385,45 @@ async fn init_from_contract(opt: &InitOpt) -> Result<()> {
     Ok(())
 }
 
+/// Recursively copy a directory and its contents.
+fn copy_dir_recursive(src: &Path, dst: &Path) -> Result<()> {
+    fs::create_dir_all(dst)?;
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let src_path = entry.path();
+        let dst_path = dst.join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_dir_recursive(&src_path, &dst_path)?;
+        } else {
+            fs::copy(&src_path, &dst_path)?;
+        }
+    }
+    Ok(())
+}
+
 /// Initialize a subgraph from an example template.
 fn init_from_example(opt: &InitOpt) -> Result<()> {
-    use std::fs;
-    use std::process::Command;
+    use std::process::{Command, Stdio};
 
-    let example = opt.from_example.as_deref().unwrap_or("ethereum-gravatar");
+    let example = opt.from_example.as_deref().ok_or_else(|| {
+        anyhow!(
+            "Example name is required. See available examples at:\n\
+             https://github.com/graphprotocol/graph-tooling/tree/main/examples"
+        )
+    })?;
+
+    // Handle legacy example name format
+    let example = match example {
+        "ethereum/gravatar" => "ethereum-gravatar",
+        other => other,
+    };
 
     let subgraph_name = opt.subgraph_name.as_deref().unwrap_or("my-subgraph");
 
     let directory = opt.directory.clone().unwrap_or_else(|| {
         PathBuf::from(subgraph_name.split('/').next_back().unwrap_or("subgraph"))
     });
 
-    step(
-        Step::Generate,
-        &format!("Creating subgraph from example: {}", example),
-    );
-
     // Check if directory already exists
     if directory.exists() {
         return Err(anyhow!(
@@ -411,37 +432,91 @@ fn init_from_example(opt: &InitOpt) -> Result<()> {
         ));
     }
 
-    // Clone the example repository
-    let repo_url = "https://github.com/graphprotocol/example-subgraph.git";
+    // Clone only the specific example using git sparse-checkout
+    let temp_dir = tempfile::tempdir()?;
+    let repo_url = "https://github.com/graphprotocol/graph-tooling";
+    let example_subpath = format!("examples/{}", example);
 
-    step(Step::Load, &format!("Cloning example from {}", repo_url));
+    step(Step::Load, &format!("Fetching example: {}", example));
 
+    // Initialize empty repo with sparse checkout
     let status = Command::new("git")
-        .args([
-            "clone",
-            "--depth",
-            "1",
-            repo_url,
-            &directory.to_string_lossy(),
-        ])
+        .current_dir(temp_dir.path())
+        .args(["init"])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
         .status()?;
 
     if !status.success() {
-        return Err(anyhow!("Failed to clone example repository"));
+        return Err(anyhow!("Failed to initialize git repository"));
+    }
+
+    // Configure sparse checkout for just the example directory
+    Command::new("git")
+        .current_dir(temp_dir.path())
+        .args(["sparse-checkout", "init", "--cone"])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()?;
+
+    Command::new("git")
+        .current_dir(temp_dir.path())
+        .args(["sparse-checkout", "set", &example_subpath])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()?;
+
+    // Add remote and fetch only the needed content
+    Command::new("git")
+        .current_dir(temp_dir.path())
+        .args(["remote", "add", "origin", repo_url])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()?;
+
+    let fetch_status = Command::new("git")
+        .current_dir(temp_dir.path())
+        .args(["fetch", "--depth=1", "origin", "main"])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()?;
+
+    if !fetch_status.success() {
+        return Err(anyhow!("Failed to fetch from graph-tooling repository"));
     }
 
-    // Remove .git directory to start fresh
-    let git_dir = directory.join(".git");
-    if git_dir.exists() {
-        fs::remove_dir_all(&git_dir)?;
+    Command::new("git")
+        .current_dir(temp_dir.path())
+        .args(["checkout", "origin/main"])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()?;
+
+    // Verify example exists
+    let example_path = temp_dir.path().join("examples").join(example);
+    if !example_path.exists() {
+        return Err(anyhow!(
+            "Example '{}' not found. See available examples at:\n\
+             https://github.com/graphprotocol/graph-tooling/tree/main/examples",
+            example
+        ));
     }
 
+    // Copy example to target directory
+    step(
+        Step::Generate,
+        &format!("Creating subgraph from example: {}", example),
+    );
+    copy_dir_recursive(&example_path, &directory)?;
+
     // Initialize fresh git repo unless skipped
     if !opt.skip_git {
         step(Step::Generate, "Initializing Git repository");
         let _ = Command::new("git")
             .current_dir(&directory)
             .arg("init")
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
             .status();
     }
 

gnd/tests/cli_commands.rs

@@ -108,7 +108,11 @@ fn test_init_from_example() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         // Example downloads from GitHub, may fail in CI without network
         // Skip test if it fails due to network issues
-        if stderr.contains("network") || stderr.contains("fetch") || stderr.contains("download") {
+        if stderr.contains("network")
+            || stderr.contains("fetch")
+            || stderr.contains("download")
+            || stderr.contains("Failed to fetch")
+        {
             eprintln!("Skipping test_init_from_example: network unavailable");
             return;
         }
@@ -132,6 +136,94 @@ fn test_init_from_example() {
         subgraph_dir.join("package.json").exists(),
         "package.json should exist"
     );
+
+    // Verify it's actually the ethereum-gravatar example (contains Gravatar entity)
+    let schema = fs::read_to_string(subgraph_dir.join("schema.graphql")).unwrap();
+    assert!(
+        schema.contains("Gravatar"),
+        "schema.graphql should contain Gravatar entity"
+    );
+}
+
+#[test]
+fn test_init_from_example_invalid_name() {
+    let temp_dir = TempDir::new().unwrap();
+    let output = run_gnd(
+        &[
+            "init",
+            "--skip-install",
+            "--from-example",
+            "nonexistent-example-12345",
+            "test",
+        ],
+        temp_dir.path(),
+    );
+
+    // Command should fail
+    assert!(!output.status.success());
+
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    // Skip test if it fails due to network issues (can't verify example doesn't exist)
+    if stderr.contains("Failed to fetch from graph-tooling") {
+        eprintln!("Skipping test_init_from_example_invalid_name: network unavailable");
+        return;
+    }
+
+    // Should show helpful error message
+    assert!(
+        stderr.contains("not found") || stderr.contains("graph-tooling"),
+        "Error should mention example not found or link to graph-tooling. Got: {}",
+        stderr
+    );
+}
+
+#[test]
+fn test_init_from_example_aggregations() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("my-agg");
+
+    let output = run_gnd(
+        &[
+            "init",
+            "--skip-install",
+            "--from-example",
+            "aggregations",
+            "my-agg",
+        ],
+        temp_dir.path(),
+    );
+
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        // Example downloads from GitHub, may fail in CI without network
+        if stderr.contains("network")
+            || stderr.contains("fetch")
+            || stderr.contains("download")
+            || stderr.contains("Failed to fetch")
+        {
+            eprintln!("Skipping test_init_from_example_aggregations: network unavailable");
+            return;
+        }
+        panic!(
+            "gnd init --from-example aggregations failed:\nstdout: {}\nstderr: {}",
+            stdout, stderr
+        );
+    }
+
+    // Verify scaffold was created
+    assert!(subgraph_dir.exists(), "Subgraph directory should exist");
+
+    // Verify it's actually the aggregations example, not ethereum-gravatar
+    let manifest = fs::read_to_string(subgraph_dir.join("subgraph.yaml")).unwrap();
+
+    // The aggregations example uses specVersion 1.1.0 and has blockHandlers,
+    // whereas ethereum-gravatar uses 0.0.5 and has eventHandlers
+    assert!(
+        manifest.contains("specVersion: 1.1.0") || manifest.contains("blockHandlers"),
+        "Manifest should be the aggregations example (expected specVersion 1.1.0 or blockHandlers)"
+    );
 }
 
 #[test]