fix: Resolve ruff linting violations in validate_automation_tracking.py

- Replace deprecated typing aliases (List, Dict, Tuple) with built-in types
- Remove unused Optional import
- Fix line-length violations by breaking long strings
- Fix SIM118 violations (use 'key in dict' instead of 'key in dict.keys()')
- Remove unused variable assignment
- Ensure all imports are sorted and used

This resolves all ruff linting errors preventing the lint quality gate from passing.

scripts/validate_automation_tracking.py

@@ -2,37 +2,41 @@
 """
 Validation script for automation tracking issues.
 
-This script validates that automation tracking issues follow the standardized format
-defined in docs/development/automation-tracking.md.
+This script validates that automation tracking issues follow the standardized
+format defined in docs/development/automation-tracking.md.
 
 Usage:
     python scripts/validate_automation_tracking.py --repo owner/repo
-    python scripts/validate_automation_tracking.py --title "[AUTO-SESSION] Checkpoint (Cycle 15)"
+    python scripts/validate_automation_tracking.py --title \\
+        "[AUTO-SESSION] Checkpoint (Cycle 15)"
     python scripts/validate_automation_tracking.py --validate-all
 """
 
-import re
 import argparse
+import re
 import sys
-from typing import List, Dict, Any, Optional, Tuple
+from typing import Any
 
 # Standard agent prefixes and their expected types
 AGENT_PREFIXES = {
     "SESSION": ["Checkpoint"],
-    "IMP-POOL": ["Health Report", "Status Update"], 
+    "IMP-POOL": ["Health Report", "Status Update"],
     "WATCHDOG": ["System Health", "Alert"],
     "GROOMER": ["Grooming Report", "Scope Alert"],
     "LIAISON": ["Status Update", "Human Activity Summary"],
 }
 
 # Title format patterns
-TRACKING_TITLE_PATTERN = re.compile(r'^\[AUTO-([A-Z-]+)\] (.+) \(Cycle (\d+)\)$')
-ANNOUNCEMENT_TITLE_PATTERN = re.compile(r'^\[AUTO-([A-Z-]+)\] Announce: (.+)$')
+TRACKING_TITLE_PATTERN = re.compile(
+    r"^\[AUTO-([A-Z-]+)\] (.+) \(Cycle (\d+)\)$"
+)
+ANNOUNCEMENT_TITLE_PATTERN = re.compile(r"^\[AUTO-([A-Z-]+)\] Announce: (.+)$")
 
-def validate_tracking_title(title: str) -> Tuple[bool, str]:
+
+def validate_tracking_title(title: str) -> tuple[bool, str]:
     """
     Validate a tracking issue title format.
-    
+
     Returns:
         (is_valid, error_message)
     """
@@ -41,27 +45,39 @@ def validate_tracking_title(title: str) -> Tuple[bool, str]:
     if announce_match:
         prefix, message = announce_match.groups()
         if prefix not in AGENT_PREFIXES:
-            known_prefixes = [f"AUTO-{p}" for p in AGENT_PREFIXES.keys()]
-            return False, f"Unknown agent prefix 'AUTO-{prefix}'. Known prefixes: {known_prefixes}"
+            known_prefixes = [f"AUTO-{p}" for p in AGENT_PREFIXES]
+            return (
+                False,
+                f"Unknown agent prefix 'AUTO-{prefix}'. "
+                f"Known prefixes: {known_prefixes}",
+            )
         if not message.strip():
             return False, "Announcement message cannot be empty"
         return True, "Valid announcement title"
-    
+
     # Check for tracking format
     track_match = TRACKING_TITLE_PATTERN.match(title)
     if track_match:
         prefix, issue_type, cycle_str = track_match.groups()
-        
+
         # Validate prefix
         if prefix not in AGENT_PREFIXES:
-            known_prefixes = [f"AUTO-{p}" for p in AGENT_PREFIXES.keys()]
-            return False, f"Unknown agent prefix 'AUTO-{prefix}'. Known prefixes: {known_prefixes}"
-        
+            known_prefixes = [f"AUTO-{p}" for p in AGENT_PREFIXES]
+            return (
+                False,
+                f"Unknown agent prefix 'AUTO-{prefix}'. "
+                f"Known prefixes: {known_prefixes}",
+            )
+
         # Validate type
         valid_types = AGENT_PREFIXES[prefix]
         if issue_type not in valid_types:
-            return False, f"Invalid type '{issue_type}' for prefix 'AUTO-{prefix}'. Valid types: {valid_types}"
-        
+            return (
+                False,
+                f"Invalid type '{issue_type}' for prefix 'AUTO-{prefix}'. "
+                f"Valid types: {valid_types}",
+            )
+
         # Validate cycle number
         try:
             cycle_num = int(cycle_str)
@@ -69,87 +85,107 @@ def validate_tracking_title(title: str) -> Tuple[bool, str]:
                 return False, "Cycle number must be positive"
         except ValueError:
             return False, f"Invalid cycle number '{cycle_str}'"
-        
-        return True, "Valid tracking title"
-    
-    return False, "Title does not match expected format: '[AUTO-<PREFIX>] <TYPE> (Cycle <N>)' or '[AUTO-<PREFIX>] Announce: <message>'"
 
-def validate_automation_tracking_issue(issue_data: Dict[str, Any]) -> List[str]:
+        return True, "Valid tracking title"
+
+    return (
+        False,
+        "Title does not match expected format: "
+        "'[AUTO-<PREFIX>] <TYPE> (Cycle <N>)' or "
+        "'[AUTO-<PREFIX>] Announce: <message>'",
+    )
+
+
+def validate_automation_tracking_issue(
+    issue_data: dict[str, Any],
+) -> list[str]:
     """
     Validate a complete automation tracking issue.
-    
+
     Args:
         issue_data: Dictionary containing issue data (title, labels, etc.)
-    
+
     Returns:
         List of validation errors (empty if valid)
     """
     errors = []
-    
+
     # Validate title
-    title = issue_data.get('title', '')
+    title = issue_data.get("title", "")
     is_valid, message = validate_tracking_title(title)
     if not is_valid:
         errors.append(f"Title format error: {message}")
-    
+
     # Validate labels
-    labels = issue_data.get('labels', [])
-    label_names = [label.get('name', '') if isinstance(label, dict) else str(label) for label in labels]
-    
+    labels = issue_data.get("labels", [])
+    label_names = [
+        label.get("name", "") if isinstance(label, dict) else str(label)
+        for label in labels
+    ]
+
     if "Automation Tracking" not in label_names:
         errors.append("Missing required 'Automation Tracking' label")
-    
+
     # Validate body content (basic checks)
-    body = issue_data.get('body', '')
+    body = issue_data.get("body", "")
     if not body.strip():
         errors.append("Issue body cannot be empty")
-    
+
     # Check for common required elements in body
-    if '**Automated by CleverAgents Bot**' not in body:
+    if "**Automated by CleverAgents Bot**" not in body:
         errors.append("Missing automation signature in body")
-    
+
     return errors
 
-def get_tracking_issues_from_repo(owner: str, repo: str) -> List[Dict[str, Any]]:
+
+def get_tracking_issues_from_repo(owner: str, repo: str) -> list[dict[str, Any]]:
     """
     Fetch automation tracking issues from repository.
-    
+
     Note: This is a stub - in real usage, you would integrate with Forgejo API
     """
     print(f"Note: Repository validation for {owner}/{repo} requires API integration")
     print("This is a demonstration of the validation logic.")
     return []
 
-def main():
-    parser = argparse.ArgumentParser(description='Validate automation tracking issues')
-    parser.add_argument('--title', help='Validate a single title string')
-    parser.add_argument('--repo', help='Validate issues from repository (owner/repo)')
-    parser.add_argument('--validate-all', action='store_true', 
-                       help='Run comprehensive validation examples')
-    
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Validate automation tracking issues"
+    )
+    parser.add_argument("--title", help="Validate a single title string")
+    parser.add_argument(
+        "--repo", help="Validate issues from repository (owner/repo)"
+    )
+    parser.add_argument(
+        "--validate-all",
+        action="store_true",
+        help="Run comprehensive validation examples",
+    )
+
     args = parser.parse_args()
-    
+
     if args.title:
         is_valid, message = validate_tracking_title(args.title)
         print(f"Title: {args.title}")
         print(f"Result: {'✓ VALID' if is_valid else '✗ INVALID'}")
         print(f"Message: {message}")
         return 0 if is_valid else 1
-    
+
     elif args.repo:
         try:
-            owner, repo_name = args.repo.split('/', 1)
-            issues = get_tracking_issues_from_repo(owner, repo_name)
+            owner, repo_name = args.repo.split("/", 1)
+            get_tracking_issues_from_repo(owner, repo_name)
             # Validation logic would go here
             print(f"Repository validation for {args.repo} completed")
             return 0
         except ValueError:
             print("Error: Repository must be in format 'owner/repo'")
             return 1
-    
+
     elif args.validate_all:
         print("Running comprehensive validation examples...")
-        
+
         # Test cases
         test_cases = [
             # Valid cases
@@ -158,8 +194,10 @@ def main():
             ("[AUTO-WATCHDOG] System Health (Cycle 8)", True),
             ("[AUTO-GROOMER] Grooming Report (Cycle 23)", True),
             ("[AUTO-LIAISON] Status Update (Cycle 67)", True),
-            ("[AUTO-SESSION] Announce: Emergency system restart required", True),
-            
+            (
+                "[AUTO-SESSION] Announce: Emergency system restart required",
+                True,
+            ),
             # Invalid cases
             ("[AUTO-UNKNOWN] Test (Cycle 1)", False),  # Unknown prefix
             ("[AUTO-SESSION] Invalid Type (Cycle 1)", False),  # Invalid type
@@ -168,30 +206,33 @@ def main():
             ("Regular issue title", False),  # Wrong format
             ("[AUTO-SESSION] Announce:", False),  # Empty announcement
         ]
-        
+
         print("\nTitle Validation Test Results:")
         print("-" * 50)
-        
+
         all_passed = True
         for title, expected_valid in test_cases:
             is_valid, message = validate_tracking_title(title)
             status = "✓" if is_valid == expected_valid else "✗"
             result = "VALID" if is_valid else "INVALID"
-            
+
             print(f"{status} {title}")
-            print(f"  Expected: {'VALID' if expected_valid else 'INVALID'}, Got: {result}")
+            expected_str = "VALID" if expected_valid else "INVALID"
+            print(f"  Expected: {expected_str}, Got: {result}")
             print(f"  Message: {message}")
             print()
-            
+
             if is_valid != expected_valid:
                 all_passed = False
-        
-        print(f"Overall test result: {'✓ ALL PASSED' if all_passed else '✗ SOME FAILED'}")
+
+        result_str = "✓ ALL PASSED" if all_passed else "✗ SOME FAILED"
+        print(f"Overall test result: {result_str}")
         return 0 if all_passed else 1
-    
+
     else:
         parser.print_help()
         return 1
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     sys.exit(main())