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

realign/db/migration.py

@@ -33,58 +33,58 @@ def parse_commit_message(message: str) -> Dict[str, Any]:
         Dictionary with extracted fields
     """
     result = {
-        'llm_title': '',
-        'llm_description': '',
-        'session_id': '',
-        'turn_number': 0,
-        'user_message': '',
+        "llm_title": "",
+        "llm_description": "",
+        "session_id": "",
+        "turn_number": 0,
+        "user_message": "",
     }
 
     if not message:
         return result
 
-    lines = message.strip().split('\n')
+    lines = message.strip().split("\n")
     if not lines:
         return result
 
     # First line is the title
-    result['llm_title'] = lines[0].strip()
+    result["llm_title"] = lines[0].strip()
 
     # Find the --- separator
     separator_idx = -1
     for i, line in enumerate(lines):
-        if line.strip() == '---':
+        if line.strip() == "---":
             separator_idx = i
             break
 
     if separator_idx > 1:
         # Description is between title and separator
         description_lines = lines[1:separator_idx]
-        result['llm_description'] = '\n'.join(description_lines).strip()
+        result["llm_description"] = "\n".join(description_lines).strip()
 
     # Parse metadata after separator
     if separator_idx >= 0:
-        metadata_lines = lines[separator_idx + 1:]
+        metadata_lines = lines[separator_idx + 1 :]
         for line in metadata_lines:
             line = line.strip()
 
             # Parse "Session: xxx | Turn: #N"
-            session_match = re.match(r'Session:\s*(.+?)\s*\|\s*Turn:\s*#?(\d+)', line)
+            session_match = re.match(r"Session:\s*(.+?)\s*\|\s*Turn:\s*#?(\d+)", line)
             if session_match:
-                result['session_id'] = session_match.group(1).strip()
-                result['turn_number'] = int(session_match.group(2))
+                result["session_id"] = session_match.group(1).strip()
+                result["turn_number"] = int(session_match.group(2))
                 continue
 
             # Parse "Request: xxx"
-            if line.startswith('Request:'):
-                result['user_message'] = line[8:].strip()
+            if line.startswith("Request:"):
+                result["user_message"] = line[8:].strip()
 
     # Fallback: try legacy format "Session xxx, Turn N: ..."
-    if not result['session_id'] and result['llm_title']:
-        legacy_match = re.match(r'Session\s+(\S+),\s*Turn\s+(\d+):', result['llm_title'])
+    if not result["session_id"] and result["llm_title"]:
+        legacy_match = re.match(r"Session\s+(\S+),\s*Turn\s+(\d+):", result["llm_title"])
         if legacy_match:
-            result['session_id'] = legacy_match.group(1)
-            result['turn_number'] = int(legacy_match.group(2))
+            result["session_id"] = legacy_match.group(1)
+            result["turn_number"] = int(legacy_match.group(2))
 
     return result
 
@@ -99,18 +99,18 @@ def get_all_commits(realign_dir: Path) -> List[Dict[str, Any]]:
     Returns:
         List of commit dictionaries with hash, timestamp, and message
     """
-    if not (realign_dir / '.git').exists():
+    if not (realign_dir / ".git").exists():
         logger.warning(f"No git repo found at {realign_dir}")
         return []
 
     try:
         # Use record separator for robust parsing
-        rs = '\x1e'
-        us = '\x1f'
-        fmt = f'%H{us}%at{us}%B{rs}'
+        rs = "\x1e"
+        us = "\x1f"
+        fmt = f"%H{us}%at{us}%B{rs}"
 
         result = subprocess.run(
-            ['git', 'log', '--reverse', f'--pretty=format:{fmt}'],
+            ["git", "log", "--reverse", f"--pretty=format:{fmt}"],
             cwd=realign_dir,
             capture_output=True,
             text=True,
@@ -136,14 +136,16 @@ def get_all_commits(realign_dir: Path) -> List[Dict[str, Any]]:
                 continue
 
             # Skip initial commit
-            if message.lower().startswith('initial commit'):
+            if message.lower().startswith("initial commit"):
                 continue
 
-            commits.append({
-                'hash': commit_hash,
-                'timestamp': datetime.fromtimestamp(int(timestamp)),
-                'message': message,
-            })
+            commits.append(
+                {
+                    "hash": commit_hash,
+                    "timestamp": datetime.fromtimestamp(int(timestamp)),
+                    "message": message,
+                }
+            )
 
         return commits
 
@@ -185,7 +187,7 @@ def migrate_project(
 
     if dry_run:
         for commit in commits:
-            parsed = parse_commit_message(commit['message'])
+            parsed = parse_commit_message(commit["message"])
             logger.info(f"Would migrate: {commit['hash'][:8]} - {parsed['llm_title'][:50]}")
         return (len(commits), 0)
 
@@ -198,8 +200,8 @@ def migrate_project(
     # Group commits by session
     session_commits: Dict[str, List[Dict]] = {}
     for commit in commits:
-        parsed = parse_commit_message(commit['message'])
-        session_id = parsed.get('session_id', '')
+        parsed = parse_commit_message(commit["message"])
+        session_id = parsed.get("session_id", "")
 
         if not session_id:
             logger.debug(f"Skipping commit without session: {commit['hash'][:8]}")
@@ -208,7 +210,7 @@ def migrate_project(
 
         if session_id not in session_commits:
             session_commits[session_id] = []
-        session_commits[session_id].append({**commit, 'parsed': parsed})
+        session_commits[session_id].append({**commit, "parsed": parsed})
 
     # Process each session
     for session_id, session_data in session_commits.items():
@@ -220,22 +222,22 @@ def migrate_project(
         session_rec = db.get_or_create_session(
             session_id=session_id,
             session_file_path=Path(f"~/.claude/projects/{project_path.name}/{session_id}.jsonl"),
-            session_type='claude',  # Default assumption
-            started_at=first_commit['timestamp'],
+            session_type="claude",  # Default assumption
+            started_at=first_commit["timestamp"],
             workspace_path=str(project_path),
         )
 
         # Create turn records
         for commit_data in session_data:
-            parsed = commit_data['parsed']
-            turn_number = parsed.get('turn_number', 0)
+            parsed = commit_data["parsed"]
+            turn_number = parsed.get("turn_number", 0)
 
             if turn_number == 0:
                 skipped += 1
                 continue
 
             # Generate content hash from commit message (since we don't have original content)
-            content_hash = hashlib.md5(commit_data['message'].encode()).hexdigest()
+            content_hash = hashlib.md5(commit_data["message"].encode()).hexdigest()
 
             # Check if already migrated
             existing = db.get_turn_by_hash(session_id, content_hash)
@@ -246,26 +248,27 @@ def migrate_project(
 
             try:
                 import uuid
+
                 turn = TurnRecord(
                     id=str(uuid.uuid4()),
                     session_id=session_id,
                     turn_number=turn_number,
-                    user_message=parsed.get('user_message', ''),
-                    assistant_summary=parsed.get('llm_description', ''),
-                    turn_status='completed',
-                    llm_title=parsed.get('llm_title', 'Migrated commit'),
-                    llm_description=parsed.get('llm_description', ''),
-                    model_name='migrated',
-                    if_last_task='unknown',
-                    satisfaction='unknown',
+                    user_message=parsed.get("user_message", ""),
+                    assistant_summary=parsed.get("llm_description", ""),
+                    turn_status="completed",
+                    llm_title=parsed.get("llm_title", "Migrated commit"),
+                    llm_description=parsed.get("llm_description", ""),
+                    model_name="migrated",
+                    if_last_task="unknown",
+                    satisfaction="unknown",
                     content_hash=content_hash,
-                    timestamp=commit_data['timestamp'],
+                    timestamp=commit_data["timestamp"],
                     created_at=datetime.now(),
-                    git_commit_hash=commit_data['hash'],
+                    git_commit_hash=commit_data["hash"],
                 )
 
                 # We don't have the original turn content, so store the commit message
-                db.create_turn(turn, content=commit_data['message'])
+                db.create_turn(turn, content=commit_data["message"])
                 migrated += 1
                 logger.debug(f"Migrated: {session_id} #{turn_number}")
 
@@ -273,7 +276,9 @@ def migrate_project(
                 logger.error(f"Failed to migrate turn: {e}")
                 skipped += 1
 
-    logger.info(f"Migration complete for {project_path.name}: {migrated} migrated, {skipped} skipped")
+    logger.info(
+        f"Migration complete for {project_path.name}: {migrated} migrated, {skipped} skipped"
+    )
     return (migrated, skipped)
 
 
@@ -296,7 +301,7 @@ def migrate_all_projects(
     if db is None:
         db = get_database()
 
-    aline_base = Path.home() / '.aline'
+    aline_base = Path.home() / ".aline"
     if not aline_base.exists():
         logger.info("No .aline directory found")
         return {}
@@ -307,9 +312,9 @@ def migrate_all_projects(
     for item in aline_base.iterdir():
         if not item.is_dir():
             continue
-        if item.name in ('db', 'logs', 'cache'):
+        if item.name in ("db", "logs", "cache"):
             continue
-        if not (item / '.git').exists():
+        if not (item / ".git").exists():
             continue
 
         # This is a project's .aline directory
@@ -323,7 +328,7 @@ def migrate_all_projects(
 
         # Create a placeholder project path
         # The real path should be stored in project metadata
-        project_path = Path.home() / 'Projects' / project_name
+        project_path = Path.home() / "Projects" / project_name
 
         # Use the .aline directory directly for migration
         migrated, skipped = migrate_project_from_realign_dir(item, db, dry_run)
@@ -348,7 +353,7 @@ def migrate_project_from_realign_dir(
     Returns:
         Tuple of (migrated_count, skipped_count)
     """
-    if not (realign_dir / '.git').exists():
+    if not (realign_dir / ".git").exists():
         logger.warning(f"No git repo at {realign_dir}")
         return (0, 0)
 
@@ -360,23 +365,23 @@ def migrate_project_from_realign_dir(
 
     if dry_run:
         for commit in commits:
-            parsed = parse_commit_message(commit['message'])
-            title = parsed.get('llm_title', 'No title')[:50]
+            parsed = parse_commit_message(commit["message"])
+            title = parsed.get("llm_title", "No title")[:50]
             logger.info(f"  Would migrate: {commit['hash'][:8]} - {title}")
         return (len(commits), 0)
 
     # Get or create project (use realign_dir name as project name)
     project_name = realign_dir.name
-    project_path = Path.home() / 'Projects' / project_name  # Placeholder
+    project_path = Path.home() / "Projects" / project_name  # Placeholder
     project_rec = db.get_or_create_project(project_path, name=project_name)
 
     migrated = 0
     skipped = 0
 
     for commit in commits:
-        parsed = parse_commit_message(commit['message'])
-        session_id = parsed.get('session_id', '')
-        turn_number = parsed.get('turn_number', 0)
+        parsed = parse_commit_message(commit["message"])
+        session_id = parsed.get("session_id", "")
+        turn_number = parsed.get("turn_number", 0)
 
         if not session_id or turn_number == 0:
             skipped += 1
@@ -386,12 +391,12 @@ def migrate_project_from_realign_dir(
         session_rec = db.get_or_create_session(
             session_id=session_id,
             session_file_path=Path(f"migrated/{session_id}.jsonl"),
-            session_type='claude',
-            started_at=commit['timestamp'],
+            session_type="claude",
+            started_at=commit["timestamp"],
             workspace_path=str(project_path),
         )
 
-        content_hash = hashlib.md5(commit['message'].encode()).hexdigest()
+        content_hash = hashlib.md5(commit["message"].encode()).hexdigest()
 
         if db.get_turn_by_hash(session_id, content_hash):
             skipped += 1
@@ -399,25 +404,26 @@ def migrate_project_from_realign_dir(
 
         try:
             import uuid
+
             turn = TurnRecord(
                 id=str(uuid.uuid4()),
                 session_id=session_id,
                 turn_number=turn_number,
-                user_message=parsed.get('user_message', ''),
-                assistant_summary=parsed.get('llm_description', ''),
-                turn_status='completed',
-                llm_title=parsed.get('llm_title', 'Migrated'),
-                llm_description=parsed.get('llm_description', ''),
-                model_name='migrated',
-                if_last_task='unknown',
-                satisfaction='unknown',
+                user_message=parsed.get("user_message", ""),
+                assistant_summary=parsed.get("llm_description", ""),
+                turn_status="completed",
+                llm_title=parsed.get("llm_title", "Migrated"),
+                llm_description=parsed.get("llm_description", ""),
+                model_name="migrated",
+                if_last_task="unknown",
+                satisfaction="unknown",
                 content_hash=content_hash,
-                timestamp=commit['timestamp'],
+                timestamp=commit["timestamp"],
                 created_at=datetime.now(),
-                git_commit_hash=commit['hash'],
+                git_commit_hash=commit["hash"],
             )
 
-            db.create_turn(turn, content=commit['message'])
+            db.create_turn(turn, content=commit["message"])
             migrated += 1
 
         except Exception as e:

realign/db/schema.py

@@ -444,15 +444,11 @@ def get_migration_scripts(from_version: int, to_version: int) -> list:
 
     if from_version < 12 and to_version >= 12:
         # V12: Add total_turns_mtime for lazy cache validation
-        scripts.append(
-            "ALTER TABLE sessions ADD COLUMN total_turns_mtime REAL;"
-        )
+        scripts.append("ALTER TABLE sessions ADD COLUMN total_turns_mtime REAL;")
 
     if from_version < 13 and to_version >= 13:
         # V13: Temporary turn title
-        scripts.append(
-            "ALTER TABLE turns ADD COLUMN temp_title TEXT;"
-        )
+        scripts.append("ALTER TABLE turns ADD COLUMN temp_title TEXT;")
 
     if from_version < 14 and to_version >= 14:
         scripts.extend(MIGRATION_V13_TO_V14)

realign/db/sqlite_db.py

@@ -206,17 +206,13 @@ class SQLiteDatabase(DatabaseInterface):
                 )
             # For existing databases, run migrations
             elif current_version < SCHEMA_VERSION:
-                migration_scripts = get_migration_scripts(
-                    current_version, SCHEMA_VERSION
-                )
+                migration_scripts = get_migration_scripts(current_version, SCHEMA_VERSION)
                 for script in migration_scripts:
                     try:
                         cursor.execute(script)
                     except sqlite3.OperationalError as e:
                         # Some migrations may fail if column already exists, etc.
-                        logger.debug(
-                            f"Migration script skipped (may already be applied): {e}"
-                        )
+                        logger.debug(f"Migration script skipped (may already be applied): {e}")
 
                 cursor.execute(
                     "INSERT INTO schema_version (version, description) VALUES (?, ?)",
@@ -256,9 +252,7 @@ class SQLiteDatabase(DatabaseInterface):
         """Public wrapper for fetching a project by path."""
         return self._get_project_by_path(path)
 
-    def get_or_create_project(
-        self, path: Path, name: Optional[str] = None
-    ) -> ProjectRecord:
+    def get_or_create_project(self, path: Path, name: Optional[str] = None) -> ProjectRecord:
         """Get existing project or create new one."""
         conn = self._get_connection()
         cursor = conn.cursor()
@@ -353,9 +347,7 @@ class SQLiteDatabase(DatabaseInterface):
             creator_id=config.user_id,
         )
 
-    def update_session_activity(
-        self, session_id: str, last_activity_at: datetime
-    ) -> None:
+    def update_session_activity(self, session_id: str, last_activity_at: datetime) -> None:
         """Update last activity timestamp."""
         conn = self._get_connection()
         conn.execute(
@@ -552,9 +544,7 @@ class SQLiteDatabase(DatabaseInterface):
             return row[0]
         return None
 
-    def get_turn_by_hash(
-        self, session_id: str, content_hash: str
-    ) -> Optional[TurnRecord]:
+    def get_turn_by_hash(self, session_id: str, content_hash: str) -> Optional[TurnRecord]:
         """Check for existing turn by content hash."""
         conn = self._get_connection()
         cursor = conn.cursor()
@@ -569,9 +559,7 @@ class SQLiteDatabase(DatabaseInterface):
             return self._row_to_turn(row)
         return None
 
-    def get_turn_by_number(
-        self, session_id: str, turn_number: int
-    ) -> Optional[TurnRecord]:
+    def get_turn_by_number(self, session_id: str, turn_number: int) -> Optional[TurnRecord]:
         """Get a turn by session_id and turn_number."""
         conn = self._get_connection()
         cursor = conn.cursor()
@@ -625,10 +613,7 @@ class SQLiteDatabase(DatabaseInterface):
             session_ids,
         )
 
-        return {
-            row[0]: int(row[1]) if row[1] is not None else 0
-            for row in cursor.fetchall()
-        }
+        return {row[0]: int(row[1]) if row[1] is not None else 0 for row in cursor.fetchall()}
 
     def get_committed_turn_numbers(self, session_id: str) -> set[int]:
         """Get the set of turn numbers that have been committed for a session."""
@@ -775,9 +760,7 @@ class SQLiteDatabase(DatabaseInterface):
         value = row[0]
         return int(value) if value is not None else 0
 
-    def try_acquire_lock(
-        self, lock_key: str, *, owner: str, ttl_seconds: float
-    ) -> bool:
+    def try_acquire_lock(self, lock_key: str, *, owner: str, ttl_seconds: float) -> bool:
         """
         Try to acquire a cross-process lease lock.
 
@@ -936,7 +919,16 @@ class SQLiteDatabase(DatabaseInterface):
                         ELSE jobs.next_run_at
                     END
                 """,
-                (job_id, kind, dedupe_key, payload_json, int(priority), run_at, requeue_done_int, requeue_done_int),
+                (
+                    job_id,
+                    kind,
+                    dedupe_key,
+                    payload_json,
+                    int(priority),
+                    run_at,
+                    requeue_done_int,
+                    requeue_done_int,
+                ),
             )
             conn.commit()
 
@@ -1318,9 +1310,7 @@ class SQLiteDatabase(DatabaseInterface):
         conn = self._get_connection()
         counts: Dict[str, int] = {}
         try:
-            rows = conn.execute(
-                "SELECT status, COUNT(*) AS c FROM jobs GROUP BY status"
-            ).fetchall()
+            rows = conn.execute("SELECT status, COUNT(*) AS c FROM jobs GROUP BY status").fetchall()
             for row in rows:
                 counts[str(row[0])] = int(row[1])
             return counts
@@ -1540,9 +1530,7 @@ class SQLiteDatabase(DatabaseInterface):
                 )
 
                 # Sync Commits (Delete all existing links and re-insert)
-                conn.execute(
-                    "DELETE FROM event_commits WHERE event_id = ?", (event.id,)
-                )
+                conn.execute("DELETE FROM event_commits WHERE event_id = ?", (event.id,))
 
                 if event.commit_hashes:
                     conn.executemany(
@@ -1758,9 +1746,7 @@ class SQLiteDatabase(DatabaseInterface):
         conn = self._get_connection()
 
         # Convert preset_questions list to JSON string
-        preset_questions_json = (
-            json.dumps(preset_questions) if preset_questions else None
-        )
+        preset_questions_json = json.dumps(preset_questions) if preset_questions else None
 
         share_expiry_str = (
             share_expiry_at.isoformat() if isinstance(share_expiry_at, datetime) else None
@@ -1964,9 +1950,7 @@ class SQLiteDatabase(DatabaseInterface):
                     "title": row["llm_title"],
                     "summary": row["assistant_summary"],
                     "content": content,
-                    "content_preview": content[:200] + "..."
-                    if len(content) > 200
-                    else content,
+                    "content_preview": content[:200] + "..." if len(content) > 200 else content,
                 }
             )
         return results
@@ -2197,9 +2181,7 @@ class SQLiteDatabase(DatabaseInterface):
             # For now, let's just do a separate query.
             conn = self._get_connection()
             cur = conn.cursor()
-            cur.execute(
-                "SELECT commit_hash FROM event_commits WHERE event_id = ?", (row["id"],)
-            )
+            cur.execute("SELECT commit_hash FROM event_commits WHERE event_id = ?", (row["id"],))
             commits = [r[0] for r in cur.fetchall()]
         except Exception:
             pass  # Indicate no commits or error

realign/events/__init__.py

@@ -1,2 +1 @@
 """Event maintenance utilities."""
-

realign/events/event_summarizer.py

@@ -31,6 +31,7 @@ def schedule_event_summary_update(db: SQLiteDatabase, event_id: str) -> None:
         db: Database instance
         event_id: ID of the event to update
     """
+
     def do_update():
         _update_event_summary(db, event_id)
 
@@ -122,10 +123,17 @@ def _get_event_summary_prompt() -> str:
                 logger.debug(f"Loaded user-customized event summary prompt from {user_prompt_path}")
                 return text
     except Exception:
-        logger.debug("Failed to load user-customized event summary prompt, falling back", exc_info=True)
+        logger.debug(
+            "Failed to load user-customized event summary prompt, falling back", exc_info=True
+        )
 
     # Fall back to built-in prompt (tools/commit_message_prompts/event_summary.md)
-    candidate = Path(__file__).resolve().parents[2] / "tools" / "commit_message_prompts" / "event_summary.md"
+    candidate = (
+        Path(__file__).resolve().parents[2]
+        / "tools"
+        / "commit_message_prompts"
+        / "event_summary.md"
+    )
     try:
         if candidate.exists():
             text = candidate.read_text(encoding="utf-8").strip()
@@ -184,19 +192,25 @@ def _generate_event_summary_llm(sessions: List[SessionRecord]) -> Tuple[str, str
     # Build sessions payload for prompt
     sessions_data = []
     for i, session in enumerate(sessions):
-        sessions_data.append({
-            "session_number": i + 1,
-            "title": session.session_title or f"Session {session.id[:8]}",
-            "summary": session.session_summary or "(no summary)",
-            "session_type": session.session_type,
-        })
+        sessions_data.append(
+            {
+                "session_number": i + 1,
+                "title": session.session_title or f"Session {session.id[:8]}",
+                "summary": session.session_summary or "(no summary)",
+                "session_type": session.session_type,
+            }
+        )
 
     system_prompt = _get_event_summary_prompt()
 
-    user_prompt = json.dumps({
-        "total_sessions": len(sessions),
-        "sessions": sessions_data,
-    }, ensure_ascii=False, indent=2)
+    user_prompt = json.dumps(
+        {
+            "total_sessions": len(sessions),
+            "sessions": sessions_data,
+        },
+        ensure_ascii=False,
+        indent=2,
+    )
 
     try:
         # Use unified LLM client
@@ -205,7 +219,7 @@ def _generate_event_summary_llm(sessions: List[SessionRecord]) -> Tuple[str, str
             user_prompt=user_prompt,
             provider="auto",  # Try Claude first, fallback to OpenAI
             max_tokens=500,
-            purpose="event_summary"
+            purpose="event_summary",
         )
 
         if not response:
@@ -241,5 +255,3 @@ def _fallback_event_summary(sessions: List[SessionRecord]) -> Tuple[str, str]:
         description = f"Event containing {len(sessions)} sessions."
 
     return title[:100], description
-
-