cc-transcript 14.40.1__tar.gz → 14.41.0__tar.gz

{cc_transcript-14.40.1 → cc_transcript-14.41.0}/PKG-INFO

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

{cc_transcript-14.40.1 → cc_transcript-14.41.0}/cc_transcript/snapshot_schema/request.schema.json

@@ -1143,6 +1143,40 @@
       "title": "PreparedErrorPredicate",
       "type": "object"
     },
+    "PreparedGlobPredicate": {
+      "additionalProperties": false,
+      "properties": {
+        "kind": {
+          "enum": [
+            "has_edit_to",
+            "has_read_glob"
+          ],
+          "title": "Kind",
+          "type": "string"
+        },
+        "subagents": {
+          "const": true,
+          "title": "Subagents",
+          "type": "boolean"
+        },
+        "values": {
+          "items": {
+            "maxLength": 1048576,
+            "type": "string"
+          },
+          "maxItems": 256,
+          "title": "Values",
+          "type": "array"
+        }
+      },
+      "required": [
+        "kind",
+        "values",
+        "subagents"
+      ],
+      "title": "PreparedGlobPredicate",
+      "type": "object"
+    },
     "PreparedInputs": {
       "additionalProperties": false,
       "properties": {
@@ -1170,10 +1204,8 @@
         "kind": {
           "enum": [
             "has_command",
-            "has_edit_to",
             "has_skill",
-            "has_skill_suffix",
-            "has_read_glob"
+            "has_skill_suffix"
           ],
           "title": "Kind",
           "type": "string"
@@ -1239,14 +1271,40 @@
       "title": "PreparedOverridePredicate",
       "type": "object"
     },
+    "PreparedRegexPredicate": {
+      "additionalProperties": false,
+      "properties": {
+        "kind": {
+          "const": "has_command_regex",
+          "title": "Kind",
+          "type": "string"
+        },
+        "pattern": {
+          "maxLength": 1048576,
+          "title": "Pattern",
+          "type": "string"
+        },
+        "subagents": {
+          "const": true,
+          "title": "Subagents",
+          "type": "boolean"
+        }
+      },
+      "required": [
+        "kind",
+        "pattern",
+        "subagents"
+      ],
+      "title": "PreparedRegexPredicate",
+      "type": "object"
+    },
     "PreparedToolPredicate": {
       "additionalProperties": false,
       "properties": {
         "kind": {
           "enum": [
             "has_tool",
-            "has_read",
-            "has_command_regex"
+            "has_read"
           ],
           "title": "Kind",
           "type": "string"
@@ -1404,6 +1462,49 @@
         "limits": {
           "$ref": "#/$defs/Limits"
         },
+        "observers": {
+          "anyOf": [
+            {
+              "items": {
+                "discriminator": {
+                  "mapping": {
+                    "has_command": "#/$defs/PreparedListPredicate",
+                    "has_edit": "#/$defs/PreparedErrorPredicate",
+                    "has_error": "#/$defs/PreparedErrorPredicate",
+                    "has_override": "#/$defs/PreparedOverridePredicate",
+                    "has_read": "#/$defs/PreparedToolPredicate",
+                    "has_skill": "#/$defs/PreparedListPredicate",
+                    "has_skill_suffix": "#/$defs/PreparedListPredicate",
+                    "has_tool": "#/$defs/PreparedToolPredicate"
+                  },
+                  "propertyName": "kind"
+                },
+                "oneOf": [
+                  {
+                    "$ref": "#/$defs/PreparedToolPredicate"
+                  },
+                  {
+                    "$ref": "#/$defs/PreparedListPredicate"
+                  },
+                  {
+                    "$ref": "#/$defs/PreparedOverridePredicate"
+                  },
+                  {
+                    "$ref": "#/$defs/PreparedErrorPredicate"
+                  }
+                ]
+              },
+              "maxItems": 32,
+              "minItems": 1,
+              "type": "array"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Observers"
+        },
         "operation": {
           "const": "query_graph",
           "title": "Operation",
@@ -1414,13 +1515,13 @@
             "mapping": {
               "deep_predicate_inputs": "#/$defs/PreparedInputs",
               "has_command": "#/$defs/PreparedListPredicate",
-              "has_command_regex": "#/$defs/PreparedToolPredicate",
+              "has_command_regex": "#/$defs/PreparedRegexPredicate",
               "has_edit": "#/$defs/PreparedErrorPredicate",
-              "has_edit_to": "#/$defs/PreparedListPredicate",
+              "has_edit_to": "#/$defs/PreparedGlobPredicate",
               "has_error": "#/$defs/PreparedErrorPredicate",
               "has_override": "#/$defs/PreparedOverridePredicate",
               "has_read": "#/$defs/PreparedToolPredicate",
-              "has_read_glob": "#/$defs/PreparedListPredicate",
+              "has_read_glob": "#/$defs/PreparedGlobPredicate",
               "has_skill": "#/$defs/PreparedListPredicate",
               "has_skill_suffix": "#/$defs/PreparedListPredicate",
               "has_tool": "#/$defs/PreparedToolPredicate"
@@ -1434,9 +1535,15 @@
             {
               "$ref": "#/$defs/PreparedToolPredicate"
             },
+            {
+              "$ref": "#/$defs/PreparedRegexPredicate"
+            },
             {
               "$ref": "#/$defs/PreparedListPredicate"
             },
+            {
+              "$ref": "#/$defs/PreparedGlobPredicate"
+            },
             {
               "$ref": "#/$defs/PreparedOverridePredicate"
             },

{cc_transcript-14.40.1 → cc_transcript-14.41.0}/cc_transcript/snapshot_schema/response.schema.json

@@ -89,6 +89,7 @@
               "hydrated": "#/$defs/Hydrated",
               "loading": "#/$defs/Loading",
               "located": "#/$defs/Located",
+              "observed_scalar": "#/$defs/ObservedScalarResult",
               "prepared_graph": "#/$defs/PreparedGraphResult",
               "records": "#/$defs/RecordsResult",
               "released": "#/$defs/Released",
@@ -143,6 +144,9 @@
             {
               "$ref": "#/$defs/ScalarResult"
             },
+            {
+              "$ref": "#/$defs/ObservedScalarResult"
+            },
             {
               "$ref": "#/$defs/StringsResult"
             },
@@ -732,6 +736,7 @@
                   "hydrated": "#/$defs/Hydrated",
                   "loading": "#/$defs/Loading",
                   "located": "#/$defs/Located",
+                  "observed_scalar": "#/$defs/ObservedScalarResult",
                   "prepared_graph": "#/$defs/PreparedGraphResult",
                   "records": "#/$defs/RecordsResult",
                   "released": "#/$defs/Released",
@@ -786,6 +791,9 @@
                 {
                   "$ref": "#/$defs/ScalarResult"
                 },
+                {
+                  "$ref": "#/$defs/ObservedScalarResult"
+                },
                 {
                   "$ref": "#/$defs/StringsResult"
                 },
@@ -945,6 +953,43 @@
       "title": "Location",
       "type": "object"
     },
+    "ObservedScalarResult": {
+      "additionalProperties": false,
+      "properties": {
+        "kind": {
+          "const": "observed_scalar",
+          "title": "Kind",
+          "type": "string"
+        },
+        "observers": {
+          "items": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "maxItems": 32,
+          "minItems": 1,
+          "title": "Observers",
+          "type": "array"
+        },
+        "value": {
+          "title": "Value",
+          "type": "boolean"
+        }
+      },
+      "required": [
+        "kind",
+        "value",
+        "observers"
+      ],
+      "title": "ObservedScalarResult",
+      "type": "object"
+    },
     "PreparedGraphResult": {
       "additionalProperties": false,
       "properties": {

{cc_transcript-14.40.1 → cc_transcript-14.41.0}/pyproject.toml

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

@@ -1018,6 +1018,7 @@ struct PreparedQueryCursor {
     query: Value,
     pending: Option<PendingPreparedSource>,
     input_records: Option<VecDeque<String>>,
+    observers: Observers,
     next: usize,
     page_output_bytes: usize,
     remaining: WorkLimits,
@@ -1684,6 +1685,7 @@ impl Charge<String> for PreparedQueryCursor {
                 records.capacity() * size_of::<String>()
                     + records.iter().map(String::capacity).sum::<usize>()
             })
+            + self.observers.charge()
     }
 }
 
@@ -5062,6 +5064,13 @@ impl NativeStore {
             query,
             pending,
             input_records,
+            observers:
+                Observers {
+                    declared: _,
+                    allowance: _,
+                    witnessed: _,
+                    pending: observing,
+                },
             next: _,
             page_output_bytes: _,
             remaining: _,
@@ -5084,6 +5093,11 @@ impl NativeStore {
                 records.capacity() * size_of::<String>()
                     + records.iter().map(String::capacity).sum::<usize>()
             })
+            + observing.capacity() * size_of::<(usize, Value)>()
+            + observing
+                .iter()
+                .map(|(_, query)| value_bytes(query))
+                .sum::<usize>()
     }
 
     #[cfg(test)]

{cc_transcript-14.40.1 → cc_transcript-14.41.0}/rust/crates/core/src/snapshot_prepared_service.rs

@@ -2154,10 +2154,17 @@ impl NativeStore {
                 let predicted = deque_capacity_for(queue, records.len());
                 queue.extend(records);
                 assert_eq!(queue.capacity(), predicted);
-            } else if facts.query(&cursor.query)?["value"].as_bool() == Some(true) {
-                let data = json!({"kind":"scalar","value":true});
-                encoded_size(&data, output_limit)?;
-                return Ok(QueryPage::Complete(data));
+            } else {
+                let found = facts.query(&cursor.query)?["value"].as_bool() == Some(true);
+                cursor.observers.observe(facts);
+                if found {
+                    return Ok(QueryPage::Complete(cursor.observers.reply(
+                        true,
+                        false,
+                        output_limit,
+                        self.config.output,
+                    )?));
+                }
             }
             cursor.next += 1;
             steps += 1;
@@ -2186,7 +2193,7 @@ impl NativeStore {
             let data = if inputs {
                 json!({"kind":"records","record_schema":"cc-transcript.predicate-inputs/1","records_json":records})
             } else {
-                json!({"kind":"scalar","value":false})
+                cursor.observers.reply(false, true, output_limit, self.config.output)?
             };
             encoded_size(&data, output_limit)?;
             return Ok(QueryPage::Complete(data));
@@ -2408,12 +2415,24 @@ impl NativeStore {
         } else {
             None
         };
+        let observers = if kind == "deep_predicate_inputs" {
+            Observers::default()
+        } else {
+            self.admit_observers(
+                request,
+                &root_facts,
+                bounds.deadline_unix_ms,
+                context,
+                &mut reservation,
+            )
+        };
         let cursor = PreparedQueryCursor {
             claimant: claimant.to_owned(),
             graph_id: token.to_owned(),
             query: query.clone(),
             pending: None,
             input_records,
+            observers,
             next: 0,
             page_output_bytes: bounds.max_output_bytes.min(MAX_DATA_BYTES),
             remaining: bounds,
@@ -2429,6 +2448,84 @@ impl NativeStore {
         )
     }
 
+    fn admit_observers(
+        &self,
+        request: &Value,
+        root_facts: &crate::snapshot_prepared::PreparedFacts,
+        deadline_unix_ms: u64,
+        context: &Value,
+        reservation: &mut ProjectionReservation<'_>,
+    ) -> Observers {
+        let Some(queries) = request
+            .get("observers")
+            .and_then(Value::as_array)
+            .filter(|queries| (1..=OBSERVER_LIMIT).contains(&queries.len()))
+        else {
+            return Observers::default();
+        };
+        let started = std::time::Instant::now();
+        let mut observers = Observers {
+            declared: queries.len(),
+            allowance: std::time::Duration::from_millis(
+                deadline_unix_ms.saturating_sub(now_ms()) / 4,
+            ),
+            witnessed: 0,
+            pending: Vec::new(),
+        };
+        let mut pending = 0u64;
+        for (index, query) in queries.iter().enumerate() {
+            if !Observers::observable(query) {
+                continue;
+            }
+            match Observers::timely(root_facts, query, started, observers.allowance) {
+                Some(Some(true)) => observers.witnessed |= 1 << index,
+                Some(Some(false)) => pending |= 1 << index,
+                Some(None) => {}
+                None => break,
+            }
+        }
+        observers.allowance = observers.allowance.saturating_sub(started.elapsed());
+        if observers.allowance.is_zero() {
+            pending = 0;
+        }
+        let selected = || {
+            queries
+                .iter()
+                .enumerate()
+                .filter(move |(index, _)| pending & (1 << *index) != 0)
+        };
+        let count = pending.count_ones() as usize;
+        let bytes = count * size_of::<(usize, Value)>()
+            + selected().map(|(_, query)| value_bytes(query)).sum::<usize>();
+        if count > 0 && self.reserve_observers(reservation, context, bytes) {
+            observers.pending = Vec::with_capacity(count);
+            observers
+                .pending
+                .extend(selected().map(|(index, query)| (index, query.clone())));
+        }
+        observers
+    }
+
+    fn reserve_observers(
+        &self,
+        reservation: &mut ProjectionReservation<'_>,
+        context: &Value,
+        bytes: usize,
+    ) -> bool {
+        let mut state = self.lock_state();
+        let fits = self.memory_cap(context).is_ok_and(|cap| {
+            number(&Self::gauges(&mut state), "retained_total_accounted_bytes")
+                .is_ok_and(|retained| retained.saturating_add(bytes) <= cap)
+        });
+        if fits {
+            state.ledger.shared.work().admitted(bytes);
+            state.transient_bytes += bytes;
+            reservation.bytes += bytes;
+            state.ledger.shared.work().reserved(bytes);
+        }
+        fits
+    }
+
     fn publish_root_slice(
         &self,
         token: &str,
@@ -2468,3 +2565,130 @@ impl NativeStore {
         Ok(facts)
     }
 }
+
+const OBSERVER_LIMIT: usize = 32;
+
+#[cfg(test)]
+thread_local! {
+    static OBSERVATIONS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+#[derive(Default)]
+struct Observers {
+    declared: usize,
+    allowance: std::time::Duration,
+    witnessed: u64,
+    pending: Vec<(usize, Value)>,
+}
+
+impl Observers {
+    fn observable(query: &Value) -> bool {
+        matches!(
+            query.get("kind").and_then(Value::as_str),
+            Some(
+                "has_tool"
+                    | "has_read"
+                    | "has_command"
+                    | "has_skill"
+                    | "has_skill_suffix"
+                    | "has_override"
+                    | "has_error"
+                    | "has_edit"
+            )
+        )
+    }
+
+    fn observed(facts: &crate::snapshot_prepared::PreparedFacts, query: &Value) -> Option<bool> {
+        #[cfg(test)]
+        OBSERVATIONS.with(|count| count.set(count.get() + 1));
+        facts
+            .query(query)
+            .ok()
+            .map(|answer| answer["value"].as_bool() == Some(true))
+    }
+
+    fn timely(
+        facts: &crate::snapshot_prepared::PreparedFacts,
+        query: &Value,
+        started: std::time::Instant,
+        allowance: std::time::Duration,
+    ) -> Option<Option<bool>> {
+        (started.elapsed() < allowance)
+            .then(|| Self::observed(facts, query))
+            .filter(|_| started.elapsed() < allowance)
+    }
+
+    fn charge(&self) -> usize {
+        self.pending.capacity() * size_of::<(usize, Value)>()
+            + self
+                .pending
+                .iter()
+                .map(|(_, query)| value_bytes(query))
+                .sum::<usize>()
+    }
+
+    fn observe(&mut self, facts: &crate::snapshot_prepared::PreparedFacts) {
+        let Self {
+            allowance,
+            witnessed,
+            pending,
+            ..
+        } = self;
+        if pending.is_empty() {
+            return;
+        }
+        let started = std::time::Instant::now();
+        let mut expired = false;
+        pending.retain(|(index, query)| {
+            let outcome = (!expired)
+                .then(|| Self::timely(facts, query, started, *allowance))
+                .flatten();
+            expired = outcome.is_none();
+            match outcome {
+                Some(Some(true)) => {
+                    *witnessed |= 1 << *index;
+                    false
+                }
+                Some(Some(false)) => true,
+                Some(None) | None => false,
+            }
+        });
+        *allowance = allowance.saturating_sub(started.elapsed());
+        if allowance.is_zero() {
+            pending.clear();
+        }
+    }
+
+    fn reply(
+        &self,
+        value: bool,
+        exhausted: bool,
+        output_limit: usize,
+        projection_limit: usize,
+    ) -> Result<Value, SnapshotError> {
+        let plain = json!({"kind":"scalar","value":value});
+        encoded_size(&plain, output_limit)?;
+        if self.declared == 0 {
+            return Ok(plain);
+        }
+        let outcomes: Vec<Option<bool>> = (0..self.declared)
+            .map(|index| {
+                if self.witnessed & (1 << index) != 0 {
+                    Some(true)
+                } else if exhausted && self.pending.iter().any(|(pending, _)| *pending == index) {
+                    Some(false)
+                } else {
+                    None
+                }
+            })
+            .collect();
+        let observed = json!({"kind":"observed_scalar","value":value,"observers":outcomes});
+        Ok(
+            if encoded_size(&observed, output_limit.min(projection_limit)).is_ok() {
+                observed
+            } else {
+                plain
+            },
+        )
+    }
+}