aline-ai 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

realign/db/sqlite_db.py

@@ -1462,6 +1462,82 @@ class SQLiteDatabase(DatabaseInterface):
         except Exception:
             return 0
 
+    def requeue_failed_jobs(
+        self,
+        *,
+        kinds: Optional[List[str]] = None,
+    ) -> Tuple[int, List[Dict[str, Any]]]:
+        """
+        Requeue all failed jobs, optionally filtering by kind.
+
+        Returns:
+            (count, jobs) - number of jobs requeued and their details
+        """
+        conn = self._get_connection()
+        try:
+            # First, get the failed jobs
+            where_clauses: list[str] = ["status = 'failed'"]
+            params: list[Any] = []
+            if kinds:
+                placeholders = ",".join(["?"] * len(kinds))
+                where_clauses.append(f"kind IN ({placeholders})")
+                params.extend(kinds)
+
+            where_sql = "WHERE " + " AND ".join(where_clauses)
+
+            rows = conn.execute(
+                f"""
+                SELECT id, kind, dedupe_key, payload, last_error, attempts
+                FROM jobs
+                {where_sql}
+                ORDER BY updated_at DESC
+                """,
+                tuple(params),
+            ).fetchall()
+
+            if not rows:
+                return 0, []
+
+            jobs_info: List[Dict[str, Any]] = []
+            for row in rows:
+                payload_raw = row["payload"] or "{}"
+                try:
+                    payload_obj = json.loads(payload_raw)
+                except Exception:
+                    payload_obj = {}
+                jobs_info.append({
+                    "id": str(row["id"]),
+                    "kind": row["kind"],
+                    "dedupe_key": row["dedupe_key"],
+                    "payload": payload_obj,
+                    "last_error": row["last_error"],
+                    "attempts": row["attempts"],
+                })
+
+            # Requeue them
+            conn.execute(
+                f"""
+                UPDATE jobs
+                SET status = 'queued',
+                    attempts = 0,
+                    next_run_at = datetime('now'),
+                    last_error = NULL,
+                    locked_until = NULL,
+                    locked_by = NULL,
+                    updated_at = datetime('now')
+                {where_sql}
+                """,
+                tuple(params),
+            )
+            conn.commit()
+
+            return len(jobs_info), jobs_info
+        except sqlite3.OperationalError:
+            return 0, []
+        except Exception:
+            conn.rollback()
+            return 0, []
+
     def update_turn_summary(
         self,
         turn_id: str,

realign/hooks.py

@@ -157,80 +157,11 @@ def _classify_task_metadata(
 ) -> Tuple[str, str]:
     """
     Run a dedicated LLM classification pass for if_last_task and satisfaction tags.
-    """
-    defaults = ("no", "fine")
-
-    if not (user_messages or assistant_replies or code_changes):
-        return defaults
-
-    def _clip_text(text: str, limit: int) -> str:
-        text = (text or "").strip()
-        if not text:
-            return ""
-        if len(text) <= limit:
-            return text
-        return text[: max(0, limit - 3)].rstrip() + "..."
-
-    clipped_user = _clip_text(user_messages, 2000) or "(missing)"
-    current_title = (summary_title or "").strip() or "(missing)"
-    previous_title = (previous_commit_title or "").strip() or "(none)"
-
-    # Try cloud provider first if provider is "auto" or "cloud" and user is logged in
-    if provider in ("auto", "cloud"):
-        try:
-            from .auth import is_logged_in
-
-            if is_logged_in():
-                logger.debug("Attempting cloud LLM for metadata classification")
-                # Load user custom prompt if available
-                custom_prompt = None
-                if system_prompt is not None:
-                    custom_prompt = system_prompt
-                else:
-                    user_prompt_path = Path.home() / ".aline" / "prompts" / "metadata.md"
-                    try:
-                        if user_prompt_path.exists():
-                            custom_prompt = user_prompt_path.read_text(encoding="utf-8").strip()
-                    except Exception:
-                        pass
-
-                model_name, result = call_llm_cloud(
-                    task="metadata",
-                    payload={
-                        "previous_title": previous_title,
-                        "user_messages": clipped_user,
-                        "current_title": current_title,
-                    },
-                    custom_prompt=custom_prompt,
-                    silent=False,
-                )
-
-                if result:
-                    if_last_task = result.get("if_last_task", "no")
-                    satisfaction = result.get("satisfaction", "fine")
-                    logger.info(
-                        "Cloud LLM metadata response: if_last_task=%s, satisfaction=%s",
-                        if_last_task,
-                        satisfaction,
-                    )
-                    print(
-                        f"   🔍 Metadata classification: if_last_task={if_last_task}, "
-                        f"satisfaction={satisfaction}",
-                        file=sys.stderr,
-                    )
-                    return if_last_task, satisfaction
-                else:
-                    # Cloud LLM failed, return defaults (local fallback disabled)
-                    logger.warning("Cloud LLM metadata failed, returning defaults")
-                    print("   ⚠️  Cloud LLM metadata failed, using defaults", file=sys.stderr)
-                    return defaults
-        except ImportError:
-            logger.debug("Auth module not available, skipping cloud LLM")
 
-    # User not logged in, return defaults (local fallback disabled)
-    logger.warning("Not logged in, cannot use cloud LLM for metadata")
-    print("   ⚠️  Please login with 'aline login' to use LLM features", file=sys.stderr)
-    return defaults
+    NOTE: LLM-based metadata classification is disabled. Always returns defaults.
+    """
+    # Metadata LLM classification disabled - always return defaults
+    return ("no", "fine")
 
     # =========================================================================
     # LOCAL LLM FALLBACK DISABLED - Code kept for reference
@@ -450,63 +381,10 @@ def find_codex_latest_session(project_path: Path, days_back: int = 7) -> Optiona
     Returns:
         Path to the most recent session file, or None if not found
     """
-    from datetime import datetime, timedelta
+    from .codex_detector import get_latest_codex_session
 
     logger.debug(f"Searching for Codex sessions for project: {project_path}")
-
-    codex_sessions_base = Path.home() / ".codex" / "sessions"
-
-    if not codex_sessions_base.exists():
-        logger.debug(f"Codex sessions directory not found: {codex_sessions_base}")
-        return None
-
-    # Normalize project path for comparison
-    abs_project_path = str(project_path.resolve())
-
-    matching_sessions = []
-
-    # Search through recent days
-    for days_ago in range(days_back + 1):
-        target_date = datetime.now() - timedelta(days=days_ago)
-        date_path = (
-            codex_sessions_base
-            / str(target_date.year)
-            / f"{target_date.month:02d}"
-            / f"{target_date.day:02d}"
-        )
-
-        if not date_path.exists():
-            continue
-
-        # Check all session files in this date directory
-        for session_file in date_path.glob("rollout-*.jsonl"):
-            try:
-                # Read first line to get session metadata
-                with open(session_file, "r", encoding="utf-8") as f:
-                    first_line = f.readline()
-                    if first_line:
-                        data = json.loads(first_line)
-                        if data.get("type") == "session_meta":
-                            session_cwd = data.get("payload", {}).get("cwd", "")
-                            # Match the project path
-                            if session_cwd == abs_project_path:
-                                matching_sessions.append(session_file)
-                                logger.debug(f"Found matching Codex session: {session_file}")
-            except (json.JSONDecodeError, IOError) as e:
-                logger.debug(f"Skipping malformed session file {session_file}: {e}")
-                continue
-
-    # Sort by modification time, newest first
-    matching_sessions.sort(key=lambda p: p.stat().st_mtime, reverse=True)
-
-    if matching_sessions:
-        logger.info(
-            f"Found {len(matching_sessions)} Codex session(s), using latest: {matching_sessions[0]}"
-        )
-    else:
-        logger.debug("No matching Codex sessions found")
-
-    return matching_sessions[0] if matching_sessions else None
+    return get_latest_codex_session(project_path, days_back=days_back)
 
 
 def find_all_claude_sessions() -> List[Path]:

realign/watcher_core.py

@@ -251,6 +251,46 @@ class DialogueWatcher:
         self.user_prompt_signal_dir = self.signal_dir / "user_prompt_submit"
         self.user_prompt_signal_dir.mkdir(parents=True, exist_ok=True)
 
+    def _maybe_link_codex_terminal(self, session_file: Path) -> None:
+        """Best-effort: bind a Codex session file to the most likely active Codex terminal."""
+        try:
+            if self._detect_session_type(session_file) != "codex":
+                return
+        except Exception:
+            return
+
+        try:
+            from .codex_home import terminal_id_from_codex_session_file
+            from .codex_terminal_linker import read_codex_session_meta, select_agent_for_codex_session
+            from .db import get_database
+
+            meta = read_codex_session_meta(session_file)
+            if meta is None:
+                return
+
+            db = get_database(read_only=False)
+            agents = db.list_agents(status="active", limit=1000)
+            # Deterministic mapping: session file stored under ~/.aline/codex_homes/<terminal_id>/...
+            agent_id = terminal_id_from_codex_session_file(session_file)
+            if not agent_id:
+                # Fallback heuristic mapping (legacy default ~/.codex/sessions).
+                agent_id = select_agent_for_codex_session(agents, session=meta)
+            if not agent_id:
+                return
+
+            db.update_agent(
+                agent_id,
+                provider="codex",
+                session_type="codex",
+                session_id=session_file.stem,
+                transcript_path=str(session_file),
+                cwd=meta.cwd,
+                project_dir=meta.cwd,
+                source="codex:auto-link",
+            )
+        except Exception:
+            return
+
     async def start(self):
         """Start watching session files."""
         if not self.config.mcp_auto_commit:
@@ -1047,6 +1087,11 @@ class DialogueWatcher:
                 if old_size is None or old_mtime is None:
                     changed_files.append(Path(path))
                     logger.debug(f"Session file first seen: {Path(path).name} ({size} bytes)")
+                    # Best-effort: link newly discovered Codex sessions to an active Codex terminal.
+                    try:
+                        self._maybe_link_codex_terminal(Path(path))
+                    except Exception:
+                        pass
                     # Reset idle final-commit attempt tracking for new files
                     self.last_final_commit_times.pop(path, None)
                     continue
@@ -1107,6 +1152,11 @@ class DialogueWatcher:
             for session_file in changed_files:
                 if not session_file.exists():
                     continue
+                # Best-effort: keep terminal bindings fresh (especially after watcher restarts).
+                try:
+                    self._maybe_link_codex_terminal(session_file)
+                except Exception:
+                    pass
                 new_turns = self._get_new_completed_turn_numbers(session_file)
                 if new_turns:
                     sessions_to_enqueue.append((session_file, new_turns))