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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.45.14" # 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.14 → cc_transcript-14.45.15}/rust/crates/core/src/snapshot.rs

@@ -11660,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,

{cc_transcript-14.45.14 → 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: _,