cc-transcript 14.26.0__tar.gz → 14.27.0__tar.gz

{cc_transcript-14.26.0 → cc_transcript-14.27.0}/PKG-INFO

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

{cc_transcript-14.26.0 → cc_transcript-14.27.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.26.0" # informational — releases stamp the version from the git tag
+version = "14.27.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.27.0/rust/crates/cli/src/commands/grep.rs

@@ -0,0 +1,561 @@
+use std::path::{Path, PathBuf};
+
+use cc_transcript_core::render::{compact_line, display_path, event_json, transcript_header, Json};
+use cc_transcript_core::scan::{
+    scan_corpus, ScanBudget, ScanControl, ScanOutcome, ScanPlan, ScanSession,
+};
+use cc_transcript_core::scan_grep::{GrepOptions, GrepPatternSpec, GrepReducer, GrepSourceResult};
+use cc_transcript_core::snapshot::{Cancellation, NativeStore, SnapshotError, Status, WorkLimits};
+use cc_transcript_core::types::{ContentBlock, Entry};
+use regex::{Regex, RegexBuilder};
+use sonic_rs::json;
+
+use crate::output::{click_error, eline, usage_error, CliExit, Out};
+use crate::target::py_path;
+use crate::DiscoveryOpts;
+
+const USAGE: &str = "cc-transcript grep [OPTIONS] PATTERN [PATHS]...";
+const HELP_PATH: &str = "cc-transcript grep";
+const DEFAULT_MAX_MATCHES: usize = 20;
+
+#[derive(clap::Args, Default)]
+pub struct ScanOptions {
+    #[arg(long, help = "Maximum cumulative source and logical projection bytes.")]
+    pub max_read_bytes: Option<usize>,
+    #[arg(
+        long,
+        help = "Maximum cumulative preparation and event traversal work."
+    )]
+    pub max_events: Option<usize>,
+    #[arg(long, help = "Maximum emitted output bytes.")]
+    pub max_output_bytes: Option<usize>,
+    #[arg(long, help = "Maximum filesystem entries examined during discovery.")]
+    pub max_discovery_entries: Option<usize>,
+    #[arg(long, help = "Maximum sources in the discovered inventory.")]
+    pub max_sources: Option<usize>,
+    #[arg(long, help = "Deadline for the complete scan in milliseconds.")]
+    pub timeout_ms: Option<u64>,
+}
+
+impl ScanOptions {
+    fn apply(&self, mut limits: WorkLimits) -> Result<WorkLimits, CliExit> {
+        if let Some(n) = self.max_read_bytes {
+            limits.max_read_bytes = n;
+        }
+        if let Some(n) = self.max_events {
+            limits.max_events = n;
+            limits.max_items = n;
+        }
+        if let Some(n) = self.max_output_bytes {
+            limits.max_output_bytes = n;
+        }
+        if let Some(n) = self.max_discovery_entries {
+            limits.max_discovery_entries = n;
+        }
+        if let Some(n) = self.max_sources {
+            limits.max_sources = n;
+        }
+        if let Some(n) = self.timeout_ms {
+            limits.deadline_unix_ms = cc_transcript_core::snapshot::now_ms().saturating_add(n);
+        }
+        if [
+            limits.max_read_bytes,
+            limits.max_events,
+            limits.max_output_bytes,
+            limits.max_discovery_entries,
+            limits.max_sources,
+        ]
+        .contains(&0)
+            || self.timeout_ms == Some(0)
+        {
+            return Err(usage_error(
+                USAGE,
+                HELP_PATH,
+                "scan work limits must be positive",
+            ));
+        }
+        Ok(limits)
+    }
+}
+
+pub struct GrepArgs {
+    pub pattern: String,
+    pub patterns: Vec<String>,
+    pub scan_json: bool,
+    pub scan_limits: ScanOptions,
+    pub paths: Vec<PathBuf>,
+    pub discovery: DiscoveryOpts,
+    pub corpus: Option<PathBuf>,
+    pub kinds: Vec<String>,
+    pub tool: Option<String>,
+    pub errors: bool,
+    pub ignore_case: bool,
+    pub wheres: Vec<String>,
+    pub context: usize,
+    pub max_matches: Option<usize>,
+    pub width: usize,
+    pub uuids: bool,
+    pub with_result: bool,
+    pub json: bool,
+}
+
+pub fn compile_pattern(
+    pattern: &str,
+    ignore_case: bool,
+    usage: &str,
+    help_path: &str,
+) -> Result<Regex, CliExit> {
+    RegexBuilder::new(pattern)
+        .case_insensitive(ignore_case)
+        .build()
+        .map_err(|e| usage_error(usage, help_path, &format!("invalid pattern: {e}")))
+}
+
+/// An empty `--where` searches everywhere (cli.py's default).
+pub fn where_flags(wheres: &[String]) -> (bool, bool, bool) {
+    if wheres.is_empty() {
+        return (true, true, true);
+    }
+    (
+        wheres.iter().any(|w| w == "text"),
+        wheres.iter().any(|w| w == "thinking"),
+        wheres.iter().any(|w| w == "tools"),
+    )
+}
+
+fn cap(args: &GrepArgs) -> Option<usize> {
+    args.max_matches.map_or_else(
+        || args.corpus.is_none().then_some(DEFAULT_MAX_MATCHES),
+        |n| (n > 0).then_some(n),
+    )
+}
+
+fn snapshot_error(error: SnapshotError) -> CliExit {
+    click_error(&format!("{}: {}", error.status.as_str(), error.reason))
+}
+
+fn output_error() -> SnapshotError {
+    SnapshotError::new(Status::OutputLimit, "stdout write failed")
+}
+
+struct Emitter {
+    out: Out,
+    scan_json: bool,
+    first: bool,
+    exit: Option<i32>,
+}
+
+impl Emitter {
+    fn new(
+        scan_json: bool,
+        budget: &mut ScanBudget,
+        _cancel: &Cancellation,
+    ) -> Result<Self, CliExit> {
+        let mut out = Out::new();
+        if scan_json {
+            if budget.remaining().max_output_bytes < 4096 {
+                return Err(click_error(
+                    "structured scan output requires 4096 status bytes",
+                ));
+            }
+            budget.progress.output_bytes += 4096;
+            out.line("{\"schema\":\"cc-transcript.scan/1\",\"matches\":[")?;
+        }
+        Ok(Self {
+            out,
+            scan_json,
+            first: true,
+            exit: None,
+        })
+    }
+
+    fn emit(
+        &mut self,
+        line: String,
+        budget: &mut ScanBudget,
+        cancel: &Cancellation,
+    ) -> Result<(), SnapshotError> {
+        budget.charge_output(line.len().saturating_add(2), cancel)?;
+        let result = if self.scan_json && !self.first {
+            self.out.line(",").and_then(|()| self.out.line(&line))
+        } else {
+            self.out.line(&line)
+        };
+        self.first = false;
+        result.map_err(|error| {
+            self.exit = Some(error.0);
+            output_error()
+        })
+    }
+
+    fn finish(mut self, outcome: &ScanOutcome, counts: &[usize]) -> Result<(), CliExit> {
+        if let Some(code) = self.exit {
+            return Err(CliExit(code));
+        }
+        if self.scan_json {
+            let status = cc_transcript_core::snapshot_codec::encode(
+                &json!({"outcome":outcome,"counts":counts}),
+                4032,
+            )
+            .map_err(snapshot_error)?;
+            if status.len().saturating_add(64) > 4096 {
+                return Err(click_error("scan status exceeds reserved output"));
+            }
+            self.out.line(&format!("],{}", &status[1..]))?;
+        }
+        self.out.finish()?;
+        if let Some(reason) = &outcome.reason {
+            if reason == "result_limit" {
+                eline(&format!("warning: stopped at --max-matches {}; more matches may exist — raise it, or pass --max-matches 0 for no cap",counts.first().copied().unwrap_or(0)));
+            } else {
+                eline(&format!("warning: scan incomplete: {reason}"));
+                return Err(CliExit(3));
+            }
+        }
+        if counts.iter().all(|count| *count == 0) {
+            return Err(CliExit(1));
+        }
+        Ok(())
+    }
+}
+
+fn result_fields(event: &Entry, result: &GrepSourceResult<'_, '_>) -> Vec<(String, Json)> {
+    if !matches!(event, Entry::Assistant(_)) {
+        return Vec::new();
+    }
+    event
+        .blocks()
+        .iter()
+        .filter_map(|block| {
+            let ContentBlock::ToolUse(tool) = block else {
+                return None;
+            };
+            let value = result.results.get(tool.id.as_str())?;
+            Some((
+                tool.id.clone(),
+                Json::Obj(vec![
+                    ("is_error".into(), Json::Bool(value.is_error)),
+                    ("denied".into(), Json::Bool(value.denied)),
+                    (
+                        "duration_ms".into(),
+                        value.duration_ms.map_or(Json::Null, Json::Int),
+                    ),
+                ]),
+            ))
+        })
+        .collect()
+}
+
+fn result_suffix(event: &Entry, result: &GrepSourceResult<'_, '_>) -> String {
+    if !matches!(event, Entry::Assistant(_)) {
+        return String::new();
+    }
+    let markers: Vec<_> = event
+        .blocks()
+        .iter()
+        .filter_map(|block| {
+            let ContentBlock::ToolUse(tool) = block else {
+                return None;
+            };
+            let value = result.results.get(tool.id.as_str())?;
+            let status = if value.denied {
+                "[denied]"
+            } else if value.is_error {
+                "[err]"
+            } else {
+                ""
+            };
+            let duration = value
+                .duration_ms
+                .map(|ms| format!("({ms}ms)"))
+                .unwrap_or_default();
+            let marker = [status.to_owned(), duration]
+                .into_iter()
+                .filter(|part| !part.is_empty())
+                .collect::<Vec<_>>()
+                .join(" ");
+            (!marker.is_empty()).then_some(marker)
+        })
+        .collect();
+    if markers.is_empty() {
+        String::new()
+    } else {
+        format!(" {}", markers.join(" "))
+    }
+}
+
+pub fn run(args: GrepArgs) -> Result<(), CliExit> {
+    let store = NativeStore::new(&json!({})).map_err(snapshot_error)?;
+    let limits = args.scan_limits.apply(store.scan_limits())?;
+    let cancel = Cancellation::default();
+    *crate::SCAN_CANCELLATION.lock().expect("scan cancellation") = Some(cancel.clone());
+    let _interrupt = ScanInterrupt;
+    if let Some(path) = &args.corpus {
+        return run_over_corpus(&store, &args, path, limits, cancel);
+    }
+    let mut session = ScanSession::new(&store, limits, cancel.clone());
+    let mut reducer = match prepare_reducer(&args, &mut session.budget, &cancel) {
+        Ok(reducer) => reducer,
+        Err(error) if error.status == Status::InvalidRequest => {
+            return Err(usage_error(USAGE, HELP_PATH, &error.reason))
+        }
+        Err(error) => {
+            let emitter = Emitter::new(
+                args.scan_json,
+                &mut session.budget,
+                &Cancellation::default(),
+            )?;
+            return emitter.finish(
+                &failed_outcome(error, &session.budget),
+                &vec![0; args.patterns.len() + 1],
+            );
+        }
+    };
+    let plan = ScanPlan {
+        paths: args
+            .paths
+            .iter()
+            .map(|path| py_path(&path.to_string_lossy()))
+            .collect(),
+        root: args.discovery.validated_root(USAGE, HELP_PATH)?,
+        project: args.discovery.project.clone(),
+        contains: args.discovery.contains.clone(),
+        source_limit: args.discovery.effective_limit(),
+    };
+    let mut emitter = Emitter::new(args.scan_json, &mut session.budget, &cancel)?;
+    let mut files = 0usize;
+    let mut outcome = session.run(&plan, |path, snapshot, budget, cancel| {
+        let result = reducer.scan_source(snapshot, budget, cancel)?;
+        if result.hits.is_empty() {
+            return Ok(if result.quota_reached {
+                ScanControl::Stop {
+                    source_complete: result.source_complete,
+                }
+            } else {
+                ScanControl::Continue
+            });
+        }
+        files += 1;
+        if !args.json && !args.scan_json {
+            emitter.emit(transcript_header(&path.to_string_lossy()), budget, cancel)?;
+        }
+        for (window_index, window) in result.windows.iter().enumerate() {
+            if !args.json && !args.scan_json && args.context > 0 && window_index > 0 {
+                emitter.emit("--".to_owned(), budget, cancel)?;
+            }
+            for index in window.clone() {
+                let _render_staging = result.preflight_render(snapshot, index, budget, cancel)?;
+                let event = snapshot.entry(index);
+                let hit = result.hits.iter().find(|hit| hit.event_index == index);
+                let line = if args.json || args.scan_json {
+                    let Json::Obj(mut fields) = event_json(index, event) else {
+                        unreachable!("event_json object")
+                    };
+                    fields.insert(
+                        0,
+                        (
+                            "path".into(),
+                            Json::Str(path.to_string_lossy().into_owned()),
+                        ),
+                    );
+                    if hit.is_none() {
+                        fields.push(("context".into(), Json::Bool(true)));
+                    }
+                    if args.with_result {
+                        let results = result_fields(event, &result);
+                        if !results.is_empty() {
+                            fields.push(("results".into(), Json::Obj(results)));
+                        }
+                    }
+                    if args.scan_json {
+                        fields.push(("generation".into(), Json::Str(snapshot.id.clone())));
+                        fields.push((
+                            "pattern_ids".into(),
+                            Json::Arr(
+                                hit.map(|hit| {
+                                    hit.pattern_ids
+                                        .iter()
+                                        .map(|id| Json::Int(*id as i64))
+                                        .collect()
+                                })
+                                .unwrap_or_default(),
+                            ),
+                        ));
+                    }
+                    Json::Obj(fields).dumps()
+                } else {
+                    let mut line =
+                        compact_line(index, event, &result.names, args.width, false, args.uuids);
+                    if args.with_result {
+                        line.push_str(&result_suffix(event, &result));
+                    }
+                    line
+                };
+                emitter.emit(line, budget, cancel)?;
+            }
+        }
+        Ok(if result.quota_reached {
+            ScanControl::Stop {
+                source_complete: result.source_complete,
+            }
+        } else {
+            ScanControl::Continue
+        })
+    });
+    if outcome.complete && !reducer.complete() {
+        outcome.complete = false;
+        outcome.reason = Some("result_limit".to_owned());
+    }
+    let counts = reducer.counts();
+    if !args.json && !args.scan_json {
+        let note = if outcome.selected_sources < outcome.available_sources {
+            format!(
+                " · searched {} of {} transcripts — use --all",
+                outcome.selected_sources, outcome.available_sources
+            )
+        } else {
+            String::new()
+        };
+        if let Err(error) = emitter.emit(
+            format!(
+                "{files} files, {} matches{note}",
+                counts.iter().sum::<usize>()
+            ),
+            &mut session.budget,
+            &cancel,
+        ) {
+            outcome.complete = false;
+            outcome.reason = Some(error.reason);
+        }
+        outcome.progress = session.budget.progress.clone();
+    }
+    emitter.finish(&outcome, counts)
+}
+
+fn run_over_corpus(
+    store: &NativeStore,
+    args: &GrepArgs,
+    path: &Path,
+    limits: WorkLimits,
+    cancel: Cancellation,
+) -> Result<(), CliExit> {
+    let mut budget = ScanBudget::new(store, limits);
+    let mut reducer = match prepare_reducer(args, &mut budget, &cancel) {
+        Ok(reducer) => reducer,
+        Err(error) if error.status == Status::InvalidRequest => {
+            return Err(usage_error(USAGE, HELP_PATH, &error.reason))
+        }
+        Err(error) => {
+            let emitter = Emitter::new(args.scan_json, &mut budget, &Cancellation::default())?;
+            return emitter.finish(
+                &failed_outcome(error, &budget),
+                &vec![0; args.patterns.len() + 1],
+            );
+        }
+    };
+    let mut emitter = Emitter::new(args.scan_json, &mut budget, &cancel)?;
+    let mut outcome = scan_corpus(
+        path,
+        &mut budget,
+        &cancel,
+        |line_number, line, budget, cancel| {
+            let (ids, _match_staging) = reducer.scan_text(line, budget, cancel)?;
+            if !ids.is_empty() {
+                let render_bound = if args.scan_json {
+                    line.len()
+                        .saturating_add(path.as_os_str().len())
+                        .saturating_mul(6)
+                        .saturating_add(1024)
+                } else {
+                    line.len().saturating_add(2)
+                };
+                if render_bound > budget.remaining().max_output_bytes {
+                    return Err(SnapshotError::new(
+                        Status::OutputLimit,
+                        "corpus match exceeds remaining output budget",
+                    ));
+                }
+                let _render_staging = budget.reserve_staging(render_bound, cancel)?;
+                budget.charge_projection(
+                    line.len().saturating_add(path.as_os_str().len()),
+                    0,
+                    cancel,
+                )?;
+                let rendered = if args.scan_json {
+                    sonic_rs::to_string(&json!({"path":path.to_string_lossy().as_ref(),"line":line_number,"text":line,"pattern_ids":ids})).map_err(|e|SnapshotError::new(Status::OutputLimit,e.to_string()))?
+                } else {
+                    line.to_owned()
+                };
+                emitter.emit(rendered, budget, cancel)?;
+            }
+            Ok(reducer.satisfied())
+        },
+    );
+    if outcome.complete && !reducer.complete() {
+        outcome.complete = false;
+        outcome.reason = Some("result_limit".to_owned());
+    }
+    let counts = reducer.counts();
+    if !args.scan_json {
+        if let Err(error) = emitter.emit(
+            format!(
+                "{} matches in {}",
+                counts.iter().sum::<usize>(),
+                display_path(&path.to_string_lossy())
+            ),
+            &mut budget,
+            &cancel,
+        ) {
+            outcome.complete = false;
+            outcome.reason = Some(error.reason);
+        }
+        outcome.progress = budget.progress.clone();
+    }
+    emitter.finish(&outcome, counts)
+}
+
+fn failed_outcome(error: SnapshotError, budget: &ScanBudget) -> ScanOutcome {
+    ScanOutcome {
+        complete: false,
+        reason: Some(format!("{}: {}", error.status.as_str(), error.reason)),
+        selected_sources: 0,
+        available_sources: 0,
+        progress: budget.progress.clone(),
+    }
+}
+
+struct ScanInterrupt;
+impl Drop for ScanInterrupt {
+    fn drop(&mut self) {
+        *crate::SCAN_CANCELLATION.lock().expect("scan cancellation") = None;
+    }
+}
+
+fn prepare_reducer<'store>(
+    args: &GrepArgs,
+    budget: &mut ScanBudget<'store>,
+    cancel: &Cancellation,
+) -> Result<GrepReducer<'store>, SnapshotError> {
+    let (where_text, where_thinking, where_tools) = where_flags(&args.wheres);
+    let patterns = std::iter::once(&args.pattern)
+        .chain(args.patterns.iter())
+        .enumerate()
+        .map(|(id, pattern)| GrepPatternSpec {
+            id,
+            pattern: pattern.clone(),
+            max_matches: cap(&args),
+        })
+        .collect();
+    let options = GrepOptions {
+        kinds: args.kinds.clone(),
+        tool: args.tool.clone(),
+        errors: args.errors,
+        ignore_case: args.ignore_case,
+        where_text,
+        where_thinking,
+        where_tools,
+        context: args.context,
+        with_result: args.with_result,
+    };
+    GrepReducer::new(patterns, options, budget, cancel)
+}

{cc_transcript-14.26.0 → cc_transcript-14.27.0}/rust/crates/cli/src/lib.rs

@@ -18,6 +18,9 @@ use output::CliExit;
 /// (cli.py watch_ catches KeyboardInterrupt); outside watch it means exit 130.
 pub static WATCH_ACTIVE: AtomicBool = AtomicBool::new(false);
 pub static WATCH_INTERRUPTED: AtomicBool = AtomicBool::new(false);
+pub(crate) static SCAN_CANCELLATION: std::sync::Mutex<
+    Option<cc_transcript_core::snapshot::Cancellation>,
+> = std::sync::Mutex::new(None);
 
 /// The real SIGINT handler spike C mandates: with the GIL detached, Python-side
 /// KeyboardInterrupt delivery never fires, so the Rust side owns the signal.
@@ -25,6 +28,12 @@ pub fn install_sigint_handler() {
     let _ = ctrlc::set_handler(|| {
         if WATCH_ACTIVE.load(Ordering::SeqCst) {
             WATCH_INTERRUPTED.store(true, Ordering::SeqCst);
+        } else if let Some(cancel) = SCAN_CANCELLATION
+            .lock()
+            .expect("scan cancellation")
+            .as_ref()
+        {
+            cancel.cancel();
         } else {
             std::process::exit(130);
         }
@@ -192,8 +201,17 @@ pub enum Cmd {
         json: bool,
     },
     /// Search transcript events for a regex pattern.
+    #[command(
+        long_about = "Search transcripts with finite read, event, source, output, and time limits. --all removes only the selected-file limit. Use repeated --pattern with --scan-json to share one traversal; incomplete scans cannot establish absence."
+    )]
     Grep {
         pattern: String,
+        #[arg(long = "pattern", requires = "scan_json")]
+        patterns: Vec<String>,
+        #[arg(long, conflicts_with = "json")]
+        scan_json: bool,
+        #[command(flatten)]
+        scan_limits: commands::grep::ScanOptions,
         paths: Vec<PathBuf>,
         #[command(flatten)]
         discovery: DiscoveryOpts,
@@ -545,6 +563,9 @@ fn dispatch(cmd: Cmd) -> Result<(), CliExit> {
         }),
         Cmd::Grep {
             pattern,
+            patterns,
+            scan_json,
+            scan_limits,
             paths,
             discovery,
             corpus,
@@ -561,6 +582,9 @@ fn dispatch(cmd: Cmd) -> Result<(), CliExit> {
             json,
         } => commands::grep::run(commands::grep::GrepArgs {
             pattern,
+            patterns,
+            scan_json,
+            scan_limits,
             paths,
             discovery,
             corpus,

{cc_transcript-14.26.0 → cc_transcript-14.27.0}/rust/crates/core/src/activity.rs

@@ -313,16 +313,42 @@ pub struct ToolUse<'a> {
     pub edits: Vec<(String, Vec<Hunk>)>,
 }
 
+pub(crate) fn tool_duration_ms(
+    start: DateTime<FixedOffset>,
+    end: Option<DateTime<FixedOffset>>,
+) -> Option<i64> {
+    end.map(|end| {
+        let micros = (end - start)
+            .num_microseconds()
+            .expect("duration fits i64 microseconds");
+        ((micros as f64 / 1_000_000.0) * 1000.0).round_ties_even() as i64
+    })
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ToolResultMetadata {
+    pub is_error: bool,
+    pub denied: bool,
+    pub duration_ms: Option<i64>,
+}
+
+pub fn tool_result_metadata(
+    start: DateTime<FixedOffset>,
+    result: Option<&ToolResultBlock>,
+    end: Option<DateTime<FixedOffset>>,
+) -> ToolResultMetadata {
+    ToolResultMetadata {
+        is_error: result.is_some_and(|result| result.is_error),
+        denied: result.is_some_and(|result| {
+            result.denial_kind.as_deref() == Some(crate::protocol::DENIAL_KIND_USER_REJECTED)
+        }),
+        duration_ms: tool_duration_ms(start, end),
+    }
+}
+
 impl ToolUse<'_> {
-    /// Milliseconds from the call to its result, or None without a result
-    /// timestamp (activity.py ToolUse.duration_ms).
     pub fn duration_ms(&self) -> Option<i64> {
-        self.result_ts.map(|rt| {
-            let micros = (rt - self.ts)
-                .num_microseconds()
-                .expect("duration fits i64 microseconds");
-            ((micros as f64 / 1_000_000.0) * 1000.0).round_ties_even() as i64
-        })
+        tool_duration_ms(self.ts, self.result_ts)
     }
 }