aline-ai 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

realign/commands/agent.py

@@ -0,0 +1,109 @@
+"""Agent management commands."""
+
+import uuid
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+def _get_db():
+    """Get database instance."""
+    from ..config import ReAlignConfig
+    from ..db.sqlite_db import SQLiteDatabase
+
+    config = ReAlignConfig.load()
+    db_path = Path(config.sqlite_db_path).expanduser()
+    db = SQLiteDatabase(str(db_path))
+    db.initialize()
+    return db
+
+
+def agent_new_command(name: str | None = None, desc: str = "") -> int:
+    """Create a new agent profile.
+
+    Args:
+        name: Display name (random Docker-style name if None).
+        desc: Agent description.
+
+    Returns:
+        Exit code (0 = success).
+    """
+    from ..agent_names import generate_agent_name
+
+    agent_id = str(uuid.uuid4())
+    display_name = name or generate_agent_name()
+
+    db = _get_db()
+    try:
+        record = db.get_or_create_agent_info(agent_id, name=display_name)
+        if desc:
+            record = db.update_agent_info(agent_id, description=desc)
+
+        console.print(f"[bold green]Agent created[/bold green]")
+        console.print(f"  id:          {record.id}")
+        console.print(f"  name:        {record.name}")
+        console.print(f"  description: {record.description or '(none)'}")
+        return 0
+    finally:
+        db.close()
+
+
+def agent_list_command(*, include_invisible: bool = False) -> int:
+    """List agent profiles.
+
+    Returns:
+        Exit code (0 = success).
+    """
+    from rich.table import Table
+
+    db = _get_db()
+    try:
+        agents = db.list_agent_info(include_invisible=include_invisible)
+
+        if not agents:
+            console.print("[dim]No agents yet.[/dim]")
+            return 0
+
+        table = Table(title="Agents")
+        table.add_column("ID", style="dim", width=8)
+        table.add_column("Name", style="bold")
+        table.add_column("Description")
+        table.add_column("Sessions", style="cyan")
+        table.add_column("Created", style="dim")
+
+        def _unique_prefixes(ids: list[str], min_len: int = 8) -> list[str]:
+            if not ids:
+                return []
+            max_len = max(len(i) for i in ids)
+            length = min_len
+            while length <= max_len:
+                prefixes = [i[:length] for i in ids]
+                if len(set(prefixes)) == len(ids):
+                    return prefixes
+                length += 2
+            return ids
+
+        for agent in agents:
+            created_str = agent.created_at.strftime("%Y-%m-%d %H:%M")
+            sessions = db.get_sessions_by_agent_id(agent.id)
+            if sessions:
+                raw_ids = [s.id for s in sessions]
+                short_ids = _unique_prefixes(raw_ids, min_len=8)
+                session_ids = ", ".join(short_ids)
+                sessions_display = f"{len(sessions)} ({session_ids})"
+            else:
+                sessions_display = "0"
+            table.add_row(
+                agent.id[:8],
+                agent.name,
+                agent.description or "",
+                sessions_display,
+                created_str,
+            )
+
+        console.print(table)
+        return 0
+    finally:
+        db.close()

realign/commands/doctor.py

@@ -308,6 +308,7 @@ def run_doctor(
     start_if_not_running: bool,
     verbose: bool,
     clear_cache: bool,
+    auto_fix: bool = False,
 ) -> int:
     """
     Core doctor logic.
@@ -317,6 +318,7 @@ def run_doctor(
         start_if_not_running: If True and restart_daemons is True, start daemons even if not running.
         verbose: Print details.
         clear_cache: Clear Python bytecode cache for the installed package directory.
+        auto_fix: If True, automatically fix failed jobs without prompting.
     """
     from ..auth import is_logged_in
     from . import watcher as watcher_cmd
@@ -417,7 +419,7 @@ def run_doctor(
                 console.print(f"  [yellow]![/yellow] Found {llm_error_count} turn(s) with LLM API errors")
 
             # Ask user if they want to fix
-            if typer.confirm("\n  Do you want to requeue these for regeneration?", default=True):
+            if auto_fix or typer.confirm("\n  Do you want to requeue these for regeneration?", default=True):
                 requeued_jobs = 0
                 requeued_turns = 0
 

realign/commands/export_shares.py

@@ -15,6 +15,7 @@ import secrets
 import hashlib
 import base64
 import threading
+import shutil
 from urllib.parse import urlparse
 from collections import defaultdict
 from dataclasses import dataclass
@@ -2523,6 +2524,59 @@ def display_share_result(
     console.print(f"[bold]👁️  Max Views:[/bold] {max_views}\n")
 
 
+def _run_clipboard_command(command: list[str], text: str) -> bool:
+    try:
+        return (
+            subprocess.run(
+                command,
+                input=text,
+                text=True,
+                capture_output=False,
+                check=False,
+            ).returncode
+            == 0
+        )
+    except Exception:
+        return False
+
+
+def _copy_text_to_clipboard(text: str) -> bool:
+    if not text:
+        return False
+
+    if shutil.which("pbcopy"):
+        if _run_clipboard_command(["pbcopy"], text):
+            return True
+
+    if os.name == "nt" and shutil.which("clip"):
+        if _run_clipboard_command(["clip"], text):
+            return True
+
+    if shutil.which("wl-copy"):
+        if _run_clipboard_command(["wl-copy"], text):
+            return True
+
+    if shutil.which("xclip"):
+        if _run_clipboard_command(["xclip", "-selection", "clipboard"], text):
+            return True
+
+    if shutil.which("xsel"):
+        if _run_clipboard_command(["xsel", "--clipboard", "--input"], text):
+            return True
+
+    return False
+
+
+def _copy_share_to_clipboard(share_url: Optional[str], slack_message: Optional[str]) -> bool:
+    if not share_url:
+        return False
+    if slack_message:
+        text_to_copy = f"{slack_message}\n\n{share_url}"
+    else:
+        text_to_copy = share_url
+    return _copy_text_to_clipboard(text_to_copy)
+
+
 def _export_by_events_interactive(
     all_commits: List,
     shadow_git: Path,
@@ -3616,7 +3670,250 @@ def export_shares_interactive_command(
             max_views=max_views,
             admin_token=result.get("admin_token"),
         )
+        copied = _copy_share_to_clipboard(
+            result.get("share_url"),
+            ui_metadata.get("slack_message") if ui_metadata else None,
+        )
+        if copied:
+            print("📋 Copied Slack message and share link to clipboard.")
 
     if not json_output:
         logger.info(f"======== Interactive export completed: {result['share_url']} ========")
     return 0
+
+
+def export_agent_shares_command(
+    agent_id: str,
+    password: Optional[str] = None,
+    expiry_days: int = 7,
+    max_views: int = 100,
+    backend_url: Optional[str] = None,
+    enable_mcp: bool = True,
+    json_output: bool = False,
+    compact: bool = True,
+    max_tool_result_chars: int = 8_000,
+    max_tool_command_chars: int = 2_000,
+    progress_callback: Optional[Callable[[str], None]] = None,
+) -> int:
+    """
+    Export all sessions associated with an agent and generate a share link.
+
+    This function creates a synthetic event structure from agent sessions,
+    generates UI metadata (Slack message), uploads to backend, and returns
+    the share link.
+
+    Args:
+        agent_id: The agent_info ID to export sessions for
+        password: Encryption password (if None, no encryption)
+        expiry_days: Share expiry in days
+        max_views: Maximum number of views
+        backend_url: Backend server URL (uses config default if None)
+        enable_mcp: Whether to include MCP instructions
+        json_output: If True, output JSON format
+        compact: Whether to compact the export data
+        max_tool_result_chars: Max chars for tool results (with compact)
+        max_tool_command_chars: Max chars for tool commands (with compact)
+        progress_callback: Optional callback for progress updates (message: str) -> None
+
+    Returns:
+        0 on success, 1 on error
+    """
+    def _progress(msg: str) -> None:
+        if progress_callback:
+            progress_callback(msg)
+
+    if not json_output:
+        logger.info(f"======== Export agent shares command started for agent {agent_id} ========")
+
+    # Check dependencies
+    if not CRYPTO_AVAILABLE:
+        if not json_output:
+            print("Error: cryptography package not installed", file=sys.stderr)
+        return 1
+
+    if not HTTPX_AVAILABLE:
+        if not json_output:
+            print("Error: httpx package not installed", file=sys.stderr)
+        return 1
+
+    # Check authentication
+    if not is_logged_in():
+        if not json_output:
+            print("Error: Not logged in. Please run 'aline login' first.", file=sys.stderr)
+        return 1
+
+    _progress("Fetching agent info...")
+
+    # Get backend URL
+    if backend_url is None:
+        from ..config import ReAlignConfig
+
+        config = ReAlignConfig.load()
+        backend_url = config.share_backend_url
+
+    # Get database
+    from ..db import get_database
+
+    db = get_database()
+
+    # Get agent info
+    agent_info = db.get_agent_info(agent_id)
+    if not agent_info:
+        if not json_output:
+            print(f"Error: Agent not found: {agent_id}", file=sys.stderr)
+        return 1
+
+    # Get sessions for this agent
+    session_records = db.get_sessions_by_agent_id(agent_id)
+    if not session_records:
+        if not json_output:
+            print(f"Error: Agent has no sessions to share", file=sys.stderr)
+        return 1
+
+    _progress(f"Found {len(session_records)} session(s)")
+
+    # Build exportable sessions
+    selected_sessions = build_exportable_sessions_from_records(session_records)
+    if not selected_sessions:
+        if not json_output:
+            print("Error: No sessions found for agent", file=sys.stderr)
+        return 1
+
+    # Create a synthetic event structure for the agent
+    # We use the agent name/description as event title/description
+    event_title = agent_info.name or "Agent Sessions"
+    event_description = agent_info.description or f"Sessions from agent: {agent_info.name}"
+
+    # Create a synthetic ExportableEvent
+    synthetic_event = ExportableEvent(
+        index=1,
+        event_id=f"agent-{agent_id}",
+        title=event_title,
+        description=event_description,
+        event_type="agent",
+        status="active",
+        updated_at=datetime.now(timezone.utc),
+        sessions=session_records,
+    )
+
+    # Build conversation data
+    _progress("Building conversation data...")
+
+    username = os.environ.get("USER") or os.environ.get("USERNAME") or "anonymous"
+
+    compaction = None
+    if compact:
+        compaction = ExportCompactionConfig(
+            enabled=True,
+            max_tool_result_chars=max_tool_result_chars,
+            max_tool_command_chars=max_tool_command_chars,
+        )
+
+    try:
+        conversation_data = build_enhanced_conversation_data(
+            selected_event=synthetic_event,
+            selected_sessions=selected_sessions,
+            username=username,
+            db=db,
+            compaction=compaction,
+        )
+    except Exception as e:
+        if not json_output:
+            print(f"Error: Failed to build conversation data: {e}", file=sys.stderr)
+        logger.error(f"Failed to build conversation data: {e}", exc_info=True)
+        return 1
+
+    if not conversation_data.get("sessions"):
+        if not json_output:
+            print("Error: No sessions found in conversation data", file=sys.stderr)
+        return 1
+
+    # Generate UI metadata with LLM
+    _progress("Generating share message...")
+
+    from ..config import ReAlignConfig
+
+    config = ReAlignConfig.load()
+    ui_metadata, _ = generate_ui_metadata_with_llm(
+        conversation_data,
+        [],  # No commits
+        event_title=event_title,
+        event_description=event_description,
+        provider=config.llm_provider,
+        preset_id="default",
+        silent=json_output,
+    )
+
+    if ui_metadata:
+        conversation_data["ui_metadata"] = ui_metadata
+    else:
+        conversation_data["ui_metadata"] = {
+            "title": event_title,
+            "description": event_description,
+        }
+
+    # Add MCP instructions if enabled
+    if enable_mcp:
+        conversation_data["ui_metadata"]["mcp_instructions"] = {
+            "tool_name": "ask_shared_conversation",
+            "usage": "Local AI agents can install the aline MCP server and use the 'ask_shared_conversation' tool to query this conversation programmatically.",
+        }
+
+    # Upload to backend (no encryption for agent shares by default)
+    _progress("Uploading to cloud...")
+
+    metadata = {
+        "username": username,
+        "expiry_days": expiry_days,
+        "max_views": max_views,
+    }
+
+    try:
+        if password:
+            encrypted_payload = encrypt_conversation_data(conversation_data, password)
+            result = upload_to_backend(
+                encrypted_payload=encrypted_payload,
+                metadata=metadata,
+                backend_url=backend_url,
+                ui_metadata=conversation_data.get("ui_metadata"),
+                background=True,
+            )
+        else:
+            result = upload_to_backend_unencrypted(
+                conversation_data=conversation_data,
+                metadata=metadata,
+                backend_url=backend_url,
+                background=True,
+            )
+    except Exception as e:
+        if not json_output:
+            print(f"Error: Upload failed: {e}", file=sys.stderr)
+        logger.error(f"Upload failed: {e}", exc_info=True)
+        return 1
+
+    share_url = result.get("share_url")
+    slack_message = ui_metadata.get("slack_message") if ui_metadata else None
+
+    # Output results
+    if json_output:
+        output_data = {
+            "agent_id": agent_id,
+            "agent_name": agent_info.name,
+            "share_link": share_url,
+            "slack_message": slack_message,
+            "session_count": len(selected_sessions),
+            "password": password,
+        }
+        print(json.dumps(output_data, ensure_ascii=False, indent=2))
+    else:
+        print(f"\n✅ Shared {len(selected_sessions)} session(s) from agent: {agent_info.name}")
+        print(f"🔗 Share link: {share_url}")
+        if slack_message:
+            print(f"\n📝 Slack message:\n{slack_message}")
+        copied = _copy_share_to_clipboard(share_url, slack_message)
+        if copied:
+            print("📋 Copied Slack message and share link to clipboard.")
+
+    if not json_output:
+        logger.info(f"======== Agent export completed: {share_url} ========")
+    return 0

realign/commands/search.py

@@ -335,9 +335,28 @@ def search_command(
             context_session_ids = get_context_session_ids()
             context_event_ids = get_context_event_ids()
 
+        # Apply agent scoping if ALINE_AGENT_ID is set
+        agent_session_ids = None
+        if not no_context:
+            import os
+
+            agent_id = os.environ.get("ALINE_AGENT_ID")
+            if agent_id:
+                agent_sessions = db.get_sessions_by_agent_id(agent_id)
+                # Always set agent_session_ids when agent_id exists
+                # (empty list means no sessions for this agent -> empty results)
+                agent_session_ids = [s.id for s in agent_sessions]
+
         # Parse session IDs if provided (resolve prefixes)
         session_ids = _resolve_id_prefixes(db, "sessions", sessions) or None
 
+        # Intersect with agent sessions first (highest priority)
+        if agent_session_ids is not None:
+            if session_ids:
+                session_ids = list(set(session_ids) & set(agent_session_ids))
+            else:
+                session_ids = agent_session_ids if agent_session_ids else []
+
         # Intersect with context sessions
         if context_session_ids:
             if session_ids:
@@ -372,43 +391,53 @@ def search_command(
         turn_ids = _resolve_id_prefixes(db, "turns", turns) or None
 
         # 1. Search Events (events don't have session scope, skip if sessions/events filter is active)
-        if type in ("all", "event") and not session_ids and not event_ids:
+        # Use 'is None' to distinguish "no filter" from "empty filter results"
+        if type in ("all", "event") and session_ids is None and event_ids is None:
             events = db.search_events(query, limit=limit, use_regex=regex, ignore_case=ignore_case)
             results["events"] = events
 
-        # 2. Search Turns
+        # 2. Search Turns (skip if session filter results in empty list)
         if type in ("all", "turn"):
-            turns = db.search_conversations(
-                query,
-                limit=limit,
-                use_regex=regex,
-                ignore_case=ignore_case,
-                session_ids=session_ids,
-            )
-            results["turns"] = turns
+            if session_ids is not None and len(session_ids) == 0:
+                results["turns"] = []
+            else:
+                turns = db.search_conversations(
+                    query,
+                    limit=limit,
+                    use_regex=regex,
+                    ignore_case=ignore_case,
+                    session_ids=session_ids if session_ids else None,
+                )
+                results["turns"] = turns
 
-        # 3. Search Sessions
+        # 3. Search Sessions (skip if session filter results in empty list)
         if type in ("all", "session"):
-            sessions_results = db.search_sessions(
-                query,
-                limit=limit,
-                use_regex=regex,
-                ignore_case=ignore_case,
-                session_ids=session_ids,
-            )
-            results["sessions"] = sessions_results
+            if session_ids is not None and len(session_ids) == 0:
+                results["sessions"] = []
+            else:
+                sessions_results = db.search_sessions(
+                    query,
+                    limit=limit,
+                    use_regex=regex,
+                    ignore_case=ignore_case,
+                    session_ids=session_ids if session_ids else None,
+                )
+                results["sessions"] = sessions_results
 
-        # 4. Search Turn Content
+        # 4. Search Turn Content (skip if session filter results in empty list)
         if type == "content":
-            content_results = db.search_turn_content(
-                query,
-                limit=limit,
-                use_regex=regex,
-                ignore_case=ignore_case,
-                session_ids=session_ids,
-                turn_ids=turn_ids,
-            )
-            results["content"] = content_results
+            if session_ids is not None and len(session_ids) == 0:
+                results["content"] = []
+            else:
+                content_results = db.search_turn_content(
+                    query,
+                    limit=limit,
+                    use_regex=regex,
+                    ignore_case=ignore_case,
+                    session_ids=session_ids if session_ids else None,
+                    turn_ids=turn_ids,
+                )
+                results["content"] = content_results
 
         # === Grep-style output for regex mode ===
         if regex: