aline-ai 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

realign/triggers/claude_trigger.py

@@ -34,7 +34,7 @@ class ClaudeTrigger(TurnTrigger):
     def __init__(self, config: Optional[Dict] = None):
         super().__init__(config)
         # Retry detection config
-        self.retry_time_window = config.get('retry_time_window', 120) if config else 120
+        self.retry_time_window = config.get("retry_time_window", 120) if config else 120
 
     def get_supported_formats(self) -> List[str]:
         return ["claude_code"]
@@ -42,7 +42,7 @@ class ClaudeTrigger(TurnTrigger):
     def detect_session_format(self, session_file: Path) -> Optional[str]:
         """Detect if this is a Claude Code session file."""
         try:
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 for i, line in enumerate(f):
                     if i >= 10:
                         break
@@ -84,7 +84,7 @@ class ClaudeTrigger(TurnTrigger):
             return "request interrupted by user" in text.strip().lower()
 
         try:
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 for line_no, line in enumerate(f, 1):
                     line = line.strip()
                     if not line:
@@ -119,20 +119,25 @@ class ClaudeTrigger(TurnTrigger):
 
                             if isinstance(content, list):
                                 text_items = [
-                                    item.get("text", "") for item in content
+                                    item.get("text", "")
+                                    for item in content
                                     if isinstance(item, dict) and item.get("type") == "text"
                                 ]
-                                if text_items and all(_is_interrupt_placeholder(t) for t in text_items):
+                                if text_items and all(
+                                    _is_interrupt_placeholder(t) for t in text_items
+                                ):
                                     continue
 
                             if not is_tool_result:
-                                messages.append({
-                                    'line_no': line_no,
-                                    'uuid': data.get('uuid'),
-                                    'parent_uuid': data.get('parentUuid'),
-                                    'timestamp': data.get('timestamp'),
-                                    'content': content
-                                })
+                                messages.append(
+                                    {
+                                        "line_no": line_no,
+                                        "uuid": data.get("uuid"),
+                                        "parent_uuid": data.get("parentUuid"),
+                                        "timestamp": data.get("timestamp"),
+                                        "content": content,
+                                    }
+                                )
 
                     except json.JSONDecodeError:
                         continue
@@ -151,27 +156,27 @@ class ClaudeTrigger(TurnTrigger):
         visited = set()
         current = msg
 
-        while current['parent_uuid'] and current['parent_uuid'] in uuid_to_msg:
-            if current['uuid'] in visited:
+        while current["parent_uuid"] and current["parent_uuid"] in uuid_to_msg:
+            if current["uuid"] in visited:
                 break
-            visited.add(current['uuid'])
-            current = uuid_to_msg[current['parent_uuid']]
+            visited.add(current["uuid"])
+            current = uuid_to_msg[current["parent_uuid"]]
 
         return current
 
     def _group_by_root_timestamp(self, messages: List[Dict]) -> Dict[str, List[Dict]]:
         """Group messages by their root's timestamp."""
-        uuid_to_msg = {m['uuid']: m for m in messages}
+        uuid_to_msg = {m["uuid"]: m for m in messages}
 
         for msg in messages:
             root = self._find_root(msg, uuid_to_msg)
-            msg['root_uuid'] = root['uuid']
-            msg['root_timestamp'] = root['timestamp']
+            msg["root_uuid"] = root["uuid"]
+            msg["root_timestamp"] = root["timestamp"]
 
         groups = defaultdict(list)
         for msg in messages:
-            if msg['root_timestamp']:
-                groups[msg['root_timestamp']].append(msg)
+            if msg["root_timestamp"]:
+                groups[msg["root_timestamp"]].append(msg)
 
         return dict(groups)
 
@@ -183,22 +188,22 @@ class ClaudeTrigger(TurnTrigger):
         """Compute hash of message content for duplicate detection."""
         texts = []
         for msg in messages:
-            content = msg.get('content', [])
+            content = msg.get("content", [])
             if isinstance(content, str):
                 texts.append(content)
             elif isinstance(content, list):
                 for item in content:
-                    if isinstance(item, dict) and item.get('type') == 'text':
-                        texts.append(item.get('text', ''))
+                    if isinstance(item, dict) and item.get("type") == "text":
+                        texts.append(item.get("text", ""))
 
-        combined = '|'.join(texts)
+        combined = "|".join(texts)
         return hashlib.md5(combined.encode()).hexdigest()
 
     def _parse_timestamp(self, timestamp: str) -> Optional[datetime]:
         if not timestamp:
             return None
         try:
-            return datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+            return datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
         except Exception:
             return None
 
@@ -206,17 +211,17 @@ class ClaudeTrigger(TurnTrigger):
         dt1 = self._parse_timestamp(ts1)
         dt2 = self._parse_timestamp(ts2)
         if not dt1 or not dt2:
-            return float('inf')
+            return float("inf")
         return abs((dt2 - dt1).total_seconds())
 
     def _is_retry(self, group1: Dict, group2: Dict) -> bool:
         """Check if group2 is a retry of group1 (same content within time window)."""
-        time_diff = self._time_diff_seconds(group1['timestamp'], group2['timestamp'])
+        time_diff = self._time_diff_seconds(group1["timestamp"], group2["timestamp"])
         if time_diff > self.retry_time_window:
             return False
 
-        hash1 = self._get_content_hash(group1['messages'])
-        hash2 = self._get_content_hash(group2['messages'])
+        hash1 = self._get_content_hash(group1["messages"])
+        hash2 = self._get_content_hash(group2["messages"])
 
         return hash1 == hash2
 
@@ -225,7 +230,7 @@ class ClaudeTrigger(TurnTrigger):
         if not groups:
             return []
 
-        sorted_groups = sorted(groups, key=lambda g: g['timestamp'] or '')
+        sorted_groups = sorted(groups, key=lambda g: g["timestamp"] or "")
         merged = []
         i = 0
 
@@ -243,19 +248,19 @@ class ClaudeTrigger(TurnTrigger):
 
             if len(retry_groups) > 1:
                 merged_group = {
-                    'timestamp': retry_groups[0]['timestamp'],
-                    'messages': [],
-                    'lines': [],
-                    'retry_count': len(retry_groups),
-                    'parent_chains': sum(g.get('parent_chains', 1) for g in retry_groups)
+                    "timestamp": retry_groups[0]["timestamp"],
+                    "messages": [],
+                    "lines": [],
+                    "retry_count": len(retry_groups),
+                    "parent_chains": sum(g.get("parent_chains", 1) for g in retry_groups),
                 }
                 for g in retry_groups:
-                    merged_group['messages'].extend(g['messages'])
-                    merged_group['lines'].extend(g['lines'])
-                merged_group['lines'] = sorted(set(merged_group['lines']))
+                    merged_group["messages"].extend(g["messages"])
+                    merged_group["lines"].extend(g["lines"])
+                merged_group["lines"] = sorted(set(merged_group["lines"]))
                 merged.append(merged_group)
             else:
-                current['retry_count'] = 0
+                current["retry_count"] = 0
                 merged.append(current)
 
             i = j
@@ -268,7 +273,7 @@ class ClaudeTrigger(TurnTrigger):
 
     def _get_file_line_count(self, session_file: Path) -> int:
         try:
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 return sum(1 for _ in f)
         except Exception:
             return 0
@@ -300,7 +305,7 @@ class ClaudeTrigger(TurnTrigger):
 
         groups = []
         for timestamp, msgs in groups_dict.items():
-            root_uuids = set(msg.get('root_uuid') for msg in msgs if msg.get('root_uuid'))
+            root_uuids = set(msg.get("root_uuid") for msg in msgs if msg.get("root_uuid"))
             groups.append(
                 {
                     "timestamp": timestamp,
@@ -343,7 +348,11 @@ class ClaudeTrigger(TurnTrigger):
             has_explicit_end_marker = False
             if detect_turn_end_status and start_line > 0 and end_line >= start_line:
                 status = detect_turn_end_status(session_file, start_line, end_line)
-                if status.line is not None and status.status in ("user_interrupted", "rate_limited", "compacted"):
+                if status.line is not None and status.status in (
+                    "user_interrupted",
+                    "rate_limited",
+                    "compacted",
+                ):
                     has_explicit_end_marker = True
 
             if has_explicit_end_marker:
@@ -357,20 +366,20 @@ class ClaudeTrigger(TurnTrigger):
 
         analysis = self.get_detailed_analysis(session_file)
 
-        if 0 < turn_number <= len(analysis['groups']):
-            group = analysis['groups'][turn_number - 1]
+        if 0 < turn_number <= len(analysis["groups"]):
+            group = analysis["groups"][turn_number - 1]
 
             messages = self._extract_messages(session_file)
-            group_lines = set(group['lines'])
+            group_lines = set(group["lines"])
             first_msg = None
 
             for msg in messages:
-                if msg['line_no'] in group_lines:
+                if msg["line_no"] in group_lines:
                     first_msg = msg
                     break
 
             if first_msg:
-                content = first_msg['content']
+                content = first_msg["content"]
                 extracted_text = None
 
                 if isinstance(content, str):
@@ -388,9 +397,9 @@ class ClaudeTrigger(TurnTrigger):
                     return TurnInfo(
                         turn_number=turn_number,
                         user_message=cleaned_text,
-                        start_line=group['start_line'],
-                        end_line=group['end_line'],
-                        timestamp=group['root_timestamp']
+                        start_line=group["start_line"],
+                        end_line=group["end_line"],
+                        timestamp=group["root_timestamp"],
                     )
 
         return None
@@ -407,25 +416,27 @@ class ClaudeTrigger(TurnTrigger):
 
         groups = []
         for timestamp, msgs in groups_dict.items():
-            root_uuids = set(msg.get('root_uuid') for msg in msgs if msg.get('root_uuid'))
-            groups.append({
-                'timestamp': timestamp,
-                'messages': msgs,
-                'lines': sorted([msg['line_no'] for msg in msgs]),
-                'parent_chains': len(root_uuids)
-            })
+            root_uuids = set(msg.get("root_uuid") for msg in msgs if msg.get("root_uuid"))
+            groups.append(
+                {
+                    "timestamp": timestamp,
+                    "messages": msgs,
+                    "lines": sorted([msg["line_no"] for msg in msgs]),
+                    "parent_chains": len(root_uuids),
+                }
+            )
 
         merged_groups = self._merge_retry_groups(groups)
         total_lines = self._get_file_line_count(session_file)
 
         detailed_groups = []
         for turn_num, group in enumerate(merged_groups, 1):
-            lines = group['lines']
+            lines = group["lines"]
             start_line = lines[0]
 
             # Extend end_line to next turn's start - 1, or file end
             if turn_num < len(merged_groups):
-                next_start = merged_groups[turn_num]['lines'][0]
+                next_start = merged_groups[turn_num]["lines"][0]
                 end_line = max(lines[-1], next_start - 1)
             else:
                 end_line = max(lines[-1], total_lines)
@@ -447,45 +458,53 @@ class ClaudeTrigger(TurnTrigger):
 
             user_message = clean_user_message(extracted_text) if extracted_text else ""
 
-            detailed_groups.append({
-                'turn_number': turn_num,
-                'root_timestamp': group['timestamp'],
-                'message_count': len(group['messages']),
-                'parent_chains': group.get('parent_chains', 1),
-                'retry_count': group.get('retry_count', 0),
-                'lines': lines,
-                'start_line': start_line,
-                'end_line': end_line,
-                'line_range': f"{start_line}-{end_line}" if start_line != end_line else str(start_line),
-                'user_message': user_message,
-            })
+            detailed_groups.append(
+                {
+                    "turn_number": turn_num,
+                    "root_timestamp": group["timestamp"],
+                    "message_count": len(group["messages"]),
+                    "parent_chains": group.get("parent_chains", 1),
+                    "retry_count": group.get("retry_count", 0),
+                    "lines": lines,
+                    "start_line": start_line,
+                    "end_line": end_line,
+                    "line_range": (
+                        f"{start_line}-{end_line}" if start_line != end_line else str(start_line)
+                    ),
+                    "user_message": user_message,
+                }
+            )
 
         # Enrich with turn status
         try:
             from .turn_status import detect_turn_end_status, preview_text
+
             for g in detailed_groups:
-                status = detect_turn_end_status(session_file, g['start_line'], g['end_line'])
-                g['turn_status'] = status.status
-                g['interrupted'] = status.status in ("user_interrupted", "rate_limited")
-                g['turn_status_line'] = status.line
-                g['turn_status_message_preview'] = preview_text(status.message)
+                status = detect_turn_end_status(session_file, g["start_line"], g["end_line"])
+                g["turn_status"] = status.status
+                g["interrupted"] = status.status in ("user_interrupted", "rate_limited")
+                g["turn_status_line"] = status.line
+                g["turn_status_message_preview"] = preview_text(status.message)
         except Exception:
             pass
 
         # Enrich with assistant summary
         try:
             from .turn_summary import extract_turn_summary
+
             for g in detailed_groups:
-                summary_line, summary_msg = extract_turn_summary(session_file, g['start_line'], g['end_line'])
-                g['summary_line'] = summary_line
-                g['summary_message'] = summary_msg
+                summary_line, summary_msg = extract_turn_summary(
+                    session_file, g["start_line"], g["end_line"]
+                )
+                g["summary_line"] = summary_line
+                g["summary_message"] = summary_msg
         except Exception:
             pass
 
         return {
-            'total_turns': len(merged_groups),
-            'total_messages': len(messages),
-            'total_retries': sum(g.get('retry_count', 0) for g in merged_groups),
-            'groups': detailed_groups,
-            'format': 'claude_code',
+            "total_turns": len(merged_groups),
+            "total_messages": len(messages),
+            "total_retries": sum(g.get("retry_count", 0) for g in merged_groups),
+            "groups": detailed_groups,
+            "format": "claude_code",
         }

realign/triggers/codex_trigger.py

@@ -215,7 +215,10 @@ class CodexTrigger(TurnTrigger):
                     # Format 2: response_item wrapper around messages
                     if data.get("type") == "response_item":
                         payload = data.get("payload") or {}
-                        if payload.get("type") == "message" and payload.get("role") in ("user", "assistant"):
+                        if payload.get("type") == "message" and payload.get("role") in (
+                            "user",
+                            "assistant",
+                        ):
                             return "codex"
 
                     # Format 3: event_msg with user_message/agent_message
@@ -267,7 +270,9 @@ class CodexTrigger(TurnTrigger):
                         else:
                             # Deduplicate the common pair:
                             # response_item(role=user) + event_msg(user_message) with same content.
-                            if current.assistant_line is None and _normalize(user_msg) == _normalize(current.user_message):
+                            if current.assistant_line is None and _normalize(
+                                user_msg
+                            ) == _normalize(current.user_message):
                                 current.start_line = min(current.start_line, line_no)
                                 if current.start_timestamp is None:
                                     current.start_timestamp = user_ts
@@ -295,7 +300,11 @@ class CodexTrigger(TurnTrigger):
                         continue
 
                     # 3) Aborted turns (user interrupted / cancelled)
-                    if current is not None and current.assistant_line is None and _is_turn_aborted(data):
+                    if (
+                        current is not None
+                        and current.assistant_line is None
+                        and _is_turn_aborted(data)
+                    ):
                         current = None
 
             if current is not None and current.assistant_line is not None:
@@ -343,7 +352,9 @@ class CodexTrigger(TurnTrigger):
                 "retry_count": 0,
                 "start_line": start_line,
                 "end_line": end_line,
-                "line_range": f"{start_line}-{end_line}" if start_line != end_line else str(start_line),
+                "line_range": (
+                    f"{start_line}-{end_line}" if start_line != end_line else str(start_line)
+                ),
                 "user_message": t.user_message,
                 "summary_line": t.assistant_line,
                 "summary_message": t.assistant_message,
@@ -360,4 +371,3 @@ class CodexTrigger(TurnTrigger):
             "total_retries": 0,
             "groups": groups,
         }
-

realign/triggers/gemini_trigger.py

@@ -40,15 +40,15 @@ class GeminiTrigger(TurnTrigger):
         """Detect if this is a Gemini session file."""
         try:
             # Check file extension and path
-            if session_file.suffix != '.json':
+            if session_file.suffix != ".json":
                 return None
-            if '.gemini/' not in str(session_file) or '/chats/' not in str(session_file):
+            if ".gemini/" not in str(session_file) or "/chats/" not in str(session_file):
                 return None
 
             # Verify it's a valid Gemini session
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 data = json.load(f)
-                if isinstance(data, dict) and 'messages' in data and 'sessionId' in data:
+                if isinstance(data, dict) and "messages" in data and "sessionId" in data:
                     return "gemini_json"
 
             return None
@@ -63,11 +63,11 @@ class GeminiTrigger(TurnTrigger):
         A turn is complete when there's a user message.
         """
         try:
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 data = json.load(f)
 
-            messages = data.get('messages', [])
-            user_count = sum(1 for m in messages if m.get('type') == 'user')
+            messages = data.get("messages", [])
+            user_count = sum(1 for m in messages if m.get("type") == "user")
 
             return user_count
         except Exception as e:
@@ -86,13 +86,13 @@ class GeminiTrigger(TurnTrigger):
         Returns TurnInfo with user message and metadata.
         """
         try:
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 data = json.load(f)
 
-            messages = data.get('messages', [])
+            messages = data.get("messages", [])
 
             # Find the nth user message
-            user_messages = [(i, m) for i, m in enumerate(messages) if m.get('type') == 'user']
+            user_messages = [(i, m) for i, m in enumerate(messages) if m.get("type") == "user"]
 
             if turn_number < 1 or turn_number > len(user_messages):
                 return None
@@ -101,17 +101,19 @@ class GeminiTrigger(TurnTrigger):
 
             return TurnInfo(
                 turn_number=turn_number,
-                user_message=user_msg.get('content', ''),
+                user_message=user_msg.get("content", ""),
                 start_line=1,  # JSON file doesn't use line numbers
                 end_line=1,
-                timestamp=user_msg.get('timestamp'),
+                timestamp=user_msg.get("timestamp"),
             )
 
         except Exception as e:
             logger.error(f"Error extracting Gemini turn info: {e}")
             return None
 
-    def extract_turn_content(self, session_file: Path, turn_number: int) -> Optional[Dict[str, Any]]:
+    def extract_turn_content(
+        self, session_file: Path, turn_number: int
+    ) -> Optional[Dict[str, Any]]:
         """
         Extract full content for a specific turn (for commit generation).
 
@@ -122,13 +124,13 @@ class GeminiTrigger(TurnTrigger):
         - timestamp: Turn timestamp
         """
         try:
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 data = json.load(f)
 
-            messages = data.get('messages', [])
+            messages = data.get("messages", [])
 
             # Find the nth user message
-            user_messages = [(i, m) for i, m in enumerate(messages) if m.get('type') == 'user']
+            user_messages = [(i, m) for i, m in enumerate(messages) if m.get("type") == "user"]
 
             if turn_number < 1 or turn_number > len(user_messages):
                 return None
@@ -143,22 +145,26 @@ class GeminiTrigger(TurnTrigger):
             gemini_responses = []
             for i in range(user_idx + 1, next_user_idx):
                 msg = messages[i]
-                if msg.get('type') == 'gemini':
-                    gemini_responses.append(msg.get('content', ''))
+                if msg.get("type") == "gemini":
+                    gemini_responses.append(msg.get("content", ""))
 
             # Build turn content
-            turn_content = json.dumps({
-                'turn_number': turn_number,
-                'user': user_msg,
-                'responses': [messages[i] for i in range(user_idx, next_user_idx)]
-            }, ensure_ascii=False, indent=2)
+            turn_content = json.dumps(
+                {
+                    "turn_number": turn_number,
+                    "user": user_msg,
+                    "responses": [messages[i] for i in range(user_idx, next_user_idx)],
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
 
             return {
-                'user_message': user_msg.get('content', ''),
-                'assistant_response': '\n'.join(gemini_responses),
-                'turn_content': turn_content,
-                'timestamp': user_msg.get('timestamp'),
-                'turn_number': turn_number,
+                "user_message": user_msg.get("content", ""),
+                "assistant_response": "\n".join(gemini_responses),
+                "turn_content": turn_content,
+                "timestamp": user_msg.get("timestamp"),
+                "turn_number": turn_number,
             }
 
         except Exception as e:
@@ -174,11 +180,11 @@ class GeminiTrigger(TurnTrigger):
         - total_turns: Total number of turns
         """
         try:
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 data = json.load(f)
 
-            messages = data.get('messages', [])
-            user_messages = [(i, m) for i, m in enumerate(messages) if m.get('type') == 'user']
+            messages = data.get("messages", [])
+            user_messages = [(i, m) for i, m in enumerate(messages) if m.get("type") == "user"]
 
             groups = []
             for turn_idx, (msg_idx, user_msg) in enumerate(user_messages, 1):
@@ -190,25 +196,29 @@ class GeminiTrigger(TurnTrigger):
                 # Collect gemini responses
                 gemini_responses = []
                 for i in range(msg_idx + 1, next_user_idx):
-                    if messages[i].get('type') == 'gemini':
-                        gemini_responses.append(messages[i].get('content', ''))
-
-                groups.append({
-                    'turn_number': turn_idx,
-                    'user_message': user_msg.get('content', ''),
-                    'summary_message': '\n'.join(gemini_responses)[:500] if gemini_responses else '',
-                    'turn_status': 'completed',
-                    'start_line': 1,  # JSON file doesn't use line numbers
-                    'end_line': 1,
-                    'lines': [1],
-                })
+                    if messages[i].get("type") == "gemini":
+                        gemini_responses.append(messages[i].get("content", ""))
+
+                groups.append(
+                    {
+                        "turn_number": turn_idx,
+                        "user_message": user_msg.get("content", ""),
+                        "summary_message": (
+                            "\n".join(gemini_responses)[:500] if gemini_responses else ""
+                        ),
+                        "turn_status": "completed",
+                        "start_line": 1,  # JSON file doesn't use line numbers
+                        "end_line": 1,
+                        "lines": [1],
+                    }
+                )
 
             return {
-                'groups': groups,
-                'total_turns': len(groups),
-                'format': 'gemini_json',
+                "groups": groups,
+                "total_turns": len(groups),
+                "format": "gemini_json",
             }
 
         except Exception as e:
             logger.error(f"Error in get_detailed_analysis for Gemini: {e}")
-            return {'groups': [], 'total_turns': 0, 'format': 'gemini_json'}
+            return {"groups": [], "total_turns": 0, "format": "gemini_json"}

realign/triggers/next_turn_trigger.py

@@ -50,7 +50,9 @@ class NextTurnTrigger(TurnTrigger):
                         continue
 
                     # Claude Code: {"type":"user"|"assistant", "message": {...}}
-                    if obj.get("type") in ("user", "assistant") and isinstance(obj.get("message"), dict):
+                    if obj.get("type") in ("user", "assistant") and isinstance(
+                        obj.get("message"), dict
+                    ):
                         return ClaudeTrigger(self.config)
 
                     # Codex: session_meta/response_item patterns

realign/triggers/registry.py

@@ -64,7 +64,9 @@ class TriggerRegistry:
             return trigger_class(config)
         return None
 
-    def get_trigger_for_type(self, session_type: str, config: Optional[Dict] = None) -> Optional[TurnTrigger]:
+    def get_trigger_for_type(
+        self, session_type: str, config: Optional[Dict] = None
+    ) -> Optional[TurnTrigger]:
         """
         根据session类型获取对应的trigger
 
@@ -99,7 +101,9 @@ class TriggerRegistry:
         """
         return list(self._type_to_trigger.keys())
 
-    def auto_select_trigger(self, session_file: Path, config: Optional[Dict] = None) -> Optional[TurnTrigger]:
+    def auto_select_trigger(
+        self, session_file: Path, config: Optional[Dict] = None
+    ) -> Optional[TurnTrigger]:
         """
         Auto-select an appropriate trigger for the given session file.