feat: use real homebrew untracked diff in filesystem view (#403)

## Summary

Start swapping out the fake data on the "Untracked" tab of file system view by integrating the same Homebrew diff that the pre-existing chip uses. This involves several changes and refactorings:

- Add separate sections for brews/casks/taps simiar to how the chip popup menu works.
- Add expanders since in practice some of these sections can get really long (see screenshot).
- Fix pre-existing unrelated bug with the brew list command and add logging so it's not totally silent in the future.
- Make the "untracked" banner on the begin step delay-loaded and dynamic with the correct count.
- Remove the "Track all" button since it never worked right and would work even less right with potentially hundreds of items. We can look into bringing it back once the untracked support is "done". Also see screenshot.

The data for "defaults" and "startup items" is still the fake data. I will work on defaults next. Note that there is a lot of demo/AI cruft remaining particularly in data.ts that will continue to disappear the closer we get to the goal.

Another potential follow-up item is some caching or limitations on how often we automatically scan, although empirically right now it's not unreasonably slow imo.

![Screenshot 2026-06-12 at 11.25.48 AM.png](https://app.graphite.com/user-attachments/assets/635f022e-e918-4f81-9177-c300c7e34489.png)

![Screenshot 2026-06-12 at 10.45.38 AM.png](https://app.graphite.com/user-attachments/assets/dc8b351c-6bd1-4833-a402-3a3b442eb84f.png)

<!-- What does this PR do? Why? -->

## Test Plan

Some minor updates to unit tests, plus lots of manual testing. Also needed to update a bunch of snaps, hopefully this doesn't run into merge issues etc.

- [ ] No test plan needed

## Docs

- [ ] Docs updated (companion PR in darkmatter/nixmac-web: #\___)
- [x] No docs update needed

Author: scottmcmaster

apps/native/src-tauri/examples/specta_gen_ts.rs

@@ -59,7 +59,8 @@ fn main() {
         .register::<shared_types::ThinkingEntry>()
         .register::<shared_types::ToolCallRecord>()
         .register::<shared_types::Evolution>()
-        .register::<shared_types::HomebrewCaskItem>()
+        .register::<shared_types::HomebrewItemType>()
+        .register::<shared_types::HomebrewItem>()
         .register::<shared_types::HomebrewState>()
         .register::<shared_types::SummarizedChange>()
         .register::<shared_types::SummarizedChangeSet>()

apps/native/src-tauri/src/commands/homebrew.rs

@@ -26,11 +26,11 @@ pub async fn homebrew_get_state_diff(
 }
 
 #[tauri::command]
-pub async fn homebrew_add_casks(
+pub async fn homebrew_add_items(
     app: AppHandle,
-    casks: Vec<shared_types::HomebrewCaskItem>,
+    items: Vec<shared_types::HomebrewItem>,
 ) -> Result<shared_types::ConfigEditApplyResult, String> {
-    crate::managed_edits::homebrew_adopt::add_homebrew_casks(&app, casks)
+    crate::managed_edits::homebrew_adopt::add_homebrew_items(&app, items)
         .await
-        .map_err(|e| capture_err("homebrew_add_casks", e))
+        .map_err(|e| capture_err("homebrew_add_items", e))
 }

apps/native/src-tauri/src/main.rs

@@ -488,7 +488,7 @@ fn run_gui_mode(
             #[cfg(debug_assertions)]
             commands::debug::e2e_mark_boot_stage,
             // Homebrew
-            commands::homebrew::homebrew_add_casks,
+            commands::homebrew::homebrew_add_items,
             commands::homebrew::homebrew_apply_diff,
             commands::homebrew::homebrew_get_state_diff,
             // Git

apps/native/src-tauri/src/managed_edits/homebrew_adopt.rs

@@ -1,13 +1,13 @@
 use crate::evolve::file_ops::resolve_path_in_dir_allow_create;
 use crate::evolve::nix_file_editor::{apply_semantic_edit, nix_quote_values};
 use crate::evolve::types::{FileEditAction, SemanticFileEdit};
-use crate::shared_types::HomebrewState;
+use crate::shared_types::{HomebrewItemType, HomebrewState};
 use crate::system::nix_ast_lists::parse_string_lists_by_attrpath;
 use crate::system::scanner::inject_module_import;
 use crate::{managed_edits::managed_edit, shared_types};
 use anyhow::{Context, Result};
 use serde_json::{Map, Value};
-use shared_types::HomebrewCaskItem;
+use shared_types::HomebrewItem;
 use tauri::AppHandle;
 
 const NIXMAC_HOMEBREW_DATA_PATH: &str = ".nixmac/homebrew/data.json";
@@ -202,7 +202,9 @@ pub async fn apply_homebrew_diff(
 }
 
 /// Scan the system for Homebrew packages, casks, and taps.
-/// Only includes explicitly installed brews and casks (via `--installed-on-request`), not their dependencies.
+/// Only includes explicitly installed brews and casks not their dependencies.
+/// Note that generally speaking, `brew list --casks` does *not* count dependences, and
+/// the `--installed-on-request` flag is not valid for casks.
 /// Excludes default taps (homebrew/core, homebrew/cask).
 /// If homebrew is not installed, returns an empty state with is_installed set to false.
 pub fn scan_homebrew() -> HomebrewState {
@@ -221,10 +223,12 @@ pub fn scan_homebrew() -> HomebrewState {
                 .lines()
                 .map(str::to_owned)
                 .collect();
+        } else {
+            log::warn!("failed to scan Homebrew brews: brew command returned non-zero exit code");
         }
     }
     if let Ok(output) = std::process::Command::new("brew")
-        .args(["list", "--installed-on-request", "--cask"])
+        .args(["list", "--cask"])
         .env("PATH", crate::system::nix::get_nix_path())
         .output()
     {
@@ -233,6 +237,8 @@ pub fn scan_homebrew() -> HomebrewState {
                 .lines()
                 .map(str::to_owned)
                 .collect();
+        } else {
+            log::warn!("failed to scan Homebrew casks: brew command returned non-zero exit code");
         }
     }
     if let Ok(output) = std::process::Command::new("brew")
@@ -249,6 +255,8 @@ pub fn scan_homebrew() -> HomebrewState {
                 })
                 .map(str::to_owned)
                 .collect();
+        } else {
+            log::warn!("failed to scan Homebrew taps: brew command returned non-zero exit code");
         }
     }
 
@@ -451,30 +459,63 @@ fn ensure_nixmac_module_import(config_dir: &std::path::Path) -> Result<()> {
     Ok(())
 }
 
-fn add_homebrew_casks_to_config(
+fn add_homebrew_items_to_config(
     config_dir: &std::path::Path,
-    casks: &[HomebrewCaskItem],
+    items: &[HomebrewItem],
 ) -> Result<std::path::PathBuf> {
-    if casks.is_empty() {
-        return Err(anyhow::anyhow!("at least one Homebrew cask is required"));
+    if items.is_empty() {
+        return Err(anyhow::anyhow!("at least one Homebrew item is required"));
     }
 
-    let cask_names = casks
+    let item_names = items
         .iter()
-        .map(|cask| cask.name.trim())
+        .map(|item| item.name.trim())
         .filter(|name| !name.is_empty())
         .map(str::to_string)
         .collect::<Vec<_>>();
-    if cask_names.is_empty() {
+    if item_names.is_empty() {
         return Err(anyhow::anyhow!(
-            "at least one named Homebrew cask is required"
+            "at least one named Homebrew item is required"
         ));
     }
 
     ensure_nixmac_module_import(config_dir)?;
     let data_path = ensure_nixmac_homebrew_module(config_dir)?;
     let mut data = read_homebrew_data(&data_path)?;
-    merge_json_array(&mut data, "casks", &cask_names)?;
+
+    // Separate out the casks/brews/formulae so we can do 0..3 merge_json_array calls for each.
+    let casks = items
+        .iter()
+        .filter(|item| item.item_type == HomebrewItemType::Cask)
+        .map(|item| item.name.trim())
+        .filter(|name| !name.is_empty())
+        .map(str::to_string)
+        .collect::<Vec<_>>();
+    if !casks.is_empty() {
+        merge_json_array(&mut data, "casks", &casks)?;
+    }
+
+    let brews = items
+        .iter()
+        .filter(|item| item.item_type == HomebrewItemType::Brew)
+        .map(|item| item.name.trim())
+        .filter(|name| !name.is_empty())
+        .map(str::to_string)
+        .collect::<Vec<_>>();
+    if !brews.is_empty() {
+        merge_json_array(&mut data, "brews", &brews)?;
+    }
+
+    let taps = items
+        .iter()
+        .filter(|item| item.item_type == HomebrewItemType::Tap)
+        .map(|item| item.name.trim())
+        .filter(|name| !name.is_empty())
+        .map(str::to_string)
+        .collect::<Vec<_>>();
+    if !taps.is_empty() {
+        merge_json_array(&mut data, "taps", &taps)?;
+    }
 
     let rendered = serde_json::to_string_pretty(&data)?;
     std::fs::write(&data_path, format!("{}\n", rendered))
@@ -483,31 +524,31 @@ fn add_homebrew_casks_to_config(
     Ok(data_path)
 }
 
-/// Adds one or more Homebrew casks to the managed Nixmac Homebrew data file,
+/// Adds one or more Homebrew items to the managed Nixmac Homebrew data file,
 /// snapshots the pre-edit tree onto a rollback branch, and enters the managed
 /// review flow.
-pub async fn add_homebrew_casks(
+pub async fn add_homebrew_items(
     app: &AppHandle,
-    casks: Vec<HomebrewCaskItem>,
+    items: Vec<HomebrewItem>,
 ) -> Result<shared_types::ConfigEditApplyResult> {
-    let item_count = casks
+    let item_count = items
         .iter()
-        .filter(|cask| !cask.name.trim().is_empty())
+        .filter(|item| !item.name.trim().is_empty())
         .count();
-    if casks.is_empty() {
-        return Err(anyhow::anyhow!("at least one Homebrew cask is required"));
+    if items.is_empty() {
+        return Err(anyhow::anyhow!("at least one Homebrew item is required"));
     }
     if item_count == 0 {
         return Err(anyhow::anyhow!(
-            "at least one named Homebrew cask is required"
+            "at least one named Homebrew item is required"
         ));
     }
 
     let context = managed_edit::prepare_managed_edit(app)?;
     let dir = context.dir.clone();
 
-    add_homebrew_casks_to_config(std::path::Path::new(&dir), &casks)
-        .context("Failed to add Homebrew casks")?;
+    add_homebrew_items_to_config(std::path::Path::new(&dir), &items)
+        .context("Failed to add Homebrew items")?;
 
     let working_tree_status =
         crate::git::status(&dir).context("Failed to get working tree status for evolve state")?;
@@ -516,7 +557,7 @@ pub async fn add_homebrew_casks(
         context,
         working_tree_status,
         item_count,
-        "add_homebrew_casks",
+        "add_homebrew_items",
     )
     .await
 }
@@ -665,6 +706,8 @@ pub fn apply_homebrew_import(diff: HomebrewState, config_dir: &std::path::Path)
 
 #[cfg(test)]
 mod tests {
+    use crate::shared_types::HomebrewItemType;
+
     use super::*;
 
     fn homebrew_state(
@@ -981,7 +1024,7 @@ mod tests {
     }
 
     #[test]
-    fn add_homebrew_casks_writes_managed_data_and_injects_flake_import() {
+    fn add_homebrew_items_writes_managed_data_and_injects_flake_import() {
         let temp = tempfile::tempdir().expect("tempdir should be created");
         let flake = temp.path().join("flake.nix");
         write_file(
@@ -1007,16 +1050,29 @@ mod tests {
 "#,
         );
 
-        let data_file = add_homebrew_casks_to_config(
+        // Make sure to test all three item types.
+        let data_file = add_homebrew_items_to_config(
             temp.path(),
             &[
-                HomebrewCaskItem {
+                HomebrewItem {
                     name: "docker".to_string(),
                     version: Some("4.32.0".to_string()),
+                    item_type: HomebrewItemType::Cask,
                 },
-                HomebrewCaskItem {
+                HomebrewItem {
                     name: " obs ".to_string(),
                     version: Some("30.2.3".to_string()),
+                    item_type: HomebrewItemType::Cask,
+                },
+                HomebrewItem {
+                    name: "git".to_string(),
+                    version: Some("2.42.0".to_string()),
+                    item_type: HomebrewItemType::Brew,
+                },
+                HomebrewItem {
+                    name: "homebrew/cask-fonts".to_string(),
+                    version: None,
+                    item_type: HomebrewItemType::Tap,
                 },
             ],
         )
@@ -1029,22 +1085,26 @@ mod tests {
         )
         .expect("homebrew data should parse");
         assert_eq!(json_string_array(&data, "casks"), vec!["docker", "obs"]);
-        assert_eq!(json_string_array(&data, "brews"), Vec::<String>::new());
-        assert_eq!(json_string_array(&data, "taps"), Vec::<String>::new());
+        assert_eq!(json_string_array(&data, "brews"), vec!["git"]);
+        assert_eq!(
+            json_string_array(&data, "taps"),
+            vec!["homebrew/cask-fonts"]
+        );
 
         let flake_content = std::fs::read_to_string(flake).expect("flake should remain readable");
         assert!(flake_content.contains("./.nixmac"));
     }
 
     #[test]
-    fn add_homebrew_casks_requires_flake_before_writing_module() {
+    fn add_homebrew_items_requires_flake_before_writing_module() {
         let temp = tempfile::tempdir().expect("tempdir should be created");
 
-        let err = add_homebrew_casks_to_config(
+        let err = add_homebrew_items_to_config(
             temp.path(),
-            &[HomebrewCaskItem {
+            &[HomebrewItem {
                 name: "iterm2".to_string(),
                 version: None,
+                item_type: HomebrewItemType::Cask,
             }],
         )
         .expect_err("managed Homebrew casks should require flake.nix");

apps/native/src-tauri/src/shared_types/managed_edits.rs

@@ -3,7 +3,16 @@ use specta::Type;
 
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, Type)]
 #[serde(rename_all = "camelCase")]
-pub struct HomebrewCaskItem {
+pub enum HomebrewItemType {
+    Tap,
+    Cask,
+    Brew,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct HomebrewItem {
     pub name: String,
     pub version: Option<String>,
+    pub item_type: HomebrewItemType,
 }