projectmemory-cli 0.1.0__py3-none-any.whl

projectmemory_cli/commands/sessions.py

@@ -0,0 +1,277 @@
+"""Session commands: pm session status, pm session end."""
+from __future__ import annotations
+
+from typing import Optional
+
+import questionary
+import typer
+
+from projectmemory_cli import config, output
+from projectmemory_cli.api.client import APIClient
+from projectmemory_cli.api.errors import APIError, SessionAlreadyFinalizedError
+from projectmemory_cli.models.api import ActiveSession
+from projectmemory_cli.project_context import guard_project_session
+
+app = typer.Typer(help="Session commands.", no_args_is_help=True)
+
+
+def _require_client() -> APIClient:
+    from projectmemory_cli import credentials
+    token = credentials.get_token()
+    if not token:
+        output.error("Not logged in. Run: pm login")
+        raise SystemExit(2)
+    return APIClient.from_env()
+
+
+def _review_data(response: dict) -> dict:
+    return response.get("review", response)
+
+
+def _short_text(value: str, limit: int = 72) -> str:
+    value = (value or "").replace("\n", " ").strip()
+    return value if len(value) <= limit else value[: limit - 1].rstrip() + "…"
+
+
+def _item_title(item: dict) -> str:
+    return item.get("title") or item.get("description") or item.get("message") or item.get("path") or f"#{item.get('id', '?')}"
+
+
+def _display_compact_section(title: str, items: list[dict], *, icon: str = "•", limit: int = 5) -> None:
+    output.header(f"{title} ({len(items)})")
+    if not items:
+        output.hint("(none)")
+        return
+    for item in items[:limit]:
+        prefix = ""
+        if item.get("number"):
+            prefix = f"#{item['number']} "
+        elif item.get("sha"):
+            prefix = f"{str(item['sha'])[:8]} "
+        output.info(f"  {icon} {prefix}{_short_text(_item_title(item))}")
+    if len(items) > limit:
+        output.hint(f"+{len(items) - limit} more")
+
+
+@app.command("status")
+def session_status(json: bool = typer.Option(False, "--json")) -> None:
+    """Show active sessions."""
+    output.configure(json_mode=json)
+    client = _require_client()
+    try:
+        data = client.get("/api/cli/session/status/")
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if json:
+        output.print_json(data)
+        return
+
+    sessions = data.get("active_sessions", [])
+    current_id = config.get_current_project_id()
+    if not sessions:
+        output.info("No active sessions.")
+        output.hint("Run: pm resume")
+        return
+
+    output.blank()
+    output.header("Active Sessions")
+    current = [s for s in sessions if str(s.get("project")) == str(current_id)]
+    other = [s for s in sessions if str(s.get("project")) != str(current_id)]
+
+    def line(s: dict) -> str:
+        name = s.get("project_name", f"Project #{s.get('project', '?')}")
+        started = output.format_ago(s.get("started_at", ""))
+        duration = output.format_duration(int(s.get("duration_seconds") or 0))
+        return f"[bold]{name}[/bold]  [dim]started {started} ({duration})[/dim]"
+
+    if current:
+        output.info("Current:")
+        for s in current:
+            output.info(f"  {line(s)}")
+    if other:
+        if current:
+            output.blank()
+        output.info("Other:")
+        for s in other:
+            output.info(f"  {line(s)}")
+    output.blank()
+
+
+@app.command("end")
+def session_end(
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+    note: Optional[str] = typer.Option(None, "--note", "-n", help="Additional session note."),
+    progress: Optional[str] = typer.Option(None, "--progress", help="Override generated session summary."),
+    no_review: bool = typer.Option(False, "--no-review", help="Skip session review display."),
+    no_memory: bool = typer.Option(False, "--no-memory", help="Skip memory update prompts."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip final confirmation."),
+    json: bool = typer.Option(False, "--json"),
+) -> None:
+    """End the current work session."""
+    output.configure(json_mode=json)
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    _run_end_session(
+        client,
+        project.id,
+        session,
+        interactive=not json,
+        note=note,
+        progress=progress,
+        no_review=no_review,
+        no_memory=no_memory,
+        assume_yes=yes,
+        json_mode=json,
+    )
+
+
+def _run_end_session(
+    client: APIClient,
+    project_id: int,
+    session: ActiveSession,
+    *,
+    interactive: bool = True,
+    note: Optional[str] = None,
+    progress: Optional[str] = None,
+    no_review: bool = False,
+    no_memory: bool = False,
+    assume_yes: bool = False,
+    json_mode: bool = False,
+) -> None:
+    """Core session end flow. Called from session end command and resume switching."""
+    session_client = APIClient(base_url=client.base_url, token=client.token, session_id=session.id)
+    review: dict = {}
+    if not no_review:
+        try:
+            review_response = client.get("/api/cli/session/review/", params={"session_id": str(session.id)})
+            review = _review_data(review_response)
+            if interactive:
+                _display_review(review)
+        except APIError as exc:
+            if interactive:
+                output.warn(f"Could not load session review: {exc}")
+
+    payload: dict = {"session_id": session.id}
+    changed_memory: list[str] = []
+
+    if interactive:
+        if note is None:
+            note = questionary.text("Anything else worth remembering? (optional):").ask() or ""
+        if not no_memory:
+            update_memory = questionary.confirm(
+                "Review Project Memory before ending?", default=False
+            ).ask()
+            if update_memory:
+                changed_memory = _gather_memory_update(client, session, review=review)
+        if not assume_yes:
+            confirmed = questionary.confirm("End session?", default=True).ask()
+            if not confirmed:
+                output.info("Cancelled.")
+                raise SystemExit(7)
+
+    if note:
+        payload["session_note"] = note
+    if progress:
+        payload["session_progress"] = progress
+
+    try:
+        data = session_client.post("/api/cli/session/end/", json=payload)
+    except SessionAlreadyFinalizedError:
+        output.warn("This session was already ended from another client.")
+        output.hint("Run: pm resume")
+        raise SystemExit(8)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if json_mode:
+        output.print_json(data)
+        return
+
+    output.blank()
+    output.success("Session ended.")
+    output.success("Session summary saved.")
+    if changed_memory:
+        output.hint("Updated Project Memory: " + ", ".join(changed_memory))
+    output.blank()
+
+
+def _display_review(review: dict) -> None:
+    project = review.get("project", {})
+    project_name = project.get("name", "Project")
+    duration = output.format_duration(int(review.get("duration_seconds") or 0))
+    counts = review.get("counts", {})
+
+    output.blank()
+    output.rule("Session Review")
+    output.kv("Project", f"[bold]{project_name}[/bold]")
+    output.kv("Duration", duration)
+
+    summary_parts = []
+    labels = [
+        ("completed_tasks", "task completed", "tasks completed"),
+        ("resolved_issues", "issue resolved", "issues resolved"),
+        ("github_commits", "commit", "commits"),
+        ("github_issues_closed", "GitHub issue closed", "GitHub issues closed"),
+        ("changed_files", "file changed", "files changed"),
+    ]
+    for key, singular, plural in labels:
+        count = int(counts.get(key) or len(review.get(key, [])) or 0)
+        if count:
+            summary_parts.append(f"{count} {singular if count == 1 else plural}")
+    if summary_parts:
+        output.kv("Activity", " • ".join(summary_parts))
+
+    _display_compact_section("Completed Tasks", review.get("completed_tasks", []), icon="✓")
+    _display_compact_section("Resolved Project Memory Issues", review.get("resolved_issues", []), icon="✓")
+    _display_compact_section("GitHub Commits", review.get("github_commits", []), icon="•")
+    _display_compact_section("GitHub Issues Closed", review.get("github_issues_closed", []), icon="✓")
+    _display_compact_section("Files Changed", review.get("changed_files", []), icon="•", limit=5)
+
+    memory = review.get("memory", {})
+    if memory:
+        output.header("Current Project Memory")
+        for label, key in [("Next Action", "next_action"), ("Current Status", "current_status"), ("Important Context", "important_context")]:
+            field = memory.get(key, {}) or {}
+            title = field.get("title") or field.get("text") or "(none)"
+            output.kv(label, _short_text(title, 100))
+    output.blank()
+
+
+def _gather_memory_update(client: APIClient, session: ActiveSession, *, review: dict | None = None) -> list[str]:
+    """Optionally update memory fields using normal backend operations."""
+    from projectmemory_cli.commands.memory import memory_context_set, memory_status_set
+    from projectmemory_cli.commands.next_action import run_next_action_menu
+    from projectmemory_cli.project_context import fetch_projects, find_project_by_name_or_id
+
+    projects = fetch_projects(client)
+    project = find_project_by_name_or_id(projects, str(session.project))
+    if not project:
+        output.warn("Could not resolve project for memory update.")
+        return []
+
+    changed: list[str] = []
+    while True:
+        choice = questionary.select(
+            "Update Project Memory:",
+            choices=[
+                questionary.Choice("Next Action", value="next"),
+                questionary.Choice("Current Status", value="status"),
+                questionary.Choice("Important Context", value="context"),
+                questionary.Choice("Done", value="done"),
+            ],
+        ).ask()
+        if not choice or choice == "done":
+            break
+        if choice == "next":
+            if run_next_action_menu(client, project, session):
+                changed.append("Next Action")
+        elif choice == "status":
+            memory_status_set(text=None, editor=False, stdin=False, project_arg=str(project.id))
+            changed.append("Current Status")
+        elif choice == "context":
+            memory_context_set(text=None, editor=False, stdin=False, project_arg=str(project.id))
+            changed.append("Important Context")
+    return changed