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

realign/redactor.py

@@ -14,7 +14,7 @@ from typing import List, Dict, Tuple, Optional
 from .logging_config import setup_logger
 
 # Initialize logger for redactor
-logger = setup_logger('realign.redactor', 'redactor.log')
+logger = setup_logger("realign.redactor", "redactor.log")
 
 
 class SecretMatch:
@@ -44,24 +44,27 @@ def _detect_custom_api_keys(content: str) -> List[SecretMatch]:
     import re
 
     secrets = []
-    lines = content.split('\n')
+    lines = content.split("\n")
 
     # Common API key patterns
     patterns = [
         # OpenAI API keys (sk-, sk-proj-)
-        (r'\bsk-[a-zA-Z0-9]{20,}', 'OpenAI API Key'),
+        (r"\bsk-[a-zA-Z0-9]{20,}", "OpenAI API Key"),
         # Anthropic API keys (sk-ant-api03-...)
-        (r'\bsk-ant-[a-zA-Z0-9\-]{50,}', 'Anthropic API Key'),
+        (r"\bsk-ant-[a-zA-Z0-9\-]{50,}", "Anthropic API Key"),
         # Generic API keys with common prefixes
-        (r'\b(?:api[_-]?key|apikey|api[_-]?secret)[\s:=]+["\']?([a-zA-Z0-9_\-]{32,})["\']?', 'Generic API Key'),
+        (
+            r'\b(?:api[_-]?key|apikey|api[_-]?secret)[\s:=]+["\']?([a-zA-Z0-9_\-]{32,})["\']?',
+            "Generic API Key",
+        ),
         # Bearer tokens
-        (r'\bBearer\s+[a-zA-Z0-9\-._~+/]+=*', 'Bearer Token'),
+        (r"\bBearer\s+[a-zA-Z0-9\-._~+/]+=*", "Bearer Token"),
         # GitHub tokens
-        (r'\bgh[ps]_[a-zA-Z0-9]{36,}', 'GitHub Token'),
+        (r"\bgh[ps]_[a-zA-Z0-9]{36,}", "GitHub Token"),
         # Slack tokens
-        (r'\bxox[baprs]-[a-zA-Z0-9\-]{10,}', 'Slack Token'),
+        (r"\bxox[baprs]-[a-zA-Z0-9\-]{10,}", "Slack Token"),
         # Generic long alphanumeric strings that look like secrets (60+ chars, mixed case)
-        (r'\b[a-zA-Z0-9]{60,}\b', 'Potential Secret (Long String)'),
+        (r"\b[a-zA-Z0-9]{60,}\b", "Potential Secret (Long String)"),
     ]
 
     for line_num, line in enumerate(lines, start=1):
@@ -71,15 +74,24 @@ def _detect_custom_api_keys(content: str) -> List[SecretMatch]:
                 matched_text = match.group(0)
 
                 # Skip if it looks like a UUID (has hyphens in UUID pattern)
-                if re.match(r'^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$', matched_text, re.IGNORECASE):
+                if re.match(
+                    r"^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$",
+                    matched_text,
+                    re.IGNORECASE,
+                ):
                     continue
 
                 # Skip common false positives
-                if matched_text.lower() in ['example', 'placeholder', 'your_api_key_here', 'your-api-key']:
+                if matched_text.lower() in [
+                    "example",
+                    "placeholder",
+                    "your_api_key_here",
+                    "your-api-key",
+                ]:
                     continue
 
                 # For "Potential Secret (Long String)", require mixed case to reduce false positives
-                if secret_type == 'Potential Secret (Long String)':
+                if secret_type == "Potential Secret (Long String)":
                     has_upper = any(c.isupper() for c in matched_text)
                     has_lower = any(c.islower() for c in matched_text)
                     has_digit = any(c.isdigit() for c in matched_text)
@@ -89,13 +101,12 @@ def _detect_custom_api_keys(content: str) -> List[SecretMatch]:
 
                 # Create a hash of the secret for identification
                 import hashlib
+
                 secret_hash = hashlib.sha256(matched_text.encode()).hexdigest()[:16]
 
                 secrets.append(
                     SecretMatch(
-                        secret_type=secret_type,
-                        line_number=line_num,
-                        secret_hash=secret_hash
+                        secret_type=secret_type, line_number=line_num, secret_hash=secret_hash
                     )
                 )
                 logger.debug(f"Custom pattern detected: {secret_type} at line {line_num}")
@@ -118,6 +129,7 @@ def detect_secrets(content: str) -> Tuple[List[SecretMatch], bool]:
     try:
         from detect_secrets import SecretsCollection
         from detect_secrets.settings import default_settings
+
         logger.debug("detect-secrets library loaded successfully")
     except ImportError:
         logger.warning("detect-secrets library not installed")
@@ -133,10 +145,7 @@ def detect_secrets(content: str) -> Tuple[List[SecretMatch], bool]:
     # Create a temporary file for scanning
     try:
         with tempfile.NamedTemporaryFile(
-            mode='w',
-            suffix='.jsonl',
-            delete=False,
-            encoding='utf-8'
+            mode="w", suffix=".jsonl", delete=False, encoding="utf-8"
         ) as f:
             f.write(content)
             temp_path = f.name
@@ -153,15 +162,17 @@ def detect_secrets(content: str) -> Tuple[List[SecretMatch], bool]:
             for secret in secret_list:
                 # Filter out high-entropy detectors that cause false positives with UUIDs
                 # Note: detect-secrets uses "High Entropy" (with space) in type names like "Base64 High Entropy String"
-                if 'High Entropy' in secret.type or 'HighEntropy' in secret.type:
-                    logger.debug(f"Filtering out high-entropy detection: {secret.type} at line {secret.line_number}")
+                if "High Entropy" in secret.type or "HighEntropy" in secret.type:
+                    logger.debug(
+                        f"Filtering out high-entropy detection: {secret.type} at line {secret.line_number}"
+                    )
                     continue
 
                 secrets.append(
                     SecretMatch(
                         secret_type=secret.type,
                         line_number=secret.line_number,
-                        secret_hash=secret.secret_hash
+                        secret_hash=secret.secret_hash,
                     )
                 )
 
@@ -194,7 +205,7 @@ def detect_secrets(content: str) -> Tuple[List[SecretMatch], bool]:
     finally:
         # Clean up temp file
         try:
-            if 'temp_path' in locals():
+            if "temp_path" in locals():
                 os.unlink(temp_path)
                 logger.debug("Temporary file cleaned up")
         except Exception as e:
@@ -206,32 +217,65 @@ def detect_secrets(content: str) -> Tuple[List[SecretMatch], bool]:
 # Fields that should NOT be redacted (metadata and non-sensitive data)
 NON_SENSITIVE_FIELDS = {
     # Message structure
-    'type', 'role', 'stop_reason', 'stop_sequence',
+    "type",
+    "role",
+    "stop_reason",
+    "stop_sequence",
     # Model metadata
-    'model', 'id', 'service_tier',
+    "model",
+    "id",
+    "service_tier",
     # Session metadata
-    'isSidechain', 'userType', 'version', 'gitBranch', 'cwd', 'slug',
+    "isSidechain",
+    "userType",
+    "version",
+    "gitBranch",
+    "cwd",
+    "slug",
     # Identifiers (UUIDs, timestamps - not actual secrets)
-    'parentUuid', 'uuid', 'sessionId', 'requestId', 'timestamp',
+    "parentUuid",
+    "uuid",
+    "sessionId",
+    "requestId",
+    "timestamp",
     # Token usage (not sensitive)
-    'usage', 'input_tokens', 'output_tokens',
-    'cache_read_input_tokens', 'cache_creation_input_tokens',
-    'cache_creation', 'ephemeral_5m_input_tokens', 'ephemeral_1h_input_tokens',
+    "usage",
+    "input_tokens",
+    "output_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens",
+    "cache_creation",
+    "ephemeral_5m_input_tokens",
+    "ephemeral_1h_input_tokens",
     # Tool metadata
-    'tool_use_id', 'name', 'is_error', 'interrupted', 'isImage',
+    "tool_use_id",
+    "name",
+    "is_error",
+    "interrupted",
+    "isImage",
     # File/process info
-    'filenames', 'durationMs', 'numFiles', 'truncated',
-    'stdout', 'stderr', 'returnCodeInterpretation',
+    "filenames",
+    "durationMs",
+    "numFiles",
+    "truncated",
+    "stdout",
+    "stderr",
+    "returnCodeInterpretation",
     # Other metadata
-    'todos', 'oldTodos', 'newTodos', 'toolUseResult',
-    'context_management', 'applied_edits', 'operation',
+    "todos",
+    "oldTodos",
+    "newTodos",
+    "toolUseResult",
+    "context_management",
+    "applied_edits",
+    "operation",
 }
 
 # Fields that contain potentially sensitive content (user input, file contents, etc.)
 SENSITIVE_CONTENT_FIELDS = {
     # These fields may contain actual secrets and should be redacted if secrets detected
-    'content',  # Main content field
-    'text',     # Text content in messages
+    "content",  # Main content field
+    "text",  # Text content in messages
 }
 
 
@@ -252,7 +296,7 @@ def redact_content(content: str, secrets: List[SecretMatch]) -> str:
 
     logger.info(f"Redacting {len(secrets)} secret(s) from content")
 
-    lines = content.split('\n')
+    lines = content.split("\n")
     original_size = len(content)
 
     # Group secrets by line number
@@ -322,27 +366,29 @@ def redact_content(content: str, secrets: List[SecretMatch]) -> str:
             logger.warning(f"Failed to parse line {line_num + 1} as JSON, using regex redaction")
 
             # Try to preserve structure by using regex to find and replace values
-            if ':' in original_line:
+            if ":" in original_line:
                 # Find the value part after the colon, preserving the closing braces/brackets
                 # Match pattern: : "value" or : value, capture trailing punctuation
                 pattern = r':\s*"[^"]*"(\s*[,}\]])'
                 if re.search(pattern, original_line):
                     lines[line_num] = re.sub(
-                        pattern,
-                        rf': "[REDACTED: {", ".join(set(secret_types))}]"\1',
-                        original_line
+                        pattern, rf': "[REDACTED: {", ".join(set(secret_types))}]"\1', original_line
                     )
                 else:
                     # Fallback: replace from colon onwards but keep trailing punctuation
-                    match = re.search(r'(.*?:\s*)(.+?)(\s*[}\]]*\s*)$', original_line)
+                    match = re.search(r"(.*?:\s*)(.+?)(\s*[}\]]*\s*)$", original_line)
                     if match:
-                        lines[line_num] = f'{match.group(1)}"[REDACTED: {", ".join(set(secret_types))}]"{match.group(3)}'
+                        lines[line_num] = (
+                            f'{match.group(1)}"[REDACTED: {", ".join(set(secret_types))}]"{match.group(3)}'
+                        )
                     else:
-                        lines[line_num] = f'{original_line}: "[REDACTED: {", ".join(set(secret_types))}]"'
+                        lines[line_num] = (
+                            f'{original_line}: "[REDACTED: {", ".join(set(secret_types))}]"'
+                        )
             else:
                 lines[line_num] = f"[REDACTED LINE - {', '.join(set(secret_types))}]"
 
-    redacted_content = '\n'.join(lines)
+    redacted_content = "\n".join(lines)
     redacted_size = len(redacted_content)
     logger.info(f"Redaction complete: {original_size} bytes -> {redacted_size} bytes")
 
@@ -350,9 +396,7 @@ def redact_content(content: str, secrets: List[SecretMatch]) -> str:
 
 
 def check_and_redact_session(
-    session_content: str,
-    redact_mode: str = "auto",
-    quiet: bool = False
+    session_content: str, redact_mode: str = "auto", quiet: bool = False
 ) -> Tuple[str, bool, List[SecretMatch]]:
     """
     Check session content for secrets and optionally redact them.
@@ -383,12 +427,9 @@ def check_and_redact_session(
 
     # Print warning about detected secrets
     logger.warning(f"Found {len(secrets)} potential secret(s) in session")
-    
+
     if not quiet:
-        print(
-            f"⚠️  Detected {len(secrets)} potential secret(s) in session:",
-            file=sys.stderr
-        )
+        print(f"⚠️  Detected {len(secrets)} potential secret(s) in session:", file=sys.stderr)
         for secret in secrets:
             print(f"   - {secret.type} at line {secret.line}", file=sys.stderr)
 
@@ -400,17 +441,14 @@ def check_and_redact_session(
     # Auto mode: redact the secrets
     logger.info("Auto mode: redacting secrets")
     redacted_content = redact_content(session_content, secrets)
-    
+
     if not quiet:
         print("   ✅ Secrets have been automatically redacted", file=sys.stderr)
 
     return redacted_content, True, secrets
 
 
-def save_original_session(
-    session_path: Path,
-    repo_root: Path
-) -> Optional[Path]:
+def save_original_session(session_path: Path, repo_root: Path) -> Optional[Path]:
     """
     Save a copy of the original session before redaction.
 
@@ -425,6 +463,7 @@ def save_original_session(
 
     try:
         from realign import get_realign_dir
+
         realign_dir = get_realign_dir(repo_root)
         backup_dir = realign_dir / "sessions-original"
         backup_dir.mkdir(parents=True, exist_ok=True)
@@ -433,6 +472,7 @@ def save_original_session(
 
         # Copy original file to backup
         import shutil
+
         shutil.copy2(session_path, backup_path)
 
         logger.info(f"Backup saved to: {backup_path}")

realign/triggers/__init__.py

@@ -13,13 +13,13 @@ from .next_turn_trigger import NextTurnTrigger
 from .registry import TriggerRegistry, get_global_registry
 
 __all__ = [
-    'TurnTrigger',
-    'TurnInfo',
-    'NextTurnTrigger',
-    'ClaudeTrigger',
-    'CodexTrigger',
-    'GeminiTrigger',
-    'AntigravityTrigger',
-    'TriggerRegistry',
-    'get_global_registry',
+    "TurnTrigger",
+    "TurnInfo",
+    "NextTurnTrigger",
+    "ClaudeTrigger",
+    "CodexTrigger",
+    "GeminiTrigger",
+    "AntigravityTrigger",
+    "TriggerRegistry",
+    "get_global_registry",
 ]

realign/triggers/antigravity_trigger.py

@@ -30,13 +30,13 @@ class AntigravityTrigger(TurnTrigger):
                 if session_file.parent.name == "brain" and "antigravity" in str(session_file):
                     return "antigravity_markdown"
                 return None
-            
+
             # Legacy/Fallback: Check if file
-            if session_file.suffix == '.md':
+            if session_file.suffix == ".md":
                 path_str = str(session_file)
-                if 'gemini' in path_str and 'brain' in path_str:
+                if "gemini" in path_str and "brain" in path_str:
                     return "antigravity_markdown"
-                if '.antigravity' in path_str or 'antigravity' in path_str.lower():
+                if ".antigravity" in path_str or "antigravity" in path_str.lower():
                     return "antigravity_markdown"
             return None
         except Exception:
@@ -46,29 +46,29 @@ class AntigravityTrigger(TurnTrigger):
         """
         Antigravity sessions are effectively "single-turn" persistent states.
         We return 1 if the artifacts exist, 0 otherwise.
-        
+
         The watcher will handle change detection via content hashing or mtime,
         even if this count stays at 1.
-        
+
         Args:
             session_file: Path to brain directory (or file)
-            
+
         Returns:
             int: 1 if artifacts exist, 0 otherwise.
         """
         if not session_file.exists():
             return 0
-            
+
         session_dir = session_file if session_file.is_dir() else session_file.parent
         artifacts = ["task.md", "walkthrough.md", "implementation_plan.md"]
-        
+
         has_artifacts = False
         for filename in artifacts:
             path = session_dir / filename
             if path.exists():
                 has_artifacts = True
                 break
-                
+
         return 1 if has_artifacts else 0
 
     def extract_turn_info(self, session_file: Path, turn_number: int) -> Optional[TurnInfo]:
@@ -81,14 +81,14 @@ class AntigravityTrigger(TurnTrigger):
 
         content_parts = []
         artifacts = ["task.md", "walkthrough.md", "implementation_plan.md"]
-        
+
         # Aggregate content
         for filename in artifacts:
             path = session_dir / filename
             if path.exists():
-                text = path.read_text(encoding='utf-8')
+                text = path.read_text(encoding="utf-8")
                 content_parts.append(f"--- {filename} ---\n{text}")
-        
+
         full_content = "\n\n".join(content_parts)
         if not full_content:
             return None
@@ -101,7 +101,7 @@ class AntigravityTrigger(TurnTrigger):
             user_message="",  # Empty - full content used elsewhere for summary generation
             start_line=1,
             end_line=len(full_content.splitlines()) if full_content else 0,
-            timestamp=timestamp
+            timestamp=timestamp,
         )
 
     def is_turn_complete(self, session_file: Path, turn_number: int) -> bool:
@@ -114,25 +114,27 @@ class AntigravityTrigger(TurnTrigger):
         Since we treat the state as a single accumulated turn, we return one turn group.
         """
         current_turn = self.count_complete_turns(session_file)
-        
+
         groups = []
         # Return a single entry representing the current state
         if current_turn > 0:
             info = self.extract_turn_info(session_file, 1)
             if info:
-                groups.append({
-                    'turn_number': 1,
-                    'user_message': info.user_message,
-                    'summary_message': 'Antigravity Session State',
-                    'turn_status': 'completed',
-                    'start_line': info.start_line,
-                    'end_line': info.end_line,
-                    'timestamp': info.timestamp,
-                })
+                groups.append(
+                    {
+                        "turn_number": 1,
+                        "user_message": info.user_message,
+                        "summary_message": "Antigravity Session State",
+                        "turn_status": "completed",
+                        "start_line": info.start_line,
+                        "end_line": info.end_line,
+                        "timestamp": info.timestamp,
+                    }
+                )
 
         return {
-            'groups': groups,
-            'total_turns': 1 if current_turn > 0 else 0, # Conceptually one continuous session
-            'latest_turn_id': 1 if current_turn > 0 else 0,
-            'format': 'antigravity_markdown',
+            "groups": groups,
+            "total_turns": 1 if current_turn > 0 else 0,  # Conceptually one continuous session
+            "latest_turn_id": 1 if current_turn > 0 else 0,
+            "format": "antigravity_markdown",
         }

realign/triggers/base.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
 @dataclass
 class TurnInfo:
     """单个对话轮次的信息"""
+
     turn_number: int  # 轮次编号（1-based）
     user_message: str  # 用户消息内容
     start_line: int  # 在session文件中的起始行
@@ -126,7 +127,7 @@ class TurnTrigger(ABC):
         import json
 
         try:
-            with open(session_file, 'r', encoding='utf-8') as f:
+            with open(session_file, "r", encoding="utf-8") as f:
                 first_line = f.readline().strip()
                 if not first_line:
                     return None
@@ -134,11 +135,11 @@ class TurnTrigger(ABC):
                 data = json.loads(first_line)
 
                 # 检测Claude Code格式
-                if 'version' in data and data['version'].startswith('2.0'):
+                if "version" in data and data["version"].startswith("2.0"):
                     return f"claude_code_{data['version']}"
 
                 # 检测Codex格式
-                if data.get('type') == 'event_msg' and 'payload' in data:
+                if data.get("type") == "event_msg" and "payload" in data:
                     return "codex"
 
                 return None