Fusion - the Fusion 360 Bridge

@@ -770,6 +770,54 @@ fn native_aps_browse(args: &Value) -> Value { }  /// `fusion_aps_search`: the server-indexed name search across the hub, newest first.+/// Non-index name search: list folder CONTENTS (Data API, never the search index) under the+/// scanned top folders, breadth first to `max_depth`, at most `max_folders` listings, 12 in+/// parallel. Returns items whose display name contains every token (issue #85).+fn contents_name_scan(store: &fusion_core::aps::ApsStore, tasks: &[(String, String, String)], toks: &[&str], max_depth: usize, max_folders: usize) -> Value {+    use std::sync::{Arc, Mutex};+    use fusion_core::aps::{aps_get, urlencode};+    let queue: Arc<Mutex<std::collections::VecDeque<(String, String, String, usize)>>> = Arc::new(Mutex::new(tasks.iter().map(|(p, pn, f)| (p.clone(), pn.clone(), f.clone(), 0usize)).collect()));+    let listed = Arc::new(Mutex::new(0usize));+    let hits: Arc<Mutex<Vec<Value>>> = Arc::new(Mutex::new(Vec::new()));+    let toks: Vec<String> = toks.iter().map(|t| t.to_string()).collect();+    let dir = store.dir.clone();+    let mut handles = Vec::new();+    for _ in 0..12 {+        let (queue, listed, hits, dir, toks) = (queue.clone(), listed.clone(), hits.clone(), dir.clone(), toks.clone());+        handles.push(std::thread::spawn(move || {+            let store = fusion_core::aps::ApsStore { dir };+            let mut idle = 0;+            loop {+                let next = queue.lock().unwrap().pop_front();+                let Some((pid, pname, fid, depth)) = next else { idle += 1; if idle > 20 { break; } std::thread::sleep(std::time::Duration::from_millis(100)); continue; };+                idle = 0;+                { let mut l = listed.lock().unwrap(); if *l >= max_folders { continue; } *l += 1; }+                let (s, b) = aps_get(&store, &format!("/data/v1/projects/{}/folders/{}/contents", urlencode(&pid), urlencode(&fid)), &[("page[limit]", "200")]).unwrap_or((0, json!({})));+                if s != 200 { continue; }+                for it in b["data"].as_array().cloned().unwrap_or_default() {+                    let ty = it["type"].as_str().unwrap_or("");+                    let name = it["attributes"]["displayName"].as_str().or(it["attributes"]["name"].as_str()).unwrap_or("").to_string();+                    if ty == "folders" {+                        if depth + 1 <= max_depth { queue.lock().unwrap().push_back((pid.clone(), pname.clone(), it["id"].as_str().unwrap_or("").to_string(), depth + 1)); }+                        continue;+                    }+                    let nl = name.to_lowercase();+                    if !toks.is_empty() && toks.iter().all(|t| nl.contains(t.as_str())) {+                        hits.lock().unwrap().push(json!({"name": name, "type": ty, "id": it["id"], "lineageUrn": it["id"], "projectId": pid, "projectName": pname, "folderId": fid,+                            "lastModified": it["attributes"]["lastModifiedTime"], "source": "folder-contents"}));+                    }+                }+            }+        }));+    }+    for h in handles { let _ = h.join(); }+    let mut out = hits.lock().unwrap().clone();+    out.sort_by(|a, b| b["lastModified"].as_str().unwrap_or("").cmp(a["lastModified"].as_str().unwrap_or("")));+    let mut seen = std::collections::HashSet::new();+    let out: Vec<Value> = out.into_iter().filter(|r| seen.insert(r["id"].as_str().unwrap_or("").to_string())).collect();+    json!(out)+}+ pub(crate) fn native_aps_search(args: &Value) -> Value {     crate::palette::say("Searching your hub", &format!("cloud search for {}", args["query"].as_str().unwrap_or("")), None, None);     use fusion_core::aps::*;@@ -782,6 +830,7 @@ pub(crate) fn native_aps_search(args: &Value) -> Value {         "_hint": "Token may lack data:read scope or the app isn't Data-Management-enabled.", "shell": "rust"}) };     let mut scanned = (0, 0, 0);     let tasks = scan_tasks(&store, &hubs, args["hubId"].as_str(), args["projectId"].as_str(), &mut scanned);+    let tasks_snapshot: Vec<(String, String, String)> = tasks.iter().map(|t| (t.project_id.clone(), t.project_name.clone(), t.folder_id.clone())).collect();     let mut results = scan_parallel(&store, tasks, &query, limit, true);     results.sort_by(|a, b| b["lastModified"].as_str().unwrap_or("").cmp(a["lastModified"].as_str().unwrap_or("")));     let n = results.len();@@ -792,18 +841,19 @@ pub(crate) fn native_aps_search(args: &Value) -> Value {         // the recently modified items the bridge can list without a full walk.         let ql = query.to_lowercase();         let toks: Vec<&str> = ql.split_whitespace().collect();-        let recent = native_aps_recent(&json!({"limit": 400, "hubId": args["hubId"], "projectId": args["projectId"]}));-        let fb: Vec<Value> = recent["data"]["results"].as_array().cloned().unwrap_or_default().into_iter()-            .filter(|i| { let nm = i["name"].as_str().unwrap_or("").to_lowercase(); !toks.is_empty() && toks.iter().all(|t| nm.contains(t)) }).take(limit).collect();+        // The index fallback (recent items) is index-backed too, so it misses the same file; the+        // Data API folder CONTENTS listing is not. Walk the scanned top folders two levels deep,+        // bounded, and match names directly.+        let fb: Vec<Value> = contents_name_scan(&store, &tasks_snapshot, &toks, 2, 80).as_array().cloned().unwrap_or_default();         let nf = fb.len();-        let folder_hint = fb.first().and_then(|f| f["folderId"].as_str().or(f["parentFolderId"].as_str())).map(|f| format!(" The first fallback hit lives in folder {f}; fusion_aps_browse {{folderId}} lists that folder in full.")).unwrap_or_default();+        let folder_hint = fb.first().and_then(|f| f["folderId"].as_str()).map(|f| format!(" The first fallback hit lives in folder {f}; fusion_aps_browse {{folderId}} lists that folder in full.")).unwrap_or_default();         return json!({"success": true, "output": format!("0 index match(es) for '{query}'; {nf} by name in recent items"),             "data": {"query": query, "count": 0, "results": [], "scanned": {"hubs": scanned.0, "projects": scanned.1, "folders": scanned.2},-                     "fallback": {"source": "recent-items name scan (newest 400 across the scanned projects)", "count": nf, "results": fb},+                     "fallback": {"source": "Data API folder contents (not the index): the scanned top folders walked two levels deep, at most 80 folder listings, names matched directly", "count": nf, "results": fb},                      "completeness": "The APS server index can lag a new or renamed file by minutes to hours and tokenises names, so a zero here does not prove absence."},             "shell": "rust",             "_hint": format!("No index match for '{query}'.{} {}Next: fusion_aps_browse a known sibling's folder (scoped, no cloud walk), or pass projectId to narrow the scan. Do not conclude the file is missing from an index zero alone.",-                if nf > 0 { format!(" {nf} recently modified item(s) match by name (data.fallback); open one with fusion_aps_open or fusion_open_by_urn.") } else { " Nothing in the newest 400 items matches by name either.".to_string() }, folder_hint)});+                if nf > 0 { format!(" {nf} item(s) match by name in the folder contents walk (data.fallback, with folderId and lineage); open one with fusion_open_by_urn.") } else { " A bounded folder-contents walk (two levels under each top folder) found nothing by name either; a deeper folder needs fusion_aps_browse {folderId}.".to_string() }, folder_hint)});     }     json!({"success": true, "output": format!("{n} match(es) for '{query}'"),            "data": {"query": query, "count": n, "results": shown, "scanned": {"hubs": scanned.0, "projects": scanned.1, "folders": scanned.2}}, "shell": "rust",