cc-transcript 10.1.0__tar.gz → 10.3.0__tar.gz

{cc_transcript-10.1.0 → cc_transcript-10.3.0}/PKG-INFO

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

{cc_transcript-10.1.0 → cc_transcript-10.3.0}/cc_transcript/activity.py

@@ -39,10 +39,12 @@ UserClassifier = Callable[["UserEvent"], bool]
 def native_user_classifier(event: UserEvent) -> bool:
     """Whether a user event is a real prompt under native Claude Code semantics.
 
-    A prompt is non-meta, non-sidechain, not an interruption marker, and not
-    tool-result-only — it must carry real text.
+    A prompt is non-meta, non-sidechain, not a compact summary, not an
+    interruption marker, and not tool-result-only — it must carry real text.
     """
-    return not (event.meta.is_meta or event.meta.is_sidechain or event.interrupted) and bool(event.text.strip())
+    return not (
+        event.meta.is_meta or event.meta.is_sidechain or event.meta.is_compact_summary or event.interrupted
+    ) and bool(event.text.strip())
 
 
 @dataclass(frozen=True, slots=True)

{cc_transcript-10.1.0 → cc_transcript-10.3.0}/cc_transcript/activity_probe.py

@@ -129,9 +129,7 @@ def probe_events(
         (
             index
             for index in reversed(range(len(events)))
-            if isinstance(event := events[index], UserEvent)
-            and native_user_classifier(event)
-            and not event.meta.is_compact_summary
+            if isinstance(event := events[index], UserEvent) and native_user_classifier(event)
         ),
         0,
     )

{cc_transcript-10.1.0 → cc_transcript-10.3.0}/cc_transcript/mining/signals.py

@@ -132,7 +132,7 @@ def last_edit_index(events: Sequence[TranscriptEvent], index: int, spec: MiningS
             i
             for i in range(index - 1, max(index - spec.reentry_lookback, 0) - 1, -1)
             if isinstance(event := events[i], AssistantEvent)
-            if any(isinstance(b, ToolUseBlock) and b.name in spec.edit_tools for b in event.blocks)
+            if any(isinstance(b, ToolUseBlock) and matches_names(b.name, spec.edit_tools) for b in event.blocks)
         ),
         None,
     )

{cc_transcript-10.1.0 → cc_transcript-10.3.0}/cc_transcript/tools.py

@@ -32,6 +32,14 @@ TOOL_ALIASES: dict[str, str] = {
 
 TOOL_ALIASES_REVERSE: dict[str, str] = {v: k for k, v in TOOL_ALIASES.items()}
 
+# cc-context routes real file edits through MCP tools whose bare names match no
+# builtin edit gate; alias its write surface to the builtins those gates watch so
+# an edit through the MCP can't slip past a Tool("Edit"/"Write"/"MultiEdit") guard.
+MCP_TOOL_ALIASES: dict[str, str] = {
+    "ccx_code_edit": "Edit",
+    "ccx_code_replace": "Write",
+}
+
 READ_VERBS = frozenset({"get", "list", "search", "read", "view", "fetch", "query", "describe", "show", "find"})
 
 
@@ -482,28 +490,34 @@ def file_path_of(call: ToolCall) -> str | None:
 
 
 def expand_tool_names(spec: str) -> frozenset[str]:
-    """Expand a pipe-separated tool spec to include both alias spellings."""
-    return frozenset(
-        (base := set(spec.split("|")))
-        | {alias for n in base for alias in (TOOL_ALIASES.get(n), TOOL_ALIASES_REVERSE.get(n)) if alias}
-    )
+    """Expand a pipe-separated tool spec to include alias and MCP bare spellings."""
+    base = set(spec.split("|"))
+    expanded = base | {alias for n in base for alias in (TOOL_ALIASES.get(n), TOOL_ALIASES_REVERSE.get(n)) if alias}
+    return frozenset(expanded | {bare for bare, builtin in MCP_TOOL_ALIASES.items() if builtin in expanded})
 
 
 def matches_names(actual: str, names: Container[str]) -> bool:
     """Whether ``actual`` is one of ``names``, exactly or as an MCP tool suffix.
 
     True when ``actual`` is in ``names``, or when it splits as
-    ``mcp__<server>__<tool>`` on the first two ``__`` and ``<tool>`` is in
-    ``names``. ``names`` is taken verbatim — no alias closure; pre-expand with
-    :func:`expand_tool_names` when aliases should match.
+    ``mcp__<server>__<tool>`` on the first two ``__`` and ``<tool>`` — or its
+    :data:`MCP_TOOL_ALIASES` builtin equivalent — is in ``names``. That alias
+    closes the edit-gate bypass where cc-context's ``ccx_code_edit`` /
+    ``ccx_code_replace`` write through the MCP under names no ``Edit``/``Write``
+    gate would catch. Harness-rename aliases are not closed over — ``names`` is
+    taken verbatim; pre-expand with :func:`expand_tool_names` for those.
 
     Example:
         >>> matches_names("mcp__github__Grep", {"Grep"})
         True
+        >>> matches_names("mcp__cc-context__ccx_code_edit", {"Edit"})
+        True
         >>> matches_names("Execute", {"Bash"})
         False
     """
-    return actual in names or ((mp := mcp_parts(actual)) is not None and mp[1] in names)
+    return actual in names or (
+        (mp := mcp_parts(actual)) is not None and (mp[1] in names or MCP_TOOL_ALIASES.get(mp[1]) in names)
+    )
 
 
 def tool_name_matches(actual: str, spec: str) -> bool:

{cc_transcript-10.1.0 → cc_transcript-10.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "10.1.0"
+version = "10.3.0"
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

{cc_transcript-10.1.0 → cc_transcript-10.3.0}/rust/src/mining.rs

@@ -8,7 +8,7 @@ use regex::Regex;
 use sonic_rs::{Index, JsonContainerTrait, JsonValueTrait, Value};
 
 use crate::filter::compile_group_array;
-use crate::parse::{parse_entry, ParseError};
+use crate::parse::{parse_bytes, ParseError};
 use crate::protocol::{
     embedded_user_text, interrupt_marker, is_bare_interrupt_marker, ANSWERED_PREFIX, ANSWERED_TRAILER,
     DENIAL_PREFIX, INTERRUPT_MARKER_RE,
@@ -434,13 +434,7 @@ impl Events {
     /// non-object values (parser.py decode_line) so event indices agree with the
     /// Python reference; a malformed entry fails the mine, as in the reference.
     fn parse(raw: &[u8]) -> Result<Self, ParseError> {
-        let entries = raw
-            .split(|&b| b == b'\n')
-            .filter(|line| !line.iter().all(u8::is_ascii_whitespace))
-            .filter_map(|line| sonic_rs::from_slice::<Value>(line).ok())
-            .filter(|value| value.is_object())
-            .map(parse_entry)
-            .collect::<Result<Vec<_>, _>>()?;
+        let entries = parse_bytes(raw, |_| true)?;
         let texts = entries
             .iter()
             .map(|entry| match entry {
@@ -479,7 +473,7 @@ impl Events {
         let lo = index.saturating_sub(spec.reentry_lookback);
         (lo..index)
             .rev()
-            .find(|&i| self.entries[i].tool_uses().any(|tu| spec.edit_tools.contains(&tu.name)))
+            .find(|&i| self.entries[i].tool_uses().any(|tu| matches_names(&tu.name, &spec.edit_tools)))
             .map(|i| i as i64)
     }
 }
@@ -1322,6 +1316,10 @@ mod tests {
         assert!(matches_names("mcp__conductor__ExitPlanMode", &names));
         assert!(!matches_names("mcp__ExitPlanMode", &names));
         assert!(!matches_names("AskUserQuestion", &names));
+
+        let edit_names: HashSet<String> = ["Edit".to_string(), "ccx_code_edit".to_string()].into();
+        assert!(matches_names("mcp__cc-context__ccx_code_edit", &edit_names));
+        assert!(!matches_names("mcp__cc-context__ccx_code_read", &edit_names));
     }
 
     #[test]

{cc_transcript-10.1.0 → cc_transcript-10.3.0}/rust/src/parse.rs

@@ -265,9 +265,10 @@ pub fn parse_entry(data: Value) -> Result<Entry, ParseError> {
     Ok(Entry::Other(OtherEntry { ty, raw: data }))
 }
 
-// Lines that are not valid JSON are skipped; a JSON line that fails the typed
-// parse (e.g. a missing required field) fails the whole file — whole-file
-// parity with PythonBackend, which parses every line before filtering.
+// Non-JSON lines and valid-JSON lines that are not objects (bare scalars or
+// arrays) are skipped; a JSON object that fails the typed parse (e.g. a missing
+// required field) fails the whole file — whole-file parity with PythonBackend,
+// which decodes every line, skips non-objects, then parses the rest.
 fn parse_line<F: Fn(&Entry) -> bool>(
     line: &[u8],
     lines: &mut Vec<Entry>,
@@ -277,6 +278,9 @@ fn parse_line<F: Fn(&Entry) -> bool>(
         return Ok(());
     }
     if let Ok(value) = sonic_rs::from_slice::<Value>(line) {
+        if !value.is_object() {
+            return Ok(());
+        }
         let entry = parse_entry(value)?;
         if keep(&entry) {
             lines.push(entry);
@@ -614,6 +618,15 @@ mod tests {
         assert_eq!(other.raw, parse(raw));
     }
 
+    #[test]
+    fn parse_bytes_skips_valid_json_non_object_lines() {
+        let real = format!(r#"{{"type":"user",{META},"message":{{"content":"hi"}}}}"#);
+        let bytes = format!("{real}\n42\n\"bare\"\n[1,2,3]\n{real}");
+        let entries = parse_bytes(bytes.as_bytes(), |_| true).unwrap();
+        assert_eq!(entries.len(), 2, "bare scalar and array lines are skipped");
+        assert!(entries.iter().all(|e| matches!(e, Entry::User(_))));
+    }
+
     #[test]
     fn print_envelope_requires_result_element() {
         assert!(matches!(