Port final parity gaps: self-update, background SCIP, capabilities summary, disable Ubuntu CI

- Add platform_triple() and self_update() for direct binary download via gh release
- Enhance cmd_update() to try binary download first, fall back to install script
- Add spawn_scip_child_process() for background SCIP enrichment (non-blocking index)
- Add print_capabilities_summary() post-install help text, wire into cmd_install()
- Comment out Ubuntu builds in CI and release workflows (lbug/KuzuDB not yet building on Linux)

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

Author: Murari

.github/workflows/ci.yml

@@ -25,27 +25,29 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        # os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [macos-latest, windows-latest]
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy
-      - name: Install cmake
-        if: runner.os == 'Linux'
-        run: sudo apt-get update && sudo apt-get install -y cmake
+      # - name: Install cmake
+      #   if: runner.os == 'Linux'
+      #   run: sudo apt-get update && sudo apt-get install -y cmake
       - run: cargo clippy --all-targets -- -D warnings
 
   test:
     name: Test (${{ matrix.os }})
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        # os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [macos-latest, windows-latest]
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
-      - name: Install cmake
-        if: runner.os == 'Linux'
-        run: sudo apt-get update && sudo apt-get install -y cmake
+      # - name: Install cmake
+      #   if: runner.os == 'Linux'
+      #   run: sudo apt-get update && sudo apt-get install -y cmake
       - run: cargo test --all

.github/workflows/release.yml

@@ -23,9 +23,9 @@ jobs:
           - os: macos-13
             target: x86_64-apple-darwin
             archive: tar.gz
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-            archive: tar.gz
+          # - os: ubuntu-latest
+          #   target: x86_64-unknown-linux-gnu
+          #   archive: tar.gz
           - os: windows-latest
             target: x86_64-pc-windows-msvc
             archive: zip
@@ -34,10 +34,9 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
         with:
           targets: ${{ matrix.target }}
-      - name: Install cmake (Linux)
-        if: runner.os == 'Linux'
-        run: sudo apt-get update && sudo apt-get install -y cmake
-
+      # - name: Install cmake (Linux)
+      #   if: runner.os == 'Linux'
+      #   run: sudo apt-get update && sudo apt-get install -y cmake
       - name: Build
         run: cargo build --release --target ${{ matrix.target }} -p infigraph-cli -p infigraph-mcp
 

crates/infigraph-cli/src/index.rs

@@ -88,12 +88,54 @@ pub(crate) fn cmd_index(root: &Path, full: bool, no_embed: bool) -> Result<()> {
         Err(e) => eprintln!("warning: document indexing failed: {e}"),
     }
 
-    // Auto-SCIP: detect languages and run available SCIP indexers
-    auto_scip(root, &result, prism.store())?;
+    // Drop prism to release the GraphStore handle before background SCIP
+    let detected_languages: std::collections::HashSet<String> = result.extractions.iter()
+        .map(|e| e.language.clone())
+        .collect();
+    drop(prism);
+
+    // SCIP enrichment in a detached child process — parent returns immediately.
+    spawn_scip_child_process(root, &detected_languages);
 
     Ok(())
 }
 
+fn spawn_scip_child_process(root: &Path, detected_languages: &std::collections::HashSet<String>) {
+    use crate::scip_download;
+
+    let indexers = scip_download::indexers_for_languages(detected_languages);
+    if indexers.is_empty() { return; }
+
+    let count = indexers.len();
+    let indexer_names: Vec<&str> = indexers.iter().map(|i| i.binary_name).collect();
+    println!("SCIP enrichment starting in background ({count} indexer(s): {})...", indexer_names.join(", "));
+
+    let langs: String = detected_languages.iter().cloned().collect::<Vec<_>>().join(",");
+
+    let exe = match std::env::current_exe() {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+
+    let log_path = root.join(".infigraph").join("scip-enrich.log");
+    let stderr_target = match std::fs::File::create(&log_path) {
+        Ok(f) => std::process::Stdio::from(f),
+        Err(_) => std::process::Stdio::null(),
+    };
+
+    let _ = std::process::Command::new(exe)
+        .arg("scip-enrich")
+        .arg("--languages")
+        .arg(&langs)
+        .current_dir(root)
+        .stdin(std::process::Stdio::null())
+        .stdout(std::process::Stdio::null())
+        .stderr(stderr_target)
+        .spawn();
+
+    eprintln!("  Log: {}", log_path.display());
+}
+
 pub(crate) fn on_path(cmd: &str) -> bool {
     let lookup = if cfg!(windows) { "where" } else { "which" };
     std::process::Command::new(lookup)

crates/infigraph-cli/src/install.rs

@@ -72,11 +72,7 @@ pub(crate) fn cmd_install() -> Result<()> {
     if configured.is_empty() {
         println!("No agents were configured.");
     } else {
-        println!(
-            "\nInstalled infigraph MCP server for {} agent(s): {}",
-            configured.len(),
-            configured.join(", ")
-        );
+        print_capabilities_summary(&configured);
     }
 
     // Write primary search instructions to ~/.claude/CLAUDE.md
@@ -396,6 +392,163 @@ pub(crate) fn cmd_uninstall() -> Result<()> {
     Ok(())
 }
 
+pub(crate) fn platform_triple() -> Result<(String, String, String)> {
+    let os = std::env::consts::OS;
+    let arch = std::env::consts::ARCH;
+    let os_tag = match os {
+        "macos" => "apple-darwin",
+        "linux" => "unknown-linux-gnu",
+        "windows" => "pc-windows-msvc",
+        _ => anyhow::bail!("unsupported OS: {os}"),
+    };
+    let arch_tag = match arch {
+        "x86_64" => "x86_64",
+        "aarch64" => "aarch64",
+        _ => anyhow::bail!("unsupported architecture: {arch}"),
+    };
+    let target = format!("{arch_tag}-{os_tag}");
+    Ok((os_tag.to_string(), arch_tag.to_string(), target))
+}
+
+pub(crate) fn self_update(version: &str) -> Result<()> {
+    let os = std::env::consts::OS;
+    let (_, _, target) = platform_triple()?;
+    let archive_ext = if os == "windows" { "zip" } else { "tar.gz" };
+    let asset_name = format!("infigraph-{target}.{archive_ext}");
+    let tag = format!("v{version}");
+
+    let gh_host =
+        std::env::var("INFIGRAPH_GH_HOST").unwrap_or_else(|_| "github.com".to_string());
+    let gh_owner =
+        std::env::var("INFIGRAPH_GH_OWNER").unwrap_or_else(|_| "intuit".to_string());
+    let gh_repo = "infigraph";
+    let full_repo = format!("{gh_host}/{gh_owner}/{gh_repo}");
+
+    println!("Downloading {asset_name} from release {tag}...");
+
+    let install_dir = std::env::var("INFIGRAPH_INSTALL_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            dirs::home_dir().unwrap_or_else(|| PathBuf::from(".")).join(".local").join("bin")
+        });
+
+    let tmp_dir = std::env::temp_dir();
+    let download_path = tmp_dir.join(&asset_name);
+
+    let mut gh_args = vec![
+        "release".to_string(), "download".to_string(), tag.clone(),
+        "--repo".to_string(), format!("{gh_owner}/{gh_repo}"),
+        "--pattern".to_string(), asset_name.clone(),
+        "--dir".to_string(), tmp_dir.to_string_lossy().to_string(),
+        "--clobber".to_string(),
+    ];
+    if gh_host != "github.com" {
+        gh_args.push("--hostname".to_string());
+        gh_args.push(gh_host.clone());
+    }
+
+    let status = std::process::Command::new("gh")
+        .args(&gh_args)
+        .status()
+        .context("failed to run `gh release download`")?;
+
+    if !status.success() {
+        anyhow::bail!("download failed for {asset_name} in release {tag} from {full_repo}");
+    }
+
+    std::fs::create_dir_all(&install_dir)?;
+
+    let bin_suffix = if os == "windows" { ".exe" } else { "" };
+    for bin in &["infigraph", "infigraph-mcp", "lsp-to-scip"] {
+        let bin_path = install_dir.join(format!("{bin}{bin_suffix}"));
+        let old_path = install_dir.join(format!("{bin}{bin_suffix}.old"));
+        if bin_path.exists() {
+            let _ = std::fs::remove_file(&old_path);
+            let _ = std::fs::rename(&bin_path, &old_path);
+        }
+    }
+
+    if archive_ext == "zip" {
+        let status = std::process::Command::new("unzip")
+            .args(["-o", &download_path.to_string_lossy(), "-d", &install_dir.to_string_lossy()])
+            .status()?;
+        if !status.success() {
+            anyhow::bail!("failed to extract zip");
+        }
+    } else {
+        let status = std::process::Command::new("tar")
+            .args(["-xzf", &download_path.to_string_lossy(), "-C", &install_dir.to_string_lossy()])
+            .status()?;
+        if !status.success() {
+            anyhow::bail!("failed to extract tar.gz");
+        }
+    }
+
+    let _ = std::fs::remove_file(&download_path);
+
+    for bin in &["infigraph", "infigraph-mcp", "lsp-to-scip"] {
+        let _ = std::fs::remove_file(install_dir.join(format!("{bin}{bin_suffix}.old")));
+    }
+
+    if os == "macos" {
+        for bin in &["infigraph", "infigraph-mcp", "lsp-to-scip"] {
+            let _ = std::process::Command::new("xattr")
+                .args(["-dr", "com.apple.quarantine", &install_dir.join(bin).to_string_lossy()])
+                .status();
+        }
+    }
+
+    if let Some(cache_path) = update_cache_path() {
+        let _ = std::fs::remove_file(&cache_path);
+    }
+
+    println!("Installed v{version} to {}", install_dir.display());
+    Ok(())
+}
+
+pub(crate) fn print_capabilities_summary(configured: &[&str]) {
+    let version = env!("CARGO_PKG_VERSION");
+    let count = configured.len();
+    let agents = configured.join(", ");
+
+    println!();
+    println!("Infigraph v{version} installed for {count} agent(s): {agents}");
+    println!();
+    println!("What you can do now:");
+    println!();
+    println!("  Index & Search");
+    println!("    infigraph index              Index your codebase (code + docs)");
+    println!("    infigraph search \"query\"      Hybrid BM25 + semantic search");
+    println!("    infigraph search-docs \"q\"     Search indexed documents");
+    println!();
+    println!("  Analysis");
+    println!("    infigraph dead-code          Find unreachable functions");
+    println!("    infigraph security           Scan for vulnerabilities (30+ patterns)");
+    println!("    infigraph complexity         Cyclomatic complexity hotspots");
+    println!("    infigraph check              CI quality gate (exit non-zero on violations)");
+    println!("    infigraph review             AI-powered PR review");
+    println!("    infigraph vulns              OSV vulnerability scanning");
+    println!();
+    println!("  Code Navigation");
+    println!("    infigraph impact <symbol>    Blast radius of a change");
+    println!("    infigraph routes             Detect HTTP/gRPC endpoints");
+    println!("    infigraph cluster            Detect functional modules");
+    println!("    infigraph architecture       Codebase overview");
+    println!("    infigraph refs <symbol>      Find all references");
+    println!();
+    println!("  Visualization");
+    println!("    infigraph visualize          Interactive graph in browser");
+    println!("    infigraph viz-sym <symbol>   Focused subgraph for one symbol");
+    println!();
+    println!("  Multi-Repo");
+    println!("    infigraph group create <name>  Create a service group");
+    println!("    infigraph group link           Link cross-service calls");
+    println!();
+    println!("  Get started:");
+    println!("    cd your-project && infigraph init");
+    println!();
+}
+
 pub(crate) fn update_cache_path() -> Option<PathBuf> {
     dirs::home_dir().map(|h| h.join(".infigraph").join("update_check.json"))
 }
@@ -492,9 +645,26 @@ pub(crate) fn print_update_hint(handle: Option<std::thread::JoinHandle<()>>) {
 }
 
 pub(crate) fn cmd_update() -> Result<()> {
-    println!("Updating infigraph...");
-    println!("Downloading latest install script and running it.");
-    println!("This will fetch the latest binary and re-register MCP configs.\n");
+    let current = env!("CARGO_PKG_VERSION");
+
+    // Try direct binary download via gh release if a new version is available
+    if let Some(latest) = fetch_latest_version() {
+        if version_newer(&latest, current) {
+            println!("Updating infigraph: v{current} → v{latest}");
+            match self_update(&latest) {
+                Ok(()) => return Ok(()),
+                Err(e) => {
+                    eprintln!("Binary update failed ({e}), falling back to install script...");
+                }
+            }
+        } else {
+            println!("Already at latest version v{current}.");
+            return Ok(());
+        }
+    }
+
+    // Fallback: install script
+    println!("Downloading latest install script and running it.\n");
 
     let gh_host =
         std::env::var("INFIGRAPH_GH_HOST").unwrap_or_else(|_| "github.com".to_string());