praisonai-code 0.0.1__py3-none-any.whl

praisonai_code/cli/commands/session.py

@@ -0,0 +1,450 @@
+"""
+Session command group for PraisonAI CLI.
+
+Provides session management:
+- session list: List all sessions
+- session resume: Resume a session
+- session delete: Delete a session
+- session export: Export a session
+"""
+
+from typing import Optional
+
+import typer
+
+from ..output.console import get_output_controller
+from ..state.sessions import get_session_manager, set_session_backend
+
+app = typer.Typer(help="Session management")
+
+
+def _create_backend(backend_type: str, storage_path: Optional[str]):
+    """Create storage backend from CLI options."""
+    try:
+        if backend_type == "file":
+            from praisonaiagents.storage import FileBackend
+            return FileBackend(storage_dir=storage_path or "~/.praison/sessions")
+        elif backend_type == "sqlite":
+            from praisonaiagents.storage import SQLiteBackend
+            db_path = storage_path or "~/.praison/sessions.db"
+            return SQLiteBackend(db_path=db_path)
+        elif backend_type.startswith("redis://"):
+            from praisonaiagents.storage import RedisBackend
+            return RedisBackend(url=backend_type, prefix="session:")
+        else:
+            return None
+    except Exception:
+        return None
+
+
+@app.command("list")
+def session_list(
+    limit: int = typer.Option(
+        20,
+        "--limit",
+        "-n",
+        help="Maximum number of sessions to show",
+    ),
+    storage_backend: Optional[str] = typer.Option(
+        None,
+        "--storage-backend",
+        help="Storage backend: 'file', 'sqlite', or 'redis://url'",
+    ),
+    storage_path: Optional[str] = typer.Option(
+        None,
+        "--storage-path",
+        help="Path for storage backend",
+    ),
+    all_projects: bool = typer.Option(
+        False,
+        "--all",
+        help="Show sessions from all projects (default: current project only)",
+    ),
+    project_id: Optional[str] = typer.Option(
+        None,
+        "--project",
+        help="Show sessions for specific project ID",
+    ),
+):
+    """List all sessions."""
+    output = get_output_controller()
+    
+    # Handle project-scoped session listing
+    if not all_projects and not storage_backend:
+        # Use project-scoped session store by default
+        from ..state.project_sessions import get_project_session_store
+        from ..utils.project import get_project_id, get_project_name
+        
+        # List sessions for specific or current project
+        project_store = get_project_session_store(project_id=project_id)
+            
+        sessions_data = project_store.list_sessions(limit=limit)
+        
+        # Convert to expected format
+        class SessionInfo:
+            def __init__(self, data):
+                from datetime import datetime
+                
+                self.session_id = data.get("session_id", data.get("id", ""))
+                self.name = data.get("agent_name", "")
+                self.status = data.get("status")  # Use actual status from data if available
+                self.event_count = data.get("message_count", 0)
+
+                # Cumulative usage totals persisted per session (Issue #2421).
+                usage = data.get("usage")
+                if isinstance(usage, dict):
+                    self.total_tokens = usage.get("total_tokens") or 0
+                    self.cost = usage.get("cost") or 0.0
+                else:
+                    self.total_tokens = data.get("total_tokens") or 0
+                    self.cost = data.get("cost") or 0.0
+
+                # Parse updated_at string
+                updated_str = data.get("updated_at", "")
+                try:
+                    self.updated_at = datetime.fromisoformat(updated_str.replace('Z', '+00:00')) if updated_str else datetime.now()
+                except ValueError:
+                    self.updated_at = datetime.now()
+                
+            def to_dict(self):
+                return {
+                    "session_id": self.session_id,
+                    "name": self.name,
+                    "status": self.status,
+                    "event_count": self.event_count,
+                    "total_tokens": self.total_tokens,
+                    "cost": self.cost,
+                    "updated_at": self.updated_at.isoformat(),
+                }
+        
+        sessions = [SessionInfo(data) for data in sessions_data]
+        
+        # Add project info to output
+        if not project_id:
+            current_project = get_project_name()
+            current_id = get_project_id()
+            output.print_info(f"Project: {current_project} (ID: {current_id})")
+        
+    else:
+        # Use global session manager
+        # Configure backend if specified
+        if storage_backend:
+            backend = _create_backend(storage_backend, storage_path)
+            if backend:
+                set_session_backend(backend)
+        
+        manager = get_session_manager()
+        sessions = manager.list(limit=limit)
+
+        # SessionMetadata objects don't carry usage; surface persisted totals
+        # for global/backend listings the same way the project path does so the
+        # Tokens/Cost columns aren't blank when usage was recorded (Issue #2421).
+        try:
+            from ..state.project_sessions import read_session_usage
+
+            for s in sessions:
+                sid = getattr(s, "session_id", None) or getattr(s, "id", None)
+                if not sid:
+                    continue
+                usage = read_session_usage(sid)
+                if usage.get("total_tokens") or usage.get("cost"):
+                    try:
+                        s.total_tokens = usage.get("total_tokens") or 0
+                        s.cost = usage.get("cost") or 0.0
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+
+    if output.is_json_mode:
+        def _session_dict(s):
+            d = s.to_dict()
+            # Ensure usage totals surface in JSON even for SessionMetadata,
+            # whose to_dict() omits them (Issue #2421).
+            if "total_tokens" not in d:
+                d["total_tokens"] = getattr(s, "total_tokens", 0) or 0
+            if "cost" not in d:
+                d["cost"] = getattr(s, "cost", 0.0) or 0.0
+            return d
+
+        output.print_json({
+            "sessions": [_session_dict(s) for s in sessions]
+        })
+        return
+    
+    if not sessions:
+        output.print_info("No sessions found")
+        return
+    
+    headers = ["ID", "Name", "Status", "Events", "Tokens", "Cost", "Updated"]
+    rows = []
+    for s in sessions:
+        total_tokens = getattr(s, "total_tokens", 0) or 0
+        cost = getattr(s, "cost", 0.0) or 0.0
+        rows.append([
+            s.session_id[:20] + "..." if len(s.session_id) > 20 else s.session_id,
+            s.name or "-",
+            s.status,
+            str(s.event_count),
+            f"{int(total_tokens):,}" if total_tokens else "-",
+            f"${float(cost):.4f}" if cost else "-",
+            s.updated_at.strftime("%Y-%m-%d %H:%M"),
+        ])
+    
+    output.print_table(headers, rows, title="Sessions")
+
+
+@app.command("resume")
+def session_resume(
+    session_id: str = typer.Argument(..., help="Session ID to resume"),
+    prompt: Optional[str] = typer.Argument(
+        None,
+        help="Optional prompt to continue the session with",
+    ),
+    transcript: bool = typer.Option(
+        False,
+        "--transcript",
+        help="Only show the session transcript instead of restoring state",
+    ),
+):
+    """Resume a session with full conversational state restored."""
+    output = get_output_controller()
+
+    # Transcript-only path (opt-in for the old behaviour).
+    if transcript:
+        _print_session_transcript(session_id, output)
+        return
+
+    # Deterministic restoration via the shared rehydrate helper.
+    from ..session.resume import rehydrate_session
+
+    restored = rehydrate_session(session_id)
+
+    if not restored.found:
+        output.print_error(
+            f"Session not found: {session_id}",
+            remediation="Use 'praisonai session list' to see available sessions"
+        )
+        raise typer.Exit(1)
+
+    # When a prompt is supplied we hand off to `_run_prompt`, which owns all
+    # output for the continuation run. Emitting a restore blob here too would
+    # produce two top-level outputs (and break `--json` consumers), so we skip
+    # the standalone restore rendering in that case.
+    if prompt is None:
+        if output.is_json_mode:
+            output.print_json({
+                "session": restored.to_dict(),
+                "restored": True,
+            })
+            return
+
+        from ..state.project_sessions import format_usage_footer
+
+        usage_line = ""
+        if restored.usage and (restored.usage.get("total_tokens") or restored.usage.get("cost")):
+            usage_line = f"\nUsage: {format_usage_footer(restored.usage)}"
+
+        output.print_panel(
+            f"Session: {restored.agent_name or restored.session_id}\n"
+            f"Model: {restored.model or 'default'}\n"
+            f"Messages restored: {len(restored.chat_history)}"
+            f"{usage_line}",
+            title="Session Resumed"
+        )
+
+        if restored.chat_history:
+            output.print("\n--- Restored Conversation ---\n")
+            for msg in restored.chat_history[-10:]:
+                role = msg.get("role", "?")
+                content = msg.get("content", "")
+                output.print(f"[{role}] {content}")
+        return
+
+    # Continue the run with the restored state via the shared run path so
+    # behaviour matches `praisonai run --session <id>`.
+    from .run import _run_prompt
+
+    _run_prompt(
+        prompt=prompt,
+        model=restored.model,
+        session=session_id,
+    )
+
+
+def _print_session_transcript(session_id: str, output) -> None:
+    """Print a session transcript (legacy ``--transcript`` behaviour)."""
+    manager = get_session_manager()
+    session = manager.get(session_id)
+
+    if not session:
+        output.print_error(
+            f"Session not found: {session_id}",
+            remediation="Use 'praisonai session list' to see available sessions"
+        )
+        raise typer.Exit(1)
+
+    events = manager.get_events(session_id)
+
+    if output.is_json_mode:
+        output.print_json({
+            "session": session.to_dict(),
+            "events": events,
+        })
+        return
+
+    output.print_panel(
+        f"Session: {session.name or session.session_id}\n"
+        f"Run ID: {session.run_id}\n"
+        f"Trace ID: {session.trace_id}\n"
+        f"Events: {session.event_count}\n"
+        f"Status: {session.status}",
+        title="Session Transcript"
+    )
+
+    if events:
+        output.print("\n--- Recent Events ---\n")
+        for event in events[-10:]:
+            event_type = event.get("event", "unknown")
+            message = event.get("message", "")
+            output.print(f"[{event_type}] {message}")
+
+
+@app.command("delete")
+def session_delete(
+    session_id: str = typer.Argument(..., help="Session ID to delete"),
+    confirm: bool = typer.Option(
+        False,
+        "--yes",
+        "-y",
+        help="Skip confirmation",
+    ),
+):
+    """Delete a session."""
+    output = get_output_controller()
+    manager = get_session_manager()
+    
+    session = manager.get(session_id)
+    
+    if not session:
+        output.print_error(f"Session not found: {session_id}")
+        raise typer.Exit(1)
+    
+    if not confirm:
+        confirmed = typer.confirm(f"Delete session {session_id}?")
+        if not confirmed:
+            output.print_info("Cancelled")
+            raise typer.Exit(0)
+    
+    deleted = manager.delete(session_id)
+    
+    if output.is_json_mode:
+        output.print_json({"deleted": deleted, "session_id": session_id})
+    else:
+        if deleted:
+            output.print_success(f"Deleted session: {session_id}")
+        else:
+            output.print_error(f"Failed to delete session: {session_id}")
+            raise typer.Exit(1)
+
+
+@app.command("export")
+def session_export(
+    session_id: str = typer.Argument(..., help="Session ID to export"),
+    format: str = typer.Option(
+        "md",
+        "--format",
+        "-f",
+        help="Export format: md or json",
+    ),
+    output_file: Optional[str] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path",
+    ),
+):
+    """Export a session."""
+    output = get_output_controller()
+    manager = get_session_manager()
+    
+    content = manager.export(session_id, format=format)
+    
+    if content is None:
+        output.print_error(f"Session not found: {session_id}")
+        raise typer.Exit(1)
+    
+    if output_file:
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(content)
+        output.print_success(f"Exported to: {output_file}")
+    else:
+        print(content)
+
+
+@app.command("show")
+def session_show(
+    session_id: str = typer.Argument(..., help="Session ID to show"),
+):
+    """Show session details."""
+    output = get_output_controller()
+    manager = get_session_manager()
+    
+    session = manager.get(session_id)
+    
+    if not session:
+        output.print_error(f"Session not found: {session_id}")
+        raise typer.Exit(1)
+    
+    if output.is_json_mode:
+        output.print_json(session.to_dict())
+        return
+    
+    output.print_panel(
+        f"Session ID: {session.session_id}\n"
+        f"Name: {session.name or '-'}\n"
+        f"Run ID: {session.run_id}\n"
+        f"Trace ID: {session.trace_id}\n"
+        f"Created: {session.created_at.isoformat()}\n"
+        f"Updated: {session.updated_at.isoformat()}\n"
+        f"Status: {session.status}\n"
+        f"Events: {session.event_count}\n"
+        f"Workspace: {session.workspace or '-'}",
+        title="Session Details"
+    )
+
+
+@app.command("import")
+def session_import(
+    input_file: str = typer.Argument(..., help="Session file to import (JSON format)"),
+):
+    """Import a session from a file."""
+    import json
+    
+    output = get_output_controller()
+    
+    try:
+        with open(input_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except FileNotFoundError:
+        output.print_error(f"File not found: {input_file}")
+        raise typer.Exit(1)
+    except json.JSONDecodeError as e:
+        output.print_error(f"Invalid JSON: {e}")
+        raise typer.Exit(1)
+    
+    # Use InteractiveCore to import
+    try:
+        from praisonai.cli.interactive import InteractiveCore
+        
+        core = InteractiveCore()
+        session_id = core.import_session(data)
+        
+        if output.is_json_mode:
+            output.print_json({"imported": True, "session_id": session_id})
+        else:
+            output.print_success(f"Imported session: {session_id}")
+            
+    except Exception as e:
+        output.print_error(f"Import failed: {e}")
+        raise typer.Exit(1)

praisonai_code/cli/commands/setup.py

@@ -0,0 +1,174 @@
+"""
+Setup command group for PraisonAI CLI.
+
+Provides interactive onboarding and configuration wizard.
+"""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from ..output.console import get_output_controller
+
+app = typer.Typer(help="Interactive onboarding / configuration wizard")
+
+# Default PRAISON_HOME directory
+def get_praison_home() -> Path:
+    """Get the PraisonAI home directory."""
+    home = os.getenv("PRAISONAI_HOME")
+    if home:
+        return Path(home)
+    return Path.home() / ".praisonai"
+
+PRAISON_HOME = get_praison_home()
+ENV_FILE = PRAISON_HOME / ".env"
+
+# Provider configurations
+PROVIDERS = {
+    "1": ("openai",    "OPENAI_API_KEY",    "gpt-4o-mini"),
+    "2": ("anthropic", "ANTHROPIC_API_KEY", "claude-3-5-sonnet-latest"),
+    "3": ("google",    "GEMINI_API_KEY",    "gemini-2.0-flash"),
+    "4": ("ollama",    None,                "llama3.2"),
+    "5": ("custom",    None,                None),
+}
+
+PROVIDER_NAMES = {
+    "openai": ("OpenAI", "OPENAI_API_KEY", "gpt-4o-mini"),
+    "anthropic": ("Anthropic", "ANTHROPIC_API_KEY", "claude-3-5-sonnet-latest"),
+    "google": ("Google", "GEMINI_API_KEY", "gemini-2.0-flash"),
+    "ollama": ("Ollama", None, "llama3.2"),
+    "custom": ("Custom", None, None),
+}
+
+
+def _run_setup(
+    non_interactive: bool = False,
+    provider: Optional[str] = None,
+    api_key: Optional[str] = None,
+    model: Optional[str] = None,
+) -> int:
+    """Run the setup wizard."""
+    try:
+        from praisonai.cli.features.setup.handler import SetupHandler
+        handler = SetupHandler()
+        return handler.execute(
+            non_interactive=non_interactive,
+            provider=provider,
+            api_key=api_key,
+            model=model
+        )
+    except ImportError as e:
+        output = get_output_controller()
+        output.print_error(f"Setup module not available: {e}")
+        return 4
+    except Exception as e:
+        output = get_output_controller()
+        output.print_error(f"Setup error: {e}")
+        return 1
+
+
+@app.callback(invoke_without_command=True)
+def setup_callback(
+    ctx: typer.Context,
+    non_interactive: bool = typer.Option(False, "--non-interactive", help="Run in non-interactive mode"),
+    provider: Optional[str] = typer.Option(None, "--provider", help="LLM provider (openai, anthropic, google, ollama, custom)"),
+    api_key: Optional[str] = typer.Option(None, "--api-key", help="API key for the provider"),
+    model: Optional[str] = typer.Option(None, "--model", help="Default model to use"),
+):
+    """Run the onboarding wizard (idempotent — safe to re-run)."""
+    if ctx.invoked_subcommand:
+        return
+        
+    exit_code = _run_setup(
+        non_interactive=non_interactive,
+        provider=provider,
+        api_key=api_key,
+        model=model
+    )
+    raise typer.Exit(exit_code)
+
+
+@app.command("wizard")
+def setup_wizard(
+    provider: Optional[str] = typer.Option(None, "--provider", help="LLM provider"),
+    api_key: Optional[str] = typer.Option(None, "--api-key", help="API key"),
+    model: Optional[str] = typer.Option(None, "--model", help="Default model"),
+):
+    """Run the interactive setup wizard."""
+    exit_code = _run_setup(
+        non_interactive=False,
+        provider=provider,
+        api_key=api_key,
+        model=model
+    )
+    raise typer.Exit(exit_code)
+
+
+@app.command("config")
+def setup_config(
+    show: bool = typer.Option(False, "--show", help="Show current configuration"),
+    edit: bool = typer.Option(False, "--edit", help="Edit configuration file"),
+):
+    """Manage setup configuration."""
+    output = get_output_controller()
+    
+    if show:
+        if ENV_FILE.exists():
+            output.console.print(f"[bold]Configuration at {ENV_FILE}:[/bold]")
+            content = ENV_FILE.read_text()
+            # Don't show actual API keys for security
+            lines = []
+            for line in content.split('\n'):
+                if '=' in line and any(key in line for key in ['API_KEY', 'TOKEN', 'SECRET']):
+                    key, _ = line.split('=', 1)
+                    lines.append(f"{key}=***")
+                else:
+                    lines.append(line)
+            output.console.print('\n'.join(lines))
+        else:
+            output.print_warning(f"No configuration found at {ENV_FILE}")
+            output.console.print("Run [cyan]praisonai setup[/cyan] to create one.")
+    
+    if edit:
+        import subprocess
+        editor = os.getenv("EDITOR", "nano")
+        try:
+            subprocess.run([editor, str(ENV_FILE)], check=True)
+        except subprocess.CalledProcessError:
+            output.print_error(f"Failed to open editor: {editor}")
+        except FileNotFoundError:
+            output.print_error(f"Editor not found: {editor}")
+
+
+@app.command("reset")
+def setup_reset(
+    force: bool = typer.Option(False, "--force", help="Skip confirmation"),
+):
+    """Reset setup configuration."""
+    output = get_output_controller()
+    
+    praison_home = get_praison_home()
+    env_file = praison_home / ".env"
+    config_file = praison_home / "config.yaml"
+    files_to_remove = [path for path in (env_file, config_file) if path.exists()]
+
+    if not files_to_remove:
+        output.print_info("No setup configuration to reset.")
+        return
+    
+    if not force:
+        confirm = typer.confirm(f"Reset configuration at {praison_home}?")
+        if not confirm:
+            output.print_info("Reset cancelled.")
+            return
+    
+    try:
+        for path in files_to_remove:
+            path.unlink()
+        output.print_success("Configuration reset successfully.")
+        output.console.print("Run [cyan]praisonai setup[/cyan] to configure again.")
+    except Exception as e:
+        output.print_error(f"Failed to reset configuration: {e}")
+        raise typer.Exit(1)