cc-transcript 0.1.0__tar.gz → 0.3.0__tar.gz

{cc_transcript-0.1.0 → cc_transcript-0.3.0}/Cargo.lock

@@ -15,6 +15,15 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.5.1"
@@ -35,7 +44,7 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "cc_transcript_parser"
-version = "0.1.0"
+version = "0.3.0"
 dependencies = [
  "chrono",
  "crossbeam-channel",
@@ -44,6 +53,7 @@ dependencies = [
  "once_cell",
  "pyo3",
  "rayon",
+ "regex",
  "serde",
  "sonic-rs",
 ]
@@ -424,6 +434,35 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
 [[package]]
 name = "rend"
 version = "0.5.3"

{cc_transcript-0.1.0 → cc_transcript-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 0.1.0
+Version: 0.3.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -12,7 +12,10 @@ Requires-Dist: orjson>=3.10
 Requires-Dist: pytest>=8.0 ; extra == 'dev'
 Requires-Dist: pyright>=1.1 ; extra == 'dev'
 Requires-Dist: ruff>=0.8 ; extra == 'dev'
+Requires-Dist: spacy>=3.8 ; extra == 'lexicon'
+Requires-Dist: afinn>=0.1 ; extra == 'lexicon'
 Provides-Extra: dev
+Provides-Extra: lexicon
 License-File: LICENSE
 Summary: Typed events for Claude Code transcripts: discovery, a superset JSONL parser (Python + Rust), and ingestion-state tracking.
 Keywords: 
@@ -31,16 +34,16 @@ Project-URL: Repository, https://github.com/yasyf/cc-transcript
 [![PyPI](https://img.shields.io/pypi/v/cc-transcript.svg)](https://pypi.org/project/cc-transcript/)
 [![Python](https://img.shields.io/pypi/pyversions/cc-transcript.svg)](https://pypi.org/project/cc-transcript/)
 [![Docs](https://img.shields.io/github/actions/workflow/status/yasyf/cc-transcript/docs.yml?branch=main&label=docs)](https://yasyf.github.io/cc-transcript/)
-[![License: PolyForm-Noncommercial-1.0.0](https://img.shields.io/badge/License-PolyForm-Noncommercial-1.0.0-blue.svg)](https://github.com/yasyf/cc-transcript/blob/main/LICENSE)
+[![License: PolyForm Noncommercial](https://img.shields.io/badge/License-PolyForm--Noncommercial--1.0.0-blue.svg)](https://github.com/yasyf/cc-transcript/blob/main/LICENSE)
 
-The shared transcript-parsing core extracted from [cc-sentiment](https://github.com/yasyf/cc-sentiment), now powering cc-pushback, cc-sentiment, and captain-hook. It parses Claude Code's on-disk JSONL transcripts into a **typed superset event model** — every entry type preserved, nothing dropped — so each consumer applies its own semantic filtering on top of one faithful representation.
+`cc-transcript` parses Claude Code's on-disk JSONL transcripts into a **typed superset event model** — every entry type preserved, nothing dropped — so you build on one faithful representation and apply your own semantic filtering on top.
 
-The one property that makes it worth using: the parser is non-lossy. It never silently discards sidechains, synthetic turns, tool results, or unrecognized entry types; filtering is opt-in and lives in the consumer, not buried in the parser.
+The one property that makes it worth using: the parser is non-lossy. It never silently discards sidechains, synthetic turns, tool results, or unrecognized entry types; filtering is opt-in and lives in your code, not buried in the parser.
 
 ## Install
 
 ```bash
-uv add cc-transcript
+uv add cc-transcript        # or: pip install cc-transcript
 ```
 
 ## Quickstart
@@ -50,8 +53,7 @@ Discover the transcripts on disk, parse one, and look at the events:
 ```python
 from cc_transcript import TranscriptDiscovery, parse_events, AssistantEvent, UserEvent
 
-path, _mtime = TranscriptDiscovery.find_in(TranscriptDiscovery.find_transcripts()[0].parent)[0]
-events = parse_events(path)
+events = parse_events(TranscriptDiscovery.find_transcripts()[0])
 
 for event in events:
     match event:
@@ -61,7 +63,8 @@ for event in events:
             print(f"assistant ({model}):", text[:80])
 ```
 
-Apply cc-sentiment's filtering rules to drop sidechains, synthetic turns, and junk:
+`SENTIMENT_FILTER` is a ready-made filter that keeps only user and assistant turns,
+dropping sidechains, synthetic turns, compacted summaries, empty events, and tool/command noise:
 
 ```python
 from cc_transcript import apply_filters, SENTIMENT_FILTER
@@ -69,12 +72,14 @@ from cc_transcript import apply_filters, SENTIMENT_FILTER
 clean = list(apply_filters(events, SENTIMENT_FILTER))
 ```
 
+Build your own with `FilterConfig` — every rule is off by default, so a bare `FilterConfig()` passes everything through.
+
 ## What problems does this solve?
 
-- **One faithful parse, many consumers.** Every project that reads Claude Code transcripts re-implements the same JSONL quirks (str-or-list content, tool results nested two ways, envelope-less mode markers). This is that parser, written once and typed strictly.
+- **One faithful parse.** Anything reading Claude Code transcripts re-implements the same JSONL quirks (str-or-list content, tool results nested two ways, envelope-less mode markers). This is that parser, written once and typed strictly.
 - **Non-lossy by design.** The event model is a superset: sidechains, `<synthetic>` turns, thinking blocks, and unrecognized entry types all survive parsing. You decide what to drop, via `FilterConfig`.
-- **Incremental ingestion.** `FileStateStore` tracks per-file mtimes in SQLite (WAL, thread-safe) so re-runs only reparse changed files, and consumers compose their own writes in the same transaction.
-- **Pluggable backends.** A pure-Python reference parser ships today; a Rust backend behind the same `Backend` protocol reaches parity in a later release.
+- **Incremental ingestion.** `FileStateStore` tracks per-file mtimes in SQLite (WAL, thread-safe) so re-runs only reparse changed files, and you compose your own writes in the same transaction.
+- **Pluggable backends.** A Rust backend (PyO3 + rayon) is the default fast path, with a pure-Python reference parser behind the same `Backend` protocol as the fallback — both at full event parity.
 
 ## Docs
 

{cc_transcript-0.1.0 → cc_transcript-0.3.0}/README.md

@@ -3,16 +3,16 @@
 [![PyPI](https://img.shields.io/pypi/v/cc-transcript.svg)](https://pypi.org/project/cc-transcript/)
 [![Python](https://img.shields.io/pypi/pyversions/cc-transcript.svg)](https://pypi.org/project/cc-transcript/)
 [![Docs](https://img.shields.io/github/actions/workflow/status/yasyf/cc-transcript/docs.yml?branch=main&label=docs)](https://yasyf.github.io/cc-transcript/)
-[![License: PolyForm-Noncommercial-1.0.0](https://img.shields.io/badge/License-PolyForm-Noncommercial-1.0.0-blue.svg)](https://github.com/yasyf/cc-transcript/blob/main/LICENSE)
+[![License: PolyForm Noncommercial](https://img.shields.io/badge/License-PolyForm--Noncommercial--1.0.0-blue.svg)](https://github.com/yasyf/cc-transcript/blob/main/LICENSE)
 
-The shared transcript-parsing core extracted from [cc-sentiment](https://github.com/yasyf/cc-sentiment), now powering cc-pushback, cc-sentiment, and captain-hook. It parses Claude Code's on-disk JSONL transcripts into a **typed superset event model** — every entry type preserved, nothing dropped — so each consumer applies its own semantic filtering on top of one faithful representation.
+`cc-transcript` parses Claude Code's on-disk JSONL transcripts into a **typed superset event model** — every entry type preserved, nothing dropped — so you build on one faithful representation and apply your own semantic filtering on top.
 
-The one property that makes it worth using: the parser is non-lossy. It never silently discards sidechains, synthetic turns, tool results, or unrecognized entry types; filtering is opt-in and lives in the consumer, not buried in the parser.
+The one property that makes it worth using: the parser is non-lossy. It never silently discards sidechains, synthetic turns, tool results, or unrecognized entry types; filtering is opt-in and lives in your code, not buried in the parser.
 
 ## Install
 
 ```bash
-uv add cc-transcript
+uv add cc-transcript        # or: pip install cc-transcript
 ```
 
 ## Quickstart
@@ -22,8 +22,7 @@ Discover the transcripts on disk, parse one, and look at the events:
 ```python
 from cc_transcript import TranscriptDiscovery, parse_events, AssistantEvent, UserEvent
 
-path, _mtime = TranscriptDiscovery.find_in(TranscriptDiscovery.find_transcripts()[0].parent)[0]
-events = parse_events(path)
+events = parse_events(TranscriptDiscovery.find_transcripts()[0])
 
 for event in events:
     match event:
@@ -33,7 +32,8 @@ for event in events:
             print(f"assistant ({model}):", text[:80])
 ```
 
-Apply cc-sentiment's filtering rules to drop sidechains, synthetic turns, and junk:
+`SENTIMENT_FILTER` is a ready-made filter that keeps only user and assistant turns,
+dropping sidechains, synthetic turns, compacted summaries, empty events, and tool/command noise:
 
 ```python
 from cc_transcript import apply_filters, SENTIMENT_FILTER
@@ -41,12 +41,14 @@ from cc_transcript import apply_filters, SENTIMENT_FILTER
 clean = list(apply_filters(events, SENTIMENT_FILTER))
 ```
 
+Build your own with `FilterConfig` — every rule is off by default, so a bare `FilterConfig()` passes everything through.
+
 ## What problems does this solve?
 
-- **One faithful parse, many consumers.** Every project that reads Claude Code transcripts re-implements the same JSONL quirks (str-or-list content, tool results nested two ways, envelope-less mode markers). This is that parser, written once and typed strictly.
+- **One faithful parse.** Anything reading Claude Code transcripts re-implements the same JSONL quirks (str-or-list content, tool results nested two ways, envelope-less mode markers). This is that parser, written once and typed strictly.
 - **Non-lossy by design.** The event model is a superset: sidechains, `<synthetic>` turns, thinking blocks, and unrecognized entry types all survive parsing. You decide what to drop, via `FilterConfig`.
-- **Incremental ingestion.** `FileStateStore` tracks per-file mtimes in SQLite (WAL, thread-safe) so re-runs only reparse changed files, and consumers compose their own writes in the same transaction.
-- **Pluggable backends.** A pure-Python reference parser ships today; a Rust backend behind the same `Backend` protocol reaches parity in a later release.
+- **Incremental ingestion.** `FileStateStore` tracks per-file mtimes in SQLite (WAL, thread-safe) so re-runs only reparse changed files, and you compose your own writes in the same transaction.
+- **Pluggable backends.** A Rust backend (PyO3 + rayon) is the default fast path, with a pure-Python reference parser behind the same `Backend` protocol as the fallback — both at full event parity.
 
 ## Docs
 

cc_transcript-0.3.0/cc_transcript/__init__.py

@@ -0,0 +1,127 @@
+"""Typed events for Claude Code transcripts.
+
+Discovery, a superset JSONL parser (Python + Rust), and ingestion-state tracking.
+"""
+
+from __future__ import annotations
+
+from cc_transcript.backend import Backend, ParsedTranscript
+from cc_transcript.discovery import CLAUDE_PROJECTS_DIR, TranscriptDiscovery
+from cc_transcript.filters import JUNK_USER_MESSAGE_RE, SENTIMENT_FILTER, FilterConfig, apply_filters
+from cc_transcript.filterspec import (
+    FRUSTRATION_GROUPS,
+    INTERRUPT_MARKER_GROUPS,
+    INTERRUPT_MARKER_RE,
+    MILD_IMPATIENCE_GROUPS,
+    PUSHBACK_SPEC,
+    RESUME_PHRASE_SET,
+    SENTIMENT_JUNK_GROUPS,
+    SENTIMENT_SPEC,
+    SENTIMENT_STRUCTURAL_GROUPS,
+    SHORT_MESSAGE_MAX_WORDS,
+    STOP_HOOK_GROUPS,
+    STOP_HOOK_RE,
+    STRUCTURAL_NOISE_GROUPS,
+    STRUCTURAL_NOISE_RE,
+    TRIVIAL_ACK_SET,
+    Action,
+    Clause,
+    EntrypointIn,
+    FilterSpec,
+    KindIs,
+    MetaFlag,
+    ModelIs,
+    TextEmpty,
+    TextInSet,
+    TextMatchesAny,
+    WordCountAtMost,
+    annotate_spec,
+    apply_spec,
+    is_portable,
+    keep,
+    labels_for,
+    spec_to_json,
+)
+from cc_transcript.models import (
+    AssistantEvent,
+    CcVersion,
+    ContentBlock,
+    EntryMeta,
+    EntryUuid,
+    ModeEvent,
+    OtherEvent,
+    SessionId,
+    SystemEvent,
+    TextBlock,
+    ThinkingBlock,
+    ToolResultBlock,
+    ToolUseBlock,
+    ToolUseId,
+    TranscriptEvent,
+    UserEvent,
+)
+from cc_transcript.parser import TranscriptParser, parse_events, parse_events_from_bytes
+from cc_transcript.store import FileStateStore
+
+__all__ = [
+    "CLAUDE_PROJECTS_DIR",
+    "FRUSTRATION_GROUPS",
+    "INTERRUPT_MARKER_GROUPS",
+    "INTERRUPT_MARKER_RE",
+    "JUNK_USER_MESSAGE_RE",
+    "MILD_IMPATIENCE_GROUPS",
+    "PUSHBACK_SPEC",
+    "RESUME_PHRASE_SET",
+    "SENTIMENT_FILTER",
+    "SENTIMENT_JUNK_GROUPS",
+    "SENTIMENT_SPEC",
+    "SENTIMENT_STRUCTURAL_GROUPS",
+    "SHORT_MESSAGE_MAX_WORDS",
+    "STOP_HOOK_GROUPS",
+    "STOP_HOOK_RE",
+    "STRUCTURAL_NOISE_GROUPS",
+    "STRUCTURAL_NOISE_RE",
+    "TRIVIAL_ACK_SET",
+    "Action",
+    "AssistantEvent",
+    "Backend",
+    "CcVersion",
+    "Clause",
+    "ContentBlock",
+    "EntryMeta",
+    "EntryUuid",
+    "EntrypointIn",
+    "FileStateStore",
+    "FilterConfig",
+    "FilterSpec",
+    "KindIs",
+    "MetaFlag",
+    "ModeEvent",
+    "ModelIs",
+    "OtherEvent",
+    "ParsedTranscript",
+    "SessionId",
+    "SystemEvent",
+    "TextBlock",
+    "TextEmpty",
+    "TextInSet",
+    "TextMatchesAny",
+    "ThinkingBlock",
+    "ToolResultBlock",
+    "ToolUseBlock",
+    "ToolUseId",
+    "TranscriptDiscovery",
+    "TranscriptEvent",
+    "TranscriptParser",
+    "UserEvent",
+    "WordCountAtMost",
+    "annotate_spec",
+    "apply_filters",
+    "apply_spec",
+    "is_portable",
+    "keep",
+    "labels_for",
+    "parse_events",
+    "parse_events_from_bytes",
+    "spec_to_json",
+]

{cc_transcript-0.1.0 → cc_transcript-0.3.0}/cc_transcript/_parser_rs.pyi

@@ -11,5 +11,11 @@ class ParseStream:
     def recv_many(self, max: int, /) -> list[tuple[str, float, list[TranscriptEvent]]]:
         """Blocks for at least one parsed file, then drains up to ``max``."""
 
-def stream_parse(paths: list[tuple[str, float]], prefetch: int, /) -> ParseStream:
-    """Spawns a rayon pool parsing ``paths``, buffering ``prefetch`` results."""
+def stream_parse(
+    paths: list[tuple[str, float]], prefetch: int, spec_json: str | None = ..., /
+) -> ParseStream:
+    """Spawns a rayon pool parsing ``paths``, buffering ``prefetch`` results.
+
+    When ``spec_json`` is the JSON of a portable filter spec, events failing it
+    are dropped during parsing, before any Python object is built.
+    """

{cc_transcript-0.1.0 → cc_transcript-0.3.0}/cc_transcript/backend.py

@@ -7,6 +7,7 @@ if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Sequence
     from pathlib import Path
 
+    from cc_transcript.filterspec import FilterSpec
     from cc_transcript.models import TranscriptEvent
 
 
@@ -39,12 +40,16 @@ class Backend(Protocol):
         paths: Sequence[tuple[Path, float]],
         *,
         prefetch: int,
+        spec: FilterSpec | None = None,
     ) -> AsyncIterator[ParsedTranscript]:
         """Parses ``paths`` concurrently, yielding results as they complete.
 
         Args:
             paths: Pairs of ``(path, mtime)`` to parse.
             prefetch: The number of files to keep in flight at once.
+            spec: When given, events failing the spec are dropped during
+                parsing; portable specs run in the Rust backend, others fall
+                back to the Python interpreter.
 
         Yields:
             One :class:`ParsedTranscript` per input path.

{cc_transcript-0.1.0 → cc_transcript-0.3.0}/cc_transcript/discovery.py

@@ -27,6 +27,11 @@ class TranscriptDiscovery:
         except OSError:
             return None
 
+    @staticmethod
+    def transcript_mtime(path: Path) -> float:
+        """Returns ``path``'s modification time, raising if it cannot be read."""
+        return path.stat().st_mtime
+
     @staticmethod
     def find_in(
         directory: Path,

{cc_transcript-0.1.0 → cc_transcript-0.3.0}/cc_transcript/filters.py

@@ -4,37 +4,47 @@ import re
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
-from cc_transcript.models import AssistantEvent, ModeEvent, OtherEvent, SystemEvent, ToolUseBlock, UserEvent
+from cc_transcript.filterspec import (
+    ASSISTANTS,
+    SENTIMENT_JUNK_GROUPS,
+    USERS,
+    Clause,
+    EntrypointIn,
+    FilterSpec,
+    KindIs,
+    MetaFlag,
+    ModelIs,
+    TextEmpty,
+    TextMatchesAny,
+    apply_spec,
+    compile_groups,
+)
+from cc_transcript.models import AssistantEvent, ModeEvent, OtherEvent, SystemEvent, UserEvent
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator
 
+    from cc_transcript.filterspec import EventKind
     from cc_transcript.models import TranscriptEvent
 
-JUNK_USER_MESSAGE_RE = re.compile(
-    r"<(?:system[_-](?:instruction|reminder)"
-    r"|local-command-(?:stdout|caveat)"
-    r"|command-(?:name|message|args)"
-    r"|task-notification"
-    r"|persisted-output"
-    r"|output-file)\b"
-    r"|Caveat: The messages below were generated by the user while running local commands\."
-    r"|\[Request interrupted by user"
-    r"|Stop hook feedback:"
-    r"|REMAINING_TASKS_ACKNOWLEDGED"
-    r"|<<[a-z][a-z0-9-]*>>"
-    r"|^Base directory for this skill:"
-    r"|(?:###\s+[\w][\w \-]{0,30}\s+){3,}###",
-    re.IGNORECASE,
-)
+JUNK_USER_MESSAGE_RE = compile_groups(SENTIMENT_JUNK_GROUPS, True)
+
+KIND_BY_TYPE: dict[type[TranscriptEvent], EventKind] = {
+    UserEvent: "user",
+    AssistantEvent: "assistant",
+    SystemEvent: "system",
+    ModeEvent: "mode",
+    OtherEvent: "other",
+}
 
 
 @dataclass(frozen=True, slots=True)
 class FilterConfig:
     """Opt-in, consumer-side filtering of a transcript event stream.
 
-    Every flag defaults off, so a bare ``FilterConfig()`` passes events
-    through untouched.
+    A back-compatible flag-bag that lowers to a :class:`~cc_transcript.FilterSpec`
+    via :meth:`to_spec`. Every flag defaults off, so a bare ``FilterConfig()``
+    passes events through untouched.
 
     Attributes:
         keep_types: When set, drop every event not an instance of one of these
@@ -57,6 +67,34 @@ class FilterConfig:
     drop_ephemeral_entrypoints: frozenset[str] = frozenset()
     junk_pattern: re.Pattern[str] | None = field(default=None)
 
+    def to_spec(self) -> FilterSpec:
+        """Lowers this flag-bag into an equivalent ordered :class:`FilterSpec`."""
+        return FilterSpec(clauses=tuple(self.clauses()))
+
+    def clauses(self) -> Iterator[Clause]:
+        if self.keep_types is not None:
+            yield Clause(KindIs(frozenset(KIND_BY_TYPE[kind] for kind in self.keep_types)), negate=True)
+        if self.drop_synthetic:
+            yield Clause(ModelIs(frozenset({"<synthetic>"})), applies_to=ASSISTANTS)
+        if self.drop_empty:
+            yield Clause(TextEmpty(consider_tool_use=True), applies_to=ASSISTANTS)
+            yield Clause(TextEmpty(consider_tool_use=False), applies_to=USERS)
+        if self.junk_pattern is not None:
+            yield Clause(
+                TextMatchesAny(
+                    (("junk", self.junk_pattern.pattern),),
+                    ignore_case=bool(self.junk_pattern.flags & re.IGNORECASE),
+                ),
+                applies_to=USERS,
+            )
+        if self.drop_sidechain:
+            yield Clause(MetaFlag("is_sidechain"))
+        if self.drop_compacted:
+            yield Clause(MetaFlag("is_compact_summary"))
+            yield Clause(MetaFlag("is_visible_in_transcript_only"))
+        if self.drop_ephemeral_entrypoints:
+            yield Clause(EntrypointIn(self.drop_ephemeral_entrypoints))
+
 
 SENTIMENT_FILTER = FilterConfig(
     keep_types=(UserEvent, AssistantEvent),
@@ -69,30 +107,6 @@ SENTIMENT_FILTER = FilterConfig(
 )
 
 
-def keep(event: TranscriptEvent, config: FilterConfig) -> bool:
-    if config.keep_types is not None and not isinstance(event, config.keep_types):
-        return False
-    match event:
-        case OtherEvent() | ModeEvent():
-            return True
-        case AssistantEvent() if config.drop_synthetic and event.model == "<synthetic>":
-            return False
-        case AssistantEvent() if config.drop_empty and not event.text.strip() and not any(
-            isinstance(block, ToolUseBlock) for block in event.blocks
-        ):
-            return False
-        case UserEvent() if config.drop_empty and not event.text.strip():
-            return False
-        case UserEvent() if config.junk_pattern is not None and config.junk_pattern.search(event.text):
-            return False
-        case UserEvent(meta=meta) | AssistantEvent(meta=meta) | SystemEvent(meta=meta):
-            if config.drop_sidechain and meta.is_sidechain:
-                return False
-            if config.drop_compacted and (meta.is_compact_summary or meta.is_visible_in_transcript_only):
-                return False
-            return meta.entrypoint not in config.drop_ephemeral_entrypoints
-
-
 def apply_filters(events: Iterable[TranscriptEvent], config: FilterConfig) -> Iterator[TranscriptEvent]:
     """Yields the events that survive ``config``.
 
@@ -103,7 +117,7 @@ def apply_filters(events: Iterable[TranscriptEvent], config: FilterConfig) -> It
     Yields:
         The events for which every enabled rule holds.
     """
-    return (event for event in events if keep(event, config))
+    return apply_spec(events, config.to_spec())
 
 
 __all__ = ["JUNK_USER_MESSAGE_RE", "SENTIMENT_FILTER", "FilterConfig", "apply_filters"]