cc-transcript 14.28.2__tar.gz → 14.28.4__tar.gz

{cc_transcript-14.28.2 → cc_transcript-14.28.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.28.2
+Version: 14.28.4
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{cc_transcript-14.28.2 → cc_transcript-14.28.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.28.2" # informational — releases stamp the version from the git tag
+version = "14.28.4" # informational — releases stamp the version from the git tag
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

{cc_transcript-14.28.2 → cc_transcript-14.28.4}/rust/crates/cli/src/target.rs

@@ -1,6 +1,7 @@
 //! Target discovery and parsing shared by every transcript command (cli.py's
 //! discover / resolve_targets / parse_transcripts / scope_note plumbing).
 
+use std::fs;
 use std::path::{Path, PathBuf};
 
 use cc_transcript_core::discovery::{find_in, mtime_secs};
@@ -26,23 +27,26 @@ pub struct Targets {
     pub total: usize,
 }
 
-fn project_matches(path: &Path, root: &Path, project: Option<&str>) -> bool {
-    let Some(project) = project else { return true };
-    let Ok(rel) = path.strip_prefix(root) else {
-        return false;
-    };
-    let parts: Vec<_> = rel.components().collect();
-    parts[..parts.len().saturating_sub(1)]
-        .iter()
-        .any(|part| part.as_os_str().to_string_lossy().contains(project))
-}
-
 /// Newest-first discovery under `root` (cli.py discover): find_in order, project
 /// filtered, stable-sorted by mtime descending.
 pub fn discover(root: &Path, project: Option<&str>, contains: Option<&str>) -> Vec<(PathBuf, f64)> {
-    let mut found: Vec<(PathBuf, f64)> = find_in(root, contains, None, None)
-        .into_iter()
-        .filter(|(path, _)| project_matches(path, root, project))
+    let roots = if let Some(project) = project {
+        fs::read_dir(root)
+            .map(|entries| {
+                entries
+                    .flatten()
+                    .filter(|entry| entry.file_type().is_ok_and(|kind| kind.is_dir()))
+                    .filter(|entry| entry.file_name().to_string_lossy().contains(project))
+                    .map(|entry| entry.path())
+                    .collect()
+            })
+            .unwrap_or_default()
+    } else {
+        vec![root.to_path_buf()]
+    };
+    let mut found: Vec<(PathBuf, f64)> = roots
+        .iter()
+        .flat_map(|root| find_in(root, contains, None, None))
         .collect();
     found.sort_by(|a, b| b.1.partial_cmp(&a.1).expect("mtimes are finite"));
     found
@@ -237,3 +241,24 @@ pub fn py_path(arg: &str) -> PathBuf {
     };
     PathBuf::from(text)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::discover;
+
+    #[test]
+    fn project_discovery_only_walks_matching_roots() {
+        let root = tempfile::tempdir().unwrap();
+        let wanted = root.path().join("wanted-project");
+        let other = root.path().join("other-project");
+        std::fs::create_dir(&wanted).unwrap();
+        std::fs::create_dir(&other).unwrap();
+        std::fs::write(wanted.join("match.jsonl"), "{}").unwrap();
+        std::fs::write(other.join("match.jsonl"), "{}").unwrap();
+
+        let found = discover(root.path(), Some("wanted"), None);
+
+        assert_eq!(found.len(), 1);
+        assert_eq!(found[0].0, wanted.join("match.jsonl"));
+    }
+}

{cc_transcript-14.28.2 → cc_transcript-14.28.4}/rust/crates/core/src/scan.rs

@@ -292,8 +292,46 @@ impl<'a> ScanSession<'a> {
         }
         let canonical_root =
             std::fs::canonicalize(&plan.root).map_err(|error| incomplete(error.to_string()))?;
+        let roots = if let Some(project) = &plan.project {
+            let mut roots = Vec::new();
+            for entry in
+                std::fs::read_dir(&plan.root).map_err(|error| incomplete(error.to_string()))?
+            {
+                self.budget.checkpoint(&self.cancel)?;
+                self.budget.progress.discovery_entries += 1;
+                if self.budget.progress.discovery_entries > self.budget.limits.max_discovery_entries
+                {
+                    return Err(incomplete("project discovery budget exhausted"));
+                }
+                let entry = entry.map_err(|error| incomplete(error.to_string()))?;
+                if entry
+                    .file_type()
+                    .map_err(|error| incomplete(error.to_string()))?
+                    .is_dir()
+                    && entry.file_name().to_string_lossy().contains(project)
+                {
+                    roots.push(entry.path());
+                }
+            }
+            roots
+        } else {
+            vec![plan.root.clone()]
+        };
+        if roots.is_empty() {
+            return Ok((Vec::new(), 0));
+        }
         let mut request = self.bounded_request("discover");
-        request.insert("roots", json!([plan.root.to_string_lossy().as_ref()]));
+        request.insert(
+            "roots",
+            json!(roots
+                .iter()
+                .map(|root| root.to_string_lossy().into_owned())
+                .collect::<Vec<_>>()),
+        );
+        request["limits"].insert(
+            "max_items",
+            json!(self.budget.remaining().max_discovery_entries),
+        );
         request.insert("preserve_aliases", json!(true));
         request.insert("follow_directory_symlinks", json!(false));
         let mut paths = Vec::new();

{cc_transcript-14.28.2 → cc_transcript-14.28.4}/rust/crates/core/src/scan_regressions.rs

@@ -85,6 +85,42 @@ fn exhausted_discovery_does_not_read_a_body() {
     assert_eq!(result.progress.source_opens, 0);
 }
 
+#[test]
+fn project_filter_skips_other_directories_before_the_scan() {
+    let fixture = Fixture::new();
+    let wanted = fixture.0.join("wanted-project");
+    let other = fixture.0.join("other-project");
+    std::fs::create_dir(&wanted).unwrap();
+    std::fs::create_dir(&other).unwrap();
+    let event = "{\"type\":\"user\",\"uuid\":\"a\",\"sessionId\":\"s\",\"timestamp\":\"2026-01-01T00:00:00Z\",\"message\":{\"role\":\"user\",\"content\":\"match\"}}\n";
+    for name in ["first.jsonl", "second.jsonl"] {
+        std::fs::write(wanted.join(name), event).unwrap();
+    }
+    for index in 0..10 {
+        std::fs::write(other.join(format!("{index}.jsonl")), event).unwrap();
+    }
+    let mut bound = limits();
+    bound.max_items = 1;
+    bound.max_discovery_entries = 6;
+    let store = NativeStore::new(&json!({})).unwrap();
+    let mut scan = ScanSession::new(&store, bound, Cancellation::default());
+    let plan = ScanPlan {
+        project: Some("wanted".to_owned()),
+        ..fixture.plan(vec![])
+    };
+    let mut visited = Vec::new();
+    let result = scan.run(&plan, |path, _, _, _| {
+        visited.push(path.file_name().unwrap().to_string_lossy().into_owned());
+        Ok(ScanControl::Continue)
+    });
+    assert!(result.complete, "{:?}", result.reason);
+    assert_eq!(result.selected_sources, 2);
+    assert_eq!(result.available_sources, 2);
+    assert!(result.progress.discovery_entries <= 6);
+    visited.sort();
+    assert_eq!(visited, ["first.jsonl", "second.jsonl"]);
+}
+
 #[test]
 fn explicit_paths_keep_their_order() {
     let fixture = Fixture::new();

{cc_transcript-14.28.2 → cc_transcript-14.28.4}/rust/crates/core/src/snapshot.rs

@@ -559,7 +559,11 @@ struct CachedPreparedFacts {
 }
 
 enum PreparedSourceOutcome {
-    Ready(SourceStamp, Arc<crate::snapshot_prepared::PreparedFacts>),
+    Ready {
+        stamp: SourceStamp,
+        facts: Arc<crate::snapshot_prepared::PreparedFacts>,
+        cached: bool,
+    },
     Pending(String),
 }
 
@@ -7439,6 +7443,38 @@ mod tests {
             checks <= 5 * 929,
             "warm verification made {checks} metadata checks"
         );
+        let deadline = now_ms() + 750;
+        let started = std::time::Instant::now();
+        let before_query_bytes = store.state.lock().unwrap().counters[1];
+        for query in [
+            json!({"kind":"has_edit_to","values":["src/**"]}),
+            json!({"kind":"has_read","pattern":"missing","subagents":true}),
+        ] {
+            let mut reply = store.request(
+                &json!({"schema":SCHEMA,"id":"query","operation":"query_graph","handle":graph["data"]["handle"],"selectors":[],"query":query,"deadline_unix_ms":deadline,"limits":template["limits"]}),
+                &owner,
+                &Cancellation::default(),
+            );
+            let mut pages = 1;
+            while reply["status"].as_str() == Some("incomplete") {
+                let cursor = reply["cursor"].as_str().expect("cached query cursor");
+                reply = store.request(
+                    &json!({"schema":SCHEMA,"id":"resume","operation":"resume","cursor":cursor}),
+                    &owner,
+                    &Cancellation::default(),
+                );
+                pages += 1;
+            }
+            assert_eq!(reply["status"].as_str(), Some("ok"), "{reply:?}");
+            assert_eq!(reply["data"]["value"].as_bool(), Some(false));
+            assert!(pages <= 4, "cached query took {pages} pages");
+        }
+        assert_eq!(store.state.lock().unwrap().counters[1], before_query_bytes);
+        assert!(
+            started.elapsed().as_millis() < 750,
+            "two cached queries took {:?}",
+            started.elapsed()
+        );
     }
 
     #[test]

{cc_transcript-14.28.2 → cc_transcript-14.28.4}/rust/crates/core/src/snapshot_prepared_service.rs

@@ -208,7 +208,14 @@ impl NativeStore {
                 })
         } {
             usage[7] += 1;
-            return Ok((stamp, PreparedSourceOutcome::Ready(stamp, facts)));
+            return Ok((
+                stamp,
+                PreparedSourceOutcome::Ready {
+                    stamp,
+                    facts,
+                    cached: true,
+                },
+            ));
         }
         let key = crate::snapshot_prepared_disk::PreparedDiskKey::new(
             stamp,
@@ -222,7 +229,11 @@ impl NativeStore {
                 usage[7] += 1;
                 return Ok((
                     stamp,
-                    PreparedSourceOutcome::Ready(stamp, Arc::new(facts)),
+                    PreparedSourceOutcome::Ready {
+                        stamp,
+                        facts: Arc::new(facts),
+                        cached: true,
+                    },
                 ));
             }
             crate::snapshot_prepared_disk::DiskLookup::Retired => {
@@ -376,7 +387,11 @@ impl NativeStore {
             .expect("snapshot state")
             .prepared_loads
             .remove(&stamp.identity);
-        Ok(PreparedSourceOutcome::Ready(stamp, facts))
+        Ok(PreparedSourceOutcome::Ready {
+            stamp,
+            facts,
+            cached: false,
+        })
     }
 
     fn warm_membership_key(
@@ -1247,7 +1262,7 @@ impl NativeStore {
             let mut rounds = 0;
             loop {
                 match outcome {
-                    PreparedSourceOutcome::Ready(stamp, _) => {
+                    PreparedSourceOutcome::Ready { stamp, .. } => {
                         if stamp != source.stamp {
                             return Err(SnapshotError::new(
                                 Status::Changed,
@@ -1440,6 +1455,8 @@ impl NativeStore {
         let mut records = Vec::new();
         let mut bytes = 128usize;
         let mut steps = 0usize;
+        let mut uncached_steps = 0usize;
+        let page_steps = if inputs { 8 } else { 256 };
         let page_items = self.config.page_items.min(cursor.remaining.max_items);
         let output_limit = cursor
             .page_output_bytes
@@ -1451,7 +1468,11 @@ impl NativeStore {
                 "prepared query output budget exhausted",
             ));
         }
-        while cursor.next < total && steps < 8 && (!inputs || records.len() < page_items) {
+        while cursor.next < total
+            && steps < page_steps
+            && uncached_steps < 8
+            && (!inputs || records.len() < page_items)
+        {
             cancel.check(cursor.remaining.deadline_unix_ms)?;
             if inputs && cursor.next == 0 {
                 let record = cursor.root_record.as_ref().expect("input root record").clone();
@@ -1491,6 +1512,7 @@ impl NativeStore {
                         pending.token = next;
                         cursor.pending = Some(pending);
                         steps += 1;
+                        uncached_steps += 1;
                         continue;
                     }
                     Ok(ready) => ready,
@@ -1518,12 +1540,18 @@ impl NativeStore {
                             stamp: source.stamp,
                         });
                         steps += 1;
+                        uncached_steps += 1;
                         continue;
                     }
                     (_, ready) => ready,
                 }
             };
-            let PreparedSourceOutcome::Ready(stamp, facts) = outcome else {
+            let PreparedSourceOutcome::Ready {
+                stamp,
+                facts,
+                cached,
+            } = outcome
+            else {
                 return Err(invalid("prepared source did not finish"));
             };
             if stamp != source.stamp {
@@ -1554,6 +1582,7 @@ impl NativeStore {
             }
             cursor.next += 1;
             steps += 1;
+            uncached_steps += usize::from(!cached);
         }
         if cursor.next == total {
             if !self.validate_source_stamps(