cc-transcript 14.9.0__tar.gz → 14.10.0__tar.gz

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.9.0
+Version: 14.10.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -120,6 +120,14 @@ print(len(transcript.events), "events after the noise drop")
 
 `discover()` lists every transcript on disk newest first, `stream` fans a whole corpus across the parse pool, and `resolve` finds one session by UUID. `parse` also reads OpenAI Codex CLI rollouts — hand it a path from `~/.codex/sessions` and the same typed events come back. The [getting-started guide](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) builds this out to a composed filter and a sentiment score.
 
+## JSON output schema
+
+`show --json` and `grep --json` emit JSONL, with one object per event. Each event
+uses the envelope `{i, kind, meta, model, text, blocks, stop_reason, usage}`;
+fields that do not apply to its kind are omitted. Every object in `blocks` has
+a `type` discriminator such as `text`, `thinking`, `tool_use`, `tool_result`,
+or `fallback`.
+
 ## More in the docs
 
 - [The Python library](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) turns a transcript into typed lazy views, a composed filter, and a score in a dozen lines.

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/README.md

@@ -84,6 +84,14 @@ print(len(transcript.events), "events after the noise drop")
 
 `discover()` lists every transcript on disk newest first, `stream` fans a whole corpus across the parse pool, and `resolve` finds one session by UUID. `parse` also reads OpenAI Codex CLI rollouts — hand it a path from `~/.codex/sessions` and the same typed events come back. The [getting-started guide](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) builds this out to a composed filter and a sentiment score.
 
+## JSON output schema
+
+`show --json` and `grep --json` emit JSONL, with one object per event. Each event
+uses the envelope `{i, kind, meta, model, text, blocks, stop_reason, usage}`;
+fields that do not apply to its kind are omitted. Every object in `blocks` has
+a `type` discriminator such as `text`, `thinking`, `tool_use`, `tool_result`,
+or `fallback`.
+
 ## More in the docs
 
 - [The Python library](https://yasyf.github.io/cc-transcript/docs/getting-started/index.html) turns a transcript into typed lazy views, a composed filter, and a score in a dozen lines.

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/cc_transcript/__init__.py

@@ -109,6 +109,7 @@ EXPORTS: dict[str, str] = {
             "CcVersion",
             "CompactBoundary",
             "ContentBlock",
+            "DeferredToolsDelta",
             "EntryMeta",
             "EventList",
             "FallbackBlock",

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/cc_transcript/__init__.pyi

@@ -147,6 +147,7 @@ from cc_transcript.models import (
     CcVersion as CcVersion,
     CompactBoundary as CompactBoundary,
     ContentBlock as ContentBlock,
+    DeferredToolsDelta as DeferredToolsDelta,
     EntryMeta as EntryMeta,
     EventList as EventList,
     FallbackBlock as FallbackBlock,
@@ -339,6 +340,7 @@ __all__ = [
     "DecisionLog",
     "DeepSession",
     "DeepView",
+    "DeferredToolsDelta",
     "DiskTruth",
     "Edit",
     "EditCall",

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/cc_transcript/_native.pyi

@@ -28,6 +28,7 @@ __all__ = [
     "CommandLine",
     "CommandLineQuery",
     "CompactBoundary",
+    "DeferredToolsDelta",
     "EditCall",
     "EditResult",
     "EditSpan",
@@ -588,6 +589,27 @@ class CompactBoundary:
     @property
     def precomputed(self) -> typing.Optional[builtins.bool]: ...
 
+@typing.final
+class DeferredToolsDelta(OtherAttachment):
+    r"""
+    Tools added to and removed from the deferred tool inventory.
+
+    Attributes:
+        added_count: Number of added tools.
+        removed_count: Number of removed tools.
+        added_names: Added tool names, in transcript order.
+        removed_names: Removed tool names, in transcript order.
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def added_count(self) -> builtins.int: ...
+    @property
+    def removed_count(self) -> builtins.int: ...
+    @property
+    def added_names(self) -> tuple[str, ...]: ...
+    @property
+    def removed_names(self) -> tuple[str, ...]: ...
+
 @typing.final
 class EditCall(ToolCallBase):
     r"""
@@ -1163,7 +1185,6 @@ class Occurrence:
         One shell-word spelling of ``text`` that survives every enclosing layer, or None.
         """
 
-@typing.final
 class OtherAttachment:
     r"""
     Any attachment whose type has no typed detail, carried verbatim.

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/cc_transcript/facts.py

@@ -33,6 +33,7 @@ class ToolFact:
         ts: The timestamp of the assistant entry that made the call, or None.
         session_id: The Claude session the call belongs to.
         path: The transcript file the call was lifted from.
+        cwd: The working directory recorded on the originating event, or None.
         tool_use_id: The tool-use block id — the join key back to the event stream.
         tool: The tool name exactly as invoked.
         command_prefixes: The permission-style prefixes of each Bash command
@@ -42,6 +43,8 @@ class ToolFact:
         mcp_tool: The MCP tool segment for an ``mcp__server__tool`` call, else None.
         mcp_access: Whether the MCP tool reads or writes, else None.
         file_path: The file the call targets, when it targets one.
+        file_paths: Every file the call touches, apply_patch multi-file included;
+            ``file_path`` mirrors the first entry.
         is_error: Whether the call's result reported a failure.
         denied: Whether the result is a user rejection of the tool use.
         denial_kind: The structured tool-denial kind (``user-rejected`` for a human
@@ -53,6 +56,7 @@ class ToolFact:
     ts: datetime | None
     session_id: SessionId
     path: Path
+    cwd: str | None
     tool_use_id: ToolUseId
     tool: str
     command_prefixes: tuple[str, ...]
@@ -61,6 +65,7 @@ class ToolFact:
     mcp_tool: str | None
     mcp_access: Literal["read", "write"] | None
     file_path: str | None
+    file_paths: tuple[str, ...]
     is_error: bool
     denied: bool
     denial_kind: str | None
@@ -73,6 +78,7 @@ def rehydrate_fact(fact: Mapping[str, Any], path: Path) -> ToolFact:
         ts=datetime.fromisoformat(fact["ts"]),
         session_id=SessionId(fact["session_id"]),
         path=path,
+        cwd=fact["cwd"],
         tool_use_id=ToolUseId(fact["tool_use_id"]),
         tool=fact["tool"],
         command_prefixes=tuple(fact["command_prefixes"]),
@@ -81,6 +87,7 @@ def rehydrate_fact(fact: Mapping[str, Any], path: Path) -> ToolFact:
         mcp_tool=fact["mcp_tool"],
         mcp_access=fact["mcp_access"],
         file_path=fact["file_path"],
+        file_paths=tuple(fact["file_paths"]),
         is_error=fact["is_error"],
         denied=fact["denied"],
         denial_kind=fact["denial_kind"],

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/cc_transcript/models.py

@@ -17,6 +17,7 @@ from cc_transcript._native import AttachmentEvent as AttachmentEvent
 from cc_transcript._native import Attribution as Attribution
 from cc_transcript._native import CacheCreation as CacheCreation
 from cc_transcript._native import CompactBoundary as CompactBoundary
+from cc_transcript._native import DeferredToolsDelta as DeferredToolsDelta
 from cc_transcript._native import EntryMeta as EntryMeta
 from cc_transcript._native import EventList as EventList
 from cc_transcript._native import FallbackBlock as FallbackBlock
@@ -121,6 +122,7 @@ AttachmentDetail = (
     | HookAdditionalContext
     | AsyncHookResponse
     | QueuedCommand
+    | DeferredToolsDelta
     | OtherAttachment
 )
 

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/cc_transcript/render.py

@@ -40,7 +40,7 @@ def render_tool_call(call: ToolCall | FallbackCall, *, budget: Budget) -> str:
     The single tool-input renderer: Edit renders the path plus ``- old`` /
     ``+ new`` lines, MultiEdit renders every span under an ``edit i/n``
     marker, Write renders the path plus content, Bash renders the command,
-    and everything else renders a compact ``name(primary-arg)`` line.
+    and everything else renders the tool name with its full compact-JSON input.
 
     Example:
         >>> render_tool_call(parse_tool_call("Bash", {"command": "ls"}), budget=Budget())

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/pyproject.toml

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

@@ -0,0 +1,234 @@
+//! The file-centric `blame` and `attribute` verbs — native-only, with no click twin.
+//! `blame` lists the sessions that wrote a working-tree file, newest first; `attribute`
+//! classifies how the file came to exist. Both resolve the target's repo root from a
+//! `.git`/`.jj` ancestor and scan only that repo's project dirs unless `--all-projects`.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use cc_transcript_core::blame::{attribute as classify, blame as rank, session_writes, RepoPaths};
+use cc_transcript_core::discovery::{find_in, mtime_secs, project_dir_name};
+use cc_transcript_core::render::{attribute_json, attribute_lines, blame_json, blame_line};
+use cc_transcript_core::types::Entry;
+use chrono::{DateTime, FixedOffset};
+
+use crate::output::{click_error, eline, py_repr, usage_error, CliExit, Out};
+use crate::target::{claude_projects_dir, parse_transcripts, require_dir, Parsed};
+
+const BLAME_USAGE: &str = "cc-transcript blame [OPTIONS] <PATH>";
+const BLAME_HELP: &str = "cc-transcript blame";
+const ATTRIBUTE_USAGE: &str = "cc-transcript attribute [OPTIONS] <PATH>";
+const ATTRIBUTE_HELP: &str = "cc-transcript attribute";
+
+pub struct BlameArgs {
+    pub path: PathBuf,
+    pub root: Option<PathBuf>,
+    pub all_projects: bool,
+    pub since: Option<String>,
+    pub until: Option<String>,
+    pub limit: Option<usize>,
+    pub json: bool,
+}
+
+pub struct AttributeArgs {
+    pub path: PathBuf,
+    pub root: Option<PathBuf>,
+    pub all_projects: bool,
+    pub json: bool,
+}
+
+/// A resolved target: the repo it belongs to, its repo-relative path, and its canonical
+/// on-disk location.
+struct Target {
+    repo: RepoPaths,
+    rel_target: String,
+    canonical: PathBuf,
+}
+
+/// The nearest ancestor directory carrying a `.git` or `.jj` entry (file or dir — a
+/// worktree's `.git` is a file), starting from the target's own parent.
+fn marker_root(canonical: &Path) -> Option<&Path> {
+    canonical
+        .ancestors()
+        .skip(1)
+        .find(|dir| dir.join(".git").exists() || dir.join(".jj").exists())
+}
+
+/// A worktree's marker root lifts to the main checkout: everything before the
+/// `/.claude/worktrees/` segment. Any other marker root is the repo root as found.
+fn repo_root(marker: &Path) -> String {
+    let text = marker.to_string_lossy();
+    let marker_segment = format!("/{}", cc_transcript_core::blame::WORKTREES_SEGMENT);
+    match text.find(&marker_segment) {
+        Some(cut) => text[..cut].to_string(),
+        None => text.into_owned(),
+    }
+}
+
+fn resolve_target(path: &Path, usage: &str, help_path: &str) -> Result<Target, CliExit> {
+    let invalid = |what: &str| {
+        usage_error(
+            usage,
+            help_path,
+            &format!(
+                "Invalid value for 'PATH': File {} {what}.",
+                py_repr(&path.to_string_lossy())
+            ),
+        )
+    };
+    let canonical = fs::canonicalize(path).map_err(|_| invalid("does not exist"))?;
+    if canonical.is_dir() {
+        return Err(invalid("is a directory"));
+    }
+    let marker = marker_root(&canonical).ok_or_else(|| {
+        click_error(&format!(
+            "{} is not inside a repository (no .git or .jj ancestor)",
+            path.display()
+        ))
+    })?;
+    let rel_target = canonical
+        .strip_prefix(marker)
+        .expect("canonical target sits under its marker root")
+        .to_string_lossy()
+        .into_owned();
+    Ok(Target {
+        repo: RepoPaths {
+            root: repo_root(marker),
+        },
+        rel_target,
+        canonical,
+    })
+}
+
+/// Parse every transcript under a project dir belonging to `repo_root` (or every dir
+/// under `--all-projects`), dropping files older than `min_mtime` (blame's `--since`).
+/// The `{encoded}-` prefix admits prefix-collided siblings (`<root>-rust`); the engine's
+/// per-call cwd check drops their writes.
+fn select_transcripts(
+    projects_root: &Path,
+    repo_root: &str,
+    all_projects: bool,
+    min_mtime: Option<f64>,
+    usage: &str,
+    help_path: &str,
+) -> Result<Vec<Parsed>, CliExit> {
+    require_dir(projects_root, "'--root'", usage, help_path)?;
+    let encoded = project_dir_name(repo_root);
+    let prefix = format!("{encoded}-");
+    let pairs: Vec<(PathBuf, f64)> = fs::read_dir(projects_root)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter(|entry| {
+            let name = entry.file_name().to_string_lossy().into_owned();
+            all_projects || name == encoded || name.starts_with(&prefix)
+        })
+        .flat_map(|entry| find_in(&entry.path(), None, None, None))
+        .filter(|(_, mtime)| min_mtime.is_none_or(|floor| *mtime >= floor))
+        .collect();
+    Ok(parse_transcripts(&pairs))
+}
+
+/// A file mtime (`os.stat` seconds) as a UTC-offset datetime, for the attribute window.
+fn mtime_datetime(mtime: f64) -> DateTime<FixedOffset> {
+    let secs = mtime.floor();
+    let nanos = ((mtime - secs) * 1e9) as u32;
+    DateTime::from_timestamp(secs as i64, nanos)
+        .expect("file mtime is in range")
+        .fixed_offset()
+}
+
+pub fn blame(args: BlameArgs) -> Result<(), CliExit> {
+    let target = resolve_target(&args.path, BLAME_USAGE, BLAME_HELP)?;
+    let now = chrono::Local::now();
+    let since = args
+        .since
+        .as_deref()
+        .map(|value| crate::timearg::parse_time("--since", value, now, BLAME_USAGE, BLAME_HELP))
+        .transpose()?;
+    let until = args
+        .until
+        .as_deref()
+        .map(|value| crate::timearg::parse_time("--until", value, now, BLAME_USAGE, BLAME_HELP))
+        .transpose()?;
+    let projects_root = args.root.unwrap_or_else(claude_projects_dir);
+    let parsed = select_transcripts(
+        &projects_root,
+        &target.repo.root,
+        args.all_projects,
+        since.map(|ts| ts.timestamp() as f64),
+        BLAME_USAGE,
+        BLAME_HELP,
+    )?;
+    let mut records = rank(
+        parsed
+            .iter()
+            .filter_map(|p| p.session_id.as_deref().map(|session| (session, p)))
+            .flat_map(|(session, p)| {
+                session_writes(
+                    session,
+                    &p.path.to_string_lossy(),
+                    &p.entries,
+                    &target.repo,
+                    &target.rel_target,
+                    since,
+                    until,
+                )
+            })
+            .collect(),
+    );
+    if let Some(limit) = args.limit {
+        records.truncate(limit);
+    }
+    if records.is_empty() {
+        eline(&format!("no sessions wrote {}", target.rel_target));
+        return Err(CliExit(1));
+    }
+    let mut out = Out::new();
+    for record in &records {
+        out.line(&match args.json {
+            true => blame_json(record).dumps(),
+            false => blame_line(record),
+        })?;
+    }
+    out.finish()
+}
+
+pub fn attribute(args: AttributeArgs) -> Result<(), CliExit> {
+    let target = resolve_target(&args.path, ATTRIBUTE_USAGE, ATTRIBUTE_HELP)?;
+    let meta = fs::metadata(&target.canonical)
+        .map_err(|e| click_error(&format!("{}: {e}", args.path.display())))?;
+    let mtime = mtime_datetime(mtime_secs(&meta));
+    let projects_root = args.root.unwrap_or_else(claude_projects_dir);
+    let parsed = select_transcripts(
+        &projects_root,
+        &target.repo.root,
+        args.all_projects,
+        None,
+        ATTRIBUTE_USAGE,
+        ATTRIBUTE_HELP,
+    )?;
+    let owned: Vec<(&str, String, &[Entry])> = parsed
+        .iter()
+        .filter_map(|p| {
+            p.session_id.as_deref().map(|session| {
+                (
+                    session,
+                    p.path.to_string_lossy().into_owned(),
+                    p.entries.as_slice(),
+                )
+            })
+        })
+        .collect();
+    let sessions: Vec<(&str, &str, &[Entry])> = owned
+        .iter()
+        .map(|(session, path, entries)| (*session, path.as_str(), *entries))
+        .collect();
+    let verdict = classify(&sessions, &target.repo, &target.rel_target, mtime);
+    let mut out = Out::new();
+    match args.json {
+        true => out.line(&attribute_json(&verdict, &target.rel_target, mtime).dumps())?,
+        false => out.lines(attribute_lines(&verdict, &target.rel_target))?,
+    }
+    out.finish()
+}

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/rust/crates/cli/src/commands/facts.rs

@@ -3,6 +3,7 @@
 use std::path::PathBuf;
 
 use cc_transcript_core::facts::{command_prefix_counts, mcp_summary, tool_facts, ToolFact};
+use cc_transcript_core::query::FileRef;
 use cc_transcript_core::render::{
     denial_json, denial_line, fact_json, fact_line, render_counts, render_mcp, Json,
 };
@@ -18,6 +19,7 @@ fn gather(
     paths: &[PathBuf],
     discovery: &DiscoveryOpts,
     name: &str,
+    min_mtime: Option<f64>,
 ) -> Result<(Targets, Vec<ToolFact>), CliExit> {
     let paths: Vec<PathBuf> = paths
         .iter()
@@ -32,6 +34,7 @@ fn gather(
         discovery.project.as_deref(),
         discovery.contains.as_deref(),
         discovery.effective_limit(),
+        min_mtime,
     )?;
     let facts: Vec<ToolFact> = parse_transcripts(&targets.paths)
         .iter()
@@ -54,12 +57,34 @@ pub fn tools(
     paths: &[PathBuf],
     discovery: &DiscoveryOpts,
     tool: Option<&str>,
+    file: Option<&str>,
+    since: Option<&str>,
+    until: Option<&str>,
     json: bool,
 ) -> Result<(), CliExit> {
-    let (targets, facts) = gather(paths, discovery, "tools")?;
+    let usage = "cc-transcript tools [OPTIONS] [PATHS]...";
+    let help_path = "cc-transcript tools";
+    let now = chrono::Local::now();
+    let since_ts = since
+        .map(|value| crate::timearg::parse_time("--since", value, now, usage, help_path))
+        .transpose()?;
+    let until_ts = until
+        .map(|value| crate::timearg::parse_time("--until", value, now, usage, help_path))
+        .transpose()?;
+    let min_mtime = since_ts.map(|ts| ts.timestamp() as f64);
+    let (targets, facts) = gather(paths, discovery, "tools", min_mtime)?;
     let facts: Vec<&ToolFact> = facts
         .iter()
         .filter(|fact| tool.is_none_or(|t| tool_name_matches(&fact.tool, t)))
+        .filter(|fact| {
+            file.is_none_or(|glob| {
+                fact.file_paths
+                    .iter()
+                    .any(|p| FileRef::new(p).matches(&[glob]))
+            })
+        })
+        .filter(|fact| since_ts.is_none_or(|s| fact.ts >= s))
+        .filter(|fact| until_ts.is_none_or(|u| fact.ts < u))
         .collect();
     let mut out = Out::new();
     if json {
@@ -76,7 +101,7 @@ pub fn tools(
 }
 
 pub fn commands(paths: &[PathBuf], discovery: &DiscoveryOpts, json: bool) -> Result<(), CliExit> {
-    let (targets, facts) = gather(paths, discovery, "commands")?;
+    let (targets, facts) = gather(paths, discovery, "commands", None)?;
     let counts = command_prefix_counts(facts.iter());
     let mut out = Out::new();
     if json {
@@ -103,7 +128,7 @@ pub fn permissions(
     discovery: &DiscoveryOpts,
     json: bool,
 ) -> Result<(), CliExit> {
-    let (targets, facts) = gather(paths, discovery, "permissions")?;
+    let (targets, facts) = gather(paths, discovery, "permissions", None)?;
     let denials: Vec<&ToolFact> = facts
         .iter()
         .filter(|fact| fact.denied)
@@ -124,7 +149,7 @@ pub fn permissions(
 }
 
 pub fn mcp(paths: &[PathBuf], discovery: &DiscoveryOpts, json: bool) -> Result<(), CliExit> {
-    let (targets, facts) = gather(paths, discovery, "mcp")?;
+    let (targets, facts) = gather(paths, discovery, "mcp", None)?;
     let summary = mcp_summary(facts.iter());
     let mut out = Out::new();
     if json {

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/rust/crates/cli/src/commands/grep.rs

@@ -5,7 +5,9 @@ use std::path::PathBuf;
 
 use cc_transcript_core::facts::{tool_facts, ToolFact};
 use cc_transcript_core::filter::event_kind;
-use cc_transcript_core::render::{compact_line, event_json, haystack, transcript_header, Json};
+use cc_transcript_core::render::{
+    compact_line, event_json, haystack, tool_haystack, transcript_header, Json,
+};
 use cc_transcript_core::toolcall::tool_name_matches;
 use cc_transcript_core::types::{ContentBlock, Entry};
 use regex::{Regex, RegexBuilder};
@@ -23,6 +25,7 @@ pub struct GrepArgs {
     pub discovery: DiscoveryOpts,
     pub kinds: Vec<String>,
     pub tool: Option<String>,
+    pub errors: bool,
     pub ignore_case: bool,
     pub wheres: Vec<String>,
     pub context: usize,
@@ -61,6 +64,28 @@ fn event_facts<'a>(event: &Entry, facts: &'a HashMap<String, ToolFact>) -> Vec<&
     }
 }
 
+fn error_call_matches(
+    event: &Entry,
+    facts: &HashMap<String, ToolFact>,
+    regex: &Regex,
+    tool: Option<&str>,
+    where_tools: bool,
+) -> bool {
+    where_tools
+        && event.blocks().iter().any(|block| {
+            let fact = match block {
+                ContentBlock::ToolUse(tool_use) => facts.get(&tool_use.id),
+                ContentBlock::ToolResult(result) => facts.get(&result.tool_use_id),
+                _ => None,
+            };
+            fact.is_some_and(|fact| {
+                fact.is_error
+                    && tool.is_none_or(|name| tool_name_matches(&fact.tool, name))
+                    && regex.is_match(&tool_haystack(block))
+            })
+        })
+}
+
 fn result_key(fact: &ToolFact) -> Json {
     Json::Obj(vec![
         ("is_error".into(), Json::Bool(fact.is_error)),
@@ -156,6 +181,7 @@ pub fn run(args: GrepArgs) -> Result<(), CliExit> {
         args.discovery.project.as_deref(),
         args.discovery.contains.as_deref(),
         args.discovery.effective_limit(),
+        None,
     )?;
     let mut out_lines: Vec<String> = Vec::new();
     let mut files_matched = 0usize;
@@ -166,6 +192,11 @@ pub fn run(args: GrepArgs) -> Result<(), CliExit> {
             break;
         }
         let names = tool_names(&parsed.entries);
+        let facts = if args.with_result || args.errors {
+            fact_index(&parsed)
+        } else {
+            HashMap::new()
+        };
         let hits: Vec<usize> = parsed
             .entries
             .iter()
@@ -174,22 +205,25 @@ pub fn run(args: GrepArgs) -> Result<(), CliExit> {
                 args.kinds.is_empty() || args.kinds.iter().any(|k| k == event_kind(event))
             })
             .filter(|(_, event)| {
-                args.tool
-                    .as_deref()
-                    .is_none_or(|tool| uses_tool(event, tool, &names))
+                args.errors
+                    || args
+                        .tool
+                        .as_deref()
+                        .is_none_or(|tool| uses_tool(event, tool, &names))
+            })
+            .filter(|(_, event)| {
+                if args.errors {
+                    error_call_matches(event, &facts, &regex, args.tool.as_deref(), w_tools)
+                } else {
+                    regex.is_match(&haystack(event, w_text, w_thinking, w_tools))
+                }
             })
-            .filter(|(_, event)| regex.is_match(&haystack(event, w_text, w_thinking, w_tools)))
             .map(|(index, _)| index)
             .take(budget)
             .collect();
         if hits.is_empty() {
             continue;
         }
-        let facts = if args.with_result {
-            fact_index(&parsed)
-        } else {
-            HashMap::new()
-        };
         files_matched += 1;
         matched += hits.len();
         budget -= hits.len();

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/rust/crates/cli/src/commands/mod.rs

@@ -1,3 +1,4 @@
+pub mod blame;
 pub mod corrections;
 pub mod digest;
 pub mod facts;

{cc_transcript-14.9.0 → cc_transcript-14.10.0}/rust/crates/cli/src/commands/show.rs

@@ -6,7 +6,7 @@ use std::path::PathBuf;
 
 use cc_transcript_core::filter::{event_kind, spec_keep, CompiledSpec, NOISE_SPEC, SIGNAL_SPEC};
 use cc_transcript_core::render::{compact_line, event_json};
-use cc_transcript_core::types::Entry;
+use cc_transcript_core::types::{ContentBlock, Entry};
 
 use crate::output::{eline, py_repr, usage_error, CliExit, Out};
 use crate::target::{parse_single, py_path, require_files, tool_names};
@@ -24,6 +24,7 @@ pub struct ShowArgs {
     pub kinds: Vec<String>,
     pub signal: bool,
     pub no_junk: bool,
+    pub errors: bool,
     pub thinking: bool,
     pub width: usize,
     pub uuids: bool,
@@ -60,12 +61,19 @@ pub fn filter_rows<'a>(
     entries: &'a [Entry],
     kinds: &[String],
     spec: Option<&CompiledSpec>,
+    errors: bool,
 ) -> Vec<(usize, &'a Entry)> {
     entries
         .iter()
         .enumerate()
         .filter(|(_, event)| kinds.is_empty() || kinds.iter().any(|k| k == event_kind(event)))
         .filter(|(_, event)| spec.is_none_or(|s| spec_keep(s, event)))
+        .filter(|(_, event)| {
+            !errors
+                || matches!(event, Entry::User(u) if u.blocks().iter().any(
+                    |block| matches!(block, ContentBlock::ToolResult(result) if result.is_error)
+                ))
+        })
         .collect()
 }
 
@@ -133,7 +141,7 @@ pub fn run(args: ShowArgs) -> Result<(), CliExit> {
     } else {
         None
     };
-    let rows = filter_rows(&parsed.entries, &args.kinds, spec);
+    let rows = filter_rows(&parsed.entries, &args.kinds, spec, args.errors);
     let (selected, notice) = slice_rows(rows, args.head, args.tail, bounds, args.all);
     let mut out = Out::new();
     if args.json {