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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.28.3" # 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.3 → 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.3 → 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.3 → 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();