cc-transcript 14.45.13__tar.gz → 14.45.15__tar.gz

{cc_transcript-14.45.13 → cc_transcript-14.45.15}/PKG-INFO

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

{cc_transcript-14.45.13 → cc_transcript-14.45.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.45.13" # informational — releases stamp the version from the git tag
+version = "14.45.15" # 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.45.13 → cc_transcript-14.45.15}/rust/crates/core/src/snapshot.rs

@@ -7143,6 +7143,7 @@ impl NativeStore {
         let mut lines: Vec<(u64, Vec<Entry>)> = Vec::new();
         let mut events = 0usize;
         let mut exhausted = false;
+        let mut read_step = self.config.read_step.min(64 * 1024);
         loop {
             while events < count {
                 cancel.check(limits.deadline_unix_ms)?;
@@ -7165,11 +7166,7 @@ impl NativeStore {
                 }
                 break;
             }
-            let step = self
-                .config
-                .read_step
-                .min(budget - read)
-                .min(pending_start as usize);
+            let step = read_step.min(budget - read).min(pending_start as usize);
             if step == 0 {
                 exhausted = true;
                 break;
@@ -7183,6 +7180,7 @@ impl NativeStore {
             file.read_exact(&mut block).map_err(io_error)?;
             usage[1] += step as u64;
             read += step;
+            read_step = read_step.saturating_mul(2).min(self.config.read_step);
             block.extend_from_slice(&pending);
             pending = block;
             pending_start -= step as u64;
@@ -11662,6 +11660,60 @@ mod tests {
         assert_eq!(state.counters[4], 1);
         assert_eq!(state.counters[1], pinned_size + 128);
     }
+    #[test]
+    fn turn_projection_cursor_preserves_native_page_status_and_zero_item_incompleteness() {
+        let source = Source::new(
+            &(0..600)
+                .map(|index| format!("{}\n", user(&format!("u{index}"))))
+                .collect::<String>(),
+        );
+        let store = NativeStore::new(&json!({})).unwrap();
+        let owner = context("turn-pages");
+        let cancel = Cancellation::default();
+        let mut acquiring = acquire(&source.path);
+        acquiring["limits"].insert("max_events", json!(10000));
+        let root = finish(&store, store.request(&acquiring, &owner, &cancel), &owner);
+        assert_eq!(root["status"].as_str(), Some("ok"));
+        for reverse in [false, true] {
+            let mut req = graph_request(
+                &root,
+                json!({"kind":"turns","order":if reverse {"reverse"} else {"forward"}}),
+                Vec::new(),
+                json!([]),
+            );
+            req["limits"].insert("max_events", json!(10000));
+            req["limits"].insert("max_items", json!(600));
+            req["limits"].insert("max_read_bytes", json!(16 * 1024 * 1024));
+            let mut response = store.request(&req, &owner, &cancel);
+            for (page_index, expected_items) in [256, 256, 88].into_iter().enumerate() {
+                assert_eq!(
+                    response["data"]["records_json"].as_array().unwrap().len(),
+                    expected_items
+                );
+                if page_index == 2 {
+                    assert_eq!(response["status"].as_str(), Some("ok"));
+                    assert!(response["cursor"].is_null());
+                    assert!(response["reason"].is_null());
+                } else {
+                    assert_eq!(response["status"].as_str(), Some("incomplete"));
+                    assert_eq!(response["reason"].as_str(), Some("item_limit"));
+                    let cursor = response["cursor"].as_str().unwrap().to_owned();
+                    response = store.request(
+                        &json!({"schema":SCHEMA,"id":"turn-resume","operation":"resume","cursor":cursor}),
+                        &owner,
+                        &cancel,
+                    );
+                }
+            }
+            req["limits"].insert("max_items", json!(0));
+            let zero = store.request(&req, &owner, &cancel);
+            assert_eq!(zero["status"].as_str(), Some("incomplete"));
+            assert_eq!(zero["reason"].as_str(), Some("item_limit"));
+            assert!(zero["cursor"].is_null());
+            assert!(zero["data"]["records_json"].as_array().unwrap().is_empty());
+        }
+    }
+
     fn graph_request(
         root: &Value,
         query: Value,
@@ -12203,6 +12255,192 @@ mod tests {
             .collect()
     }
 
+    fn tail_with_small_step_reference(source: &Source, count: usize, budget: usize) -> Value {
+        let owner = context("a");
+        let request = tail_request(&source.path, count, budget);
+        let store = NativeStore::new(&json!({})).unwrap();
+        let response = store.request(&request, &owner, &Cancellation::default());
+        let reference = NativeStore::new(&json!({"max_read_bytes_per_step":4096})).unwrap();
+        let reference = reference.request(&request, &owner, &Cancellation::default());
+        assert_eq!(response["status"], reference["status"], "{response:?}");
+        assert_eq!(response["reason"], reference["reason"], "{response:?}");
+        assert_eq!(response["data"], reference["data"], "{response:?}");
+        response
+    }
+
+    #[test]
+    fn tail_default_steps_read_only_the_newest_event_window() {
+        let suffix = (0..256)
+            .map(|index| format!("{}\n", user_text(&index.to_string(), &"x".repeat(1400))))
+            .collect::<String>();
+        assert!((256 * 1024..448 * 1024).contains(&suffix.len()));
+        let prefix = format!("{}\n", " ".repeat(8 * 1024 * 1024));
+        let source = Source::new(&format!("{prefix}{suffix}"));
+        let response = tail_with_small_step_reference(&source, 256, 8 * 1024 * 1024);
+        assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+        assert_eq!(
+            tail_uuids(&response),
+            (0..256).map(|index| index.to_string()).collect::<Vec<_>>()
+        );
+        assert_eq!(
+            response["data"]["source_bytes"].as_u64(),
+            Some((prefix.len() + suffix.len()) as u64)
+        );
+        assert_eq!(
+            response["data"]["window_start_byte"].as_u64(),
+            Some(prefix.len() as u64)
+        );
+        let read = response["usage"]["source_bytes_read"].as_u64().unwrap();
+        assert!(read >= suffix.len() as u64 && read <= 512 * 1024, "{read}");
+    }
+
+    #[test]
+    fn tail_grows_reads_for_a_long_partial_line() {
+        fn count_reads(store: &Arc<NativeStore>, reads: &Arc<AtomicUsize>) {
+            let next = Arc::downgrade(store);
+            let reads = Arc::clone(reads);
+            *store.read_hook.lock().unwrap() = Some(Arc::new(move || {
+                reads.fetch_add(1, Ordering::Relaxed);
+                count_reads(&next.upgrade().unwrap(), &reads);
+            }));
+        }
+
+        let prefix = format!("{}\n", " ".repeat(8 * 1024 * 1024));
+        let suffix = format!("{}\n", user_text("large", &"x".repeat(512 * 1024)));
+        let source = Source::new(&format!("{prefix}{suffix}"));
+        let owner = context("a");
+        let request = tail_request(&source.path, 1, 8 * 1024 * 1024);
+        let store = Arc::new(NativeStore::new(&json!({})).unwrap());
+        let reads = Arc::new(AtomicUsize::new(0));
+        count_reads(&store, &reads);
+        let response = store.request(&request, &owner, &Cancellation::default());
+        assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+        assert_eq!(tail_uuids(&response), ["large"]);
+        assert_eq!(
+            response["data"]["window_start_byte"].as_u64(),
+            Some(prefix.len() as u64)
+        );
+        assert!(response["usage"]["source_bytes_read"].as_u64().unwrap() <= 1024 * 1024);
+        assert!(reads.load(Ordering::Relaxed) <= 4);
+        let bounded = NativeStore::new(&json!({"max_entry_bytes":256*1024})).unwrap();
+        let refused = bounded.request(&request, &owner, &Cancellation::default());
+        assert_eq!(
+            refused["status"].as_str(),
+            Some("entry_limit"),
+            "{refused:?}"
+        );
+    }
+
+    #[test]
+    fn tail_preserves_utf8_across_growing_read_boundaries() {
+        let mut split_scalars = 0;
+        for ending in ["", "\n"] {
+            let contents = format!(
+                "{}\n{}{ending}",
+                user("old"),
+                user_text("unicode", &"é".repeat(128 * 1024))
+            );
+            let boundary = contents.len() - 64 * 1024;
+            split_scalars += usize::from(contents.as_bytes()[boundary] & 0xc0 == 0x80);
+            let source = Source::new(&contents);
+            let response = tail_with_small_step_reference(&source, 1, 1024 * 1024);
+            assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+            assert_eq!(tail_uuids(&response), ["unicode"]);
+            assert_eq!(
+                response["data"]["window_start_byte"].as_u64(),
+                Some((user("old").len() + 1) as u64)
+            );
+        }
+        assert_eq!(split_scalars, 1);
+    }
+
+    #[test]
+    fn tail_read_budget_requires_the_oldest_line_delimiter() {
+        let prefix = format!("{}\n", user("old"));
+        let first = format!("{}\n", user_text("a", &"x".repeat(128 * 1024)));
+        let last = format!("{}\n", user_text("b", &"x".repeat(128 * 1024)));
+        let source = Source::new(&format!("{prefix}{first}{last}"));
+        let budget = first.len() + last.len();
+        let incomplete = tail_with_small_step_reference(&source, 2, budget);
+        assert_eq!(
+            incomplete["status"].as_str(),
+            Some("incomplete"),
+            "{incomplete:?}"
+        );
+        assert_eq!(
+            incomplete["reason"].as_str(),
+            Some("tail read budget exhausted")
+        );
+        assert!(incomplete["cursor"].is_null());
+        assert_eq!(tail_uuids(&incomplete), ["b"]);
+        assert_eq!(
+            incomplete["data"]["window_start_byte"].as_u64(),
+            Some((prefix.len() + first.len()) as u64)
+        );
+        let complete = tail_with_small_step_reference(&source, 2, budget + 1);
+        assert_eq!(complete["status"].as_str(), Some("ok"), "{complete:?}");
+        assert_eq!(tail_uuids(&complete), ["a", "b"]);
+        assert_eq!(
+            complete["data"]["window_start_byte"].as_u64(),
+            Some(prefix.len() as u64)
+        );
+    }
+
+    #[test]
+    fn tail_counts_metadata_events_and_skips_non_events_across_steps() {
+        let source = Source::new(&format!(
+            "{}\n{}\nnot json\n[]\nnull\n42\n{{\"type\":\"queue-operation\",\"operation\":\"enqueue\"}}\n{}\n",
+            user("a"),
+            " ".repeat(96 * 1024),
+            user_text("b", &"x".repeat(128 * 1024)),
+        ));
+        let response = tail_with_small_step_reference(&source, 3, 1024 * 1024);
+        assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+        let records = response["data"]["records_json"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|record| record.as_str().unwrap().to_owned())
+            .collect::<Vec<_>>();
+        let records = crate::snapshot_codec::decode_events(&records, 1024 * 1024).unwrap();
+        assert_eq!(records.len(), 3);
+        assert_eq!(records[0].event.meta().unwrap().uuid, "a");
+        assert!(matches!(&records[1].event, Entry::Other(other) if other.ty == "queue-operation"));
+        assert_eq!(records[2].event.meta().unwrap().uuid, "b");
+        assert_eq!(response["data"]["window_start_byte"].as_u64(), Some(0));
+    }
+
+    #[test]
+    fn tail_preserves_the_pinned_source_while_reads_grow() {
+        let prefix = format!("{}\n", user("old"));
+        let suffix = format!("{}\n", user_text("new", &"x".repeat(256 * 1024)));
+        let source = Source::new(&format!("{prefix}{suffix}"));
+        let path = source.path.clone();
+        let store = NativeStore::new(&json!({})).unwrap();
+        *store.read_hook.lock().unwrap() = Some(Arc::new(move || {
+            std::fs::OpenOptions::new()
+                .append(true)
+                .open(&path)
+                .unwrap()
+                .write_all(format!("{}\n", user("appended")).as_bytes())
+                .unwrap();
+        }));
+        let response = store.request(
+            &tail_request(&source.path, 1, 1024 * 1024),
+            &context("a"),
+            &Cancellation::default(),
+        );
+        assert_eq!(response["status"].as_str(), Some("ok"), "{response:?}");
+        assert_eq!(tail_uuids(&response), ["new"]);
+        assert_eq!(
+            response["data"]["source_bytes"].as_u64(),
+            Some((prefix.len() + suffix.len()) as u64)
+        );
+        assert_eq!(
+            response["data"]["window_start_byte"].as_u64(),
+            Some(prefix.len() as u64)
+        );
+    }
     #[test]
     fn tail_returns_the_newest_events_reading_backwards_in_bounded_steps() {
         let source = Source::new(&users(0..50));

{cc_transcript-14.45.13 → cc_transcript-14.45.15}/rust/crates/core/src/snapshot_activity.rs

@@ -41,6 +41,7 @@ pub(crate) struct CachedCall {
 #[derive(Debug, Clone)]
 pub(crate) struct CachedTurn {
     prompt: String,
+    prompt_count: usize,
     bounds: Range<usize>,
     started: Option<usize>,
     ended: Option<usize>,
@@ -252,6 +253,8 @@ impl ActivityIndex {
                 }
             }
             let turn = CachedTurn {
+                prompt_count: next.prompt_count_before(next.turn_count())
+                    + usize::from(!indexed.prompt.is_empty()),
                 prompt: indexed.prompt,
                 bounds: first_new_index + indexed.start..first_new_index + indexed.end,
                 started: indexed.started_idx.map(|i| first_new_index + i),
@@ -299,6 +302,19 @@ impl ActivityIndex {
         self.turns.get(index).map(|turn| turn.prompt.as_str())
     }
 
+    pub(crate) fn prompt_count_before(&self, turn: usize) -> usize {
+        if turn == 0 {
+            0
+        } else {
+            self.turns[turn - 1].prompt_count
+        }
+    }
+
+    pub(crate) fn prompt_turn(&self, ordinal: usize) -> usize {
+        self.turns
+            .partition_point(|turn| turn.prompt_count <= ordinal)
+    }
+
     pub fn turn_bounds(&self, index: usize) -> Option<Range<usize>> {
         self.turns.get(index).map(|turn| turn.bounds.clone())
     }
@@ -558,6 +574,7 @@ impl ActivityIndex {
         for turn in turns.iter() {
             let CachedTurn {
                 prompt,
+                prompt_count: _,
                 bounds: _,
                 started: _,
                 ended: _,