projectmemory-cli 0.1.0__py3-none-any.whl

projectmemory_cli/commands/projects.py

@@ -0,0 +1,325 @@
+"""Project commands: pm project list/create/current/link/unlink, pm web."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import questionary
+import typer
+
+from projectmemory_cli import config, git, output
+from projectmemory_cli.api.client import APIClient
+from projectmemory_cli.api.errors import APIError
+from projectmemory_cli.models.api import ProjectSummary
+from projectmemory_cli.project_context import (
+    fetch_projects,
+    get_mapped_project_id_for_cwd,
+    remove_repo_mapping,
+    resolve_project,
+    save_repo_mapping,
+    select_project_interactive,
+)
+
+app = typer.Typer(help="Project management 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()
+
+
+# ---------------------------------------------------------------------------
+# pm project list
+# ---------------------------------------------------------------------------
+
+@app.command("list")
+def project_list(
+    json: bool = typer.Option(False, "--json", help="Output as JSON."),
+    plain: bool = typer.Option(False, "--plain", help="Plain text output."),
+) -> None:
+    """List all accessible projects."""
+    output.configure(json_mode=json, plain_mode=plain)
+    client = _require_client()
+
+    try:
+        projects = fetch_projects(client)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if json:
+        import json as _json
+        output.print_json([p.model_dump() for p in projects])
+        return
+
+    current_id = config.get_current_project_id()
+    mapped = get_mapped_project_id_for_cwd()
+    mapped_id = str(mapped[0]) if mapped else ""
+
+    if not projects:
+        output.info("No projects found. Run: pm project create")
+        return
+
+    headers = ["#", "Name", "Status", "Session", "Updated"]
+    rows = []
+    for p in projects:
+        marker = ""
+        if str(p.id) == current_id:
+            marker = "● "
+        if mapped_id and str(p.id) == mapped_id:
+            marker += "⚑ "
+        session_text = "active" if p.has_active_session else "—"
+        updated = output.format_ago(p.last_updated_at or p.updated_at)
+        rows.append([marker + str(p.id), p.name, p.status, session_text, updated])
+
+    output.table(headers, rows, title="Projects")
+    output.blank()
+    output.hint("● = current project   ⚑ = mapped to this directory")
+
+
+# ---------------------------------------------------------------------------
+# pm project create
+# ---------------------------------------------------------------------------
+
+@app.command("create")
+def project_create(
+    name: Optional[str] = typer.Option(None, "--name", help="Project name."),
+    description: Optional[str] = typer.Option(None, "--description", help="Project description."),
+    next_action: Optional[str] = typer.Option(None, "--next", help="Initial Next Action."),
+    status_text: Optional[str] = typer.Option(None, "--status-text", help="Current Status."),
+    context: Optional[str] = typer.Option(None, "--context", help="Important Context."),
+    link_repo: bool = typer.Option(False, "--link-repo", help="Link current git repo."),
+    no_interactive: bool = typer.Option(False, "--no-interactive", help="Skip all prompts."),
+) -> None:
+    """Create a new project and start its first session."""
+    client = _require_client()
+
+    if not no_interactive:
+        if not name:
+            name = questionary.text("Project name:").ask()
+            if not name:
+                output.info("Cancelled.")
+                raise SystemExit(7)
+        if description is None:
+            description = questionary.text("Description (optional):").ask() or ""
+
+        # Optional memory init
+        init = questionary.confirm("Initialize Project Memory now?", default=True).ask()
+        if init:
+            if next_action is None:
+                next_action = questionary.text("Next Action (optional):").ask() or ""
+            if status_text is None:
+                status_text = questionary.text("Current Status (optional):").ask() or ""
+            if context is None:
+                context = questionary.text("Important Context (optional):").ask() or ""
+
+    if not name:
+        output.error("Project name is required.")
+        raise SystemExit(4)
+
+    payload: dict = {"name": name, "description": description or ""}
+    if next_action:
+        payload["next_action"] = next_action
+    if status_text:
+        payload["status_text"] = status_text
+    if context:
+        payload["context"] = context
+
+    try:
+        data = client.post("/api/cli/projects/", json=payload)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    project_data = data.get("project", {})
+    project = ProjectSummary.model_validate(project_data)
+    active_session = project.active_session
+
+    output.blank()
+    output.success(f"Project created.")
+    output.success(f"Current project: [bold]{project.name}[/bold]")
+    if active_session:
+        output.success("Session started.")
+
+    # Set as current
+    config.set_current_project(project.id)
+
+    # Offer repo link
+    in_git = git.is_git_repo()
+    linked = False
+    if in_git and not no_interactive:
+        do_link = questionary.confirm("Link this repository to the project?", default=True).ask()
+        if do_link:
+            _do_link_repo(project.id, project.name)
+            linked = True
+    elif link_repo and in_git:
+        _do_link_repo(project.id, project.name)
+        linked = True
+
+    if linked:
+        output.success("Repository linked.")
+
+    output.blank()
+
+
+# ---------------------------------------------------------------------------
+# pm project current
+# ---------------------------------------------------------------------------
+
+@app.command("current")
+def project_current() -> None:
+    """Show the current CLI project and session status."""
+    client = _require_client()
+    current_id = config.get_current_project_id()
+
+    resolution = "stored"
+    mapped = get_mapped_project_id_for_cwd()
+    if mapped:
+        current_id = str(mapped[0])
+        resolution = "directory mapping"
+
+    if not current_id:
+        output.warn("No current project set.")
+        output.hint("Run: pm resume")
+        return
+
+    try:
+        projects = fetch_projects(client)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    from projectmemory_cli.project_context import find_project_by_name_or_id
+    project = find_project_by_name_or_id(projects, current_id)
+    if not project:
+        output.warn(f"Stored project ID {current_id!r} not found.")
+        return
+
+    output.blank()
+    output.kv("Project", f"[bold]{project.name}[/bold]")
+    output.kv("ID", str(project.id))
+    output.kv("Resolved via", resolution)
+    output.kv("Status", project.status)
+
+    if project.has_active_session and project.active_session:
+        s = project.active_session
+        output.kv("Session", f"active (started {output.format_ago(s.started_at)})")
+    else:
+        output.kv("Session", "[dim]none[/dim]")
+        output.hint("Run: pm resume")
+
+    output.blank()
+
+
+# ---------------------------------------------------------------------------
+# pm project link
+# ---------------------------------------------------------------------------
+
+@app.command("link")
+def project_link(
+    project_arg: Optional[str] = typer.Argument(None, help="Project name or ID."),
+) -> None:
+    """Link the current directory/git repo to a Project Memory project."""
+    client = _require_client()
+
+    try:
+        project = resolve_project(client, arg=project_arg)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if not project:
+        output.error("No project selected.")
+        raise SystemExit(1)
+
+    _do_link_repo(project.id, project.name, check_mismatch=True, project=project)
+
+
+# ---------------------------------------------------------------------------
+# pm project unlink
+# ---------------------------------------------------------------------------
+
+@app.command("unlink")
+def project_unlink() -> None:
+    """Remove the current directory/git repo mapping."""
+    cwd = str(Path.cwd())
+    if remove_repo_mapping(cwd):
+        output.success("Directory mapping removed.")
+        return
+
+    root = git.get_repo_root()
+    if root and remove_repo_mapping(str(root)):
+        output.success("Repository mapping removed.")
+        return
+
+    output.warn("No mapping found for the current directory.")
+
+
+# ---------------------------------------------------------------------------
+# pm web
+# ---------------------------------------------------------------------------
+
+def web(
+    project_arg: Optional[str] = typer.Argument(None, help="Project name or ID."),
+) -> None:
+    """Open the current project workspace in the browser."""
+    import webbrowser
+    client = _require_client()
+
+    try:
+        project = resolve_project(client, arg=project_arg)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if not project:
+        output.error("No current project. Run: pm resume")
+        raise SystemExit(1)
+
+    url = project.web_url or f"https://projectmemory.app/app/projects/{project.id}/"
+    output.info(f"Opening [link]{url}[/link]")
+    webbrowser.open(url)
+
+
+# ---------------------------------------------------------------------------
+# Internal helper
+# ---------------------------------------------------------------------------
+
+def _do_link_repo(
+    project_id: int,
+    project_name: str,
+    *,
+    check_mismatch: bool = False,
+    project: Optional[ProjectSummary] = None,
+) -> None:
+    root = git.get_repo_root()
+    cwd = str(Path.cwd())
+    path_to_save = str(root) if root else cwd
+
+    if check_mismatch and project and root:
+        local_remote = git.normalize_github_repo(git.get_remote_url(root))
+        if local_remote and project.github.connected and project.github.repository:
+            expected = project.github.repository.full_name.lower()
+            if local_remote != expected:
+                output.warn(
+                    f"Remote mismatch: local repo is '{local_remote}' "
+                    f"but project is linked to '{expected}'."
+                )
+                confirmed = questionary.confirm("Link anyway?", default=False).ask()
+                if not confirmed:
+                    output.info("Link cancelled.")
+                    return
+
+    save_repo_mapping(path_to_save, project_id, project_name)
+
+    # Also save git remote key for multi-directory use
+    if root:
+        remote_name = git.normalize_github_repo(git.get_remote_url(root))
+        if remote_name:
+            save_repo_mapping(f"git_remote:{remote_name}", project_id, project_name)
+
+    output.success(f"Linked [bold]{path_to_save}[/bold] → {project_name}")

projectmemory_cli/commands/resume.py

@@ -0,0 +1,240 @@
+"""pm resume — begin or return to work on a project."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+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
+from projectmemory_cli.models.api import ActiveSession, ProjectContext, ProjectSummary
+from projectmemory_cli.project_context import (
+    fetch_projects,
+    get_active_session_for_project,
+    resolve_project,
+)
+
+_OLD_SESSION_HOURS = 24
+
+
+def _session_age_hours(session: ActiveSession) -> float:
+    try:
+        started = datetime.fromisoformat(session.started_at.replace("Z", "+00:00"))
+        return (datetime.now(timezone.utc) - started).total_seconds() / 3600
+    except Exception:
+        return 0.0
+
+
+def _display_resume(context: ProjectContext, session_state: str, *, show_tasks: bool = True) -> None:
+    p = context.project
+    session = context.active_session
+
+    output.blank()
+    output.project_banner(p.name)
+    output.blank()
+
+    if session_state == "resumed":
+        output.info("[bold]Resuming active session[/bold]")
+    else:
+        output.info("[bold]Starting a new session[/bold]")
+
+    if session:
+        output.info(f"Started {output.format_ago(session.started_at)}")
+
+    if p.last_updated_at:
+        output.kv("Last updated", output.format_ago(p.last_updated_at))
+    if p.last_memory_updated_at:
+        output.kv("Last memory updated", output.format_ago(p.last_memory_updated_at))
+
+    mem = context.memory
+    if mem.next_action.title:
+        output.blank()
+        output.header("Next Action")
+        output.info(f"  {mem.next_action.title}")
+        if mem.next_action.linked_source:
+            src = mem.next_action.linked_source
+            output.hint(f"  Linked {src.type} #{src.id}")
+
+    if mem.current_status.title:
+        output.blank()
+        output.header("Current Status")
+        output.info(f"  {mem.current_status.title}")
+
+    if mem.important_context.title:
+        output.blank()
+        output.header("Important Context")
+        output.info(f"  {mem.important_context.title}")
+
+    if context.open_issues:
+        output.blank()
+        output.header("Open Issues")
+        for issue in context.open_issues[:5]:
+            output.info(f"  [dim]#{issue['id']}[/dim] {issue['description']}")
+        if len(context.open_issues) > 5:
+            output.hint(f"  +{len(context.open_issues) - 5} more")
+
+    if show_tasks and context.open_tasks:
+        output.blank()
+        output.header("Open Tasks")
+        for task in context.open_tasks[:5]:
+            na = " [dim]→ next action[/dim]" if task.get("is_next_action") else ""
+            output.info(f"  [dim]#{task['id']}[/dim] {task['title']}{na}")
+        if len(context.open_tasks) > 5:
+            output.hint(f"  +{len(context.open_tasks) - 5} more")
+
+    output.blank()
+
+
+def _handle_old_session(client: APIClient, project: ProjectSummary, session: ActiveSession) -> Optional[ActiveSession]:
+    """Prompt user when session is unusually old. Return final session or None on cancel."""
+    age_h = _session_age_hours(session)
+    age_str = output.format_ago(session.started_at)
+    output.warn(f"This session started {age_str}.")
+    output.blank()
+
+    choice = questionary.select(
+        "What would you like to do?",
+        choices=[
+            questionary.Choice("Continue this session", value="continue"),
+            questionary.Choice("End it and start a new session", value="end_new"),
+            questionary.Choice("Cancel", value="cancel"),
+        ],
+    ).ask()
+
+    if choice == "cancel" or choice is None:
+        output.info("Cancelled.")
+        raise SystemExit(7)
+
+    if choice == "continue":
+        return session
+
+    if choice == "end_new":
+        from projectmemory_cli.commands.sessions import _run_end_session
+        _run_end_session(client, project.id, session, interactive=True)
+        return None  # caller will create new session
+
+    return session
+
+
+def _switch_prompt(current_project_name: str) -> str:
+    """Prompt when switching from a project with an active session."""
+    output.warn(f"[bold]{current_project_name}[/bold] still has an active session.")
+    output.blank()
+    choice = questionary.select(
+        "What would you like to do?",
+        choices=[
+            questionary.Choice("End Session and switch", value="end"),
+            questionary.Choice("Keep Session Active and switch", value="keep"),
+            questionary.Choice("Cancel", value="cancel"),
+        ],
+    ).ask()
+    return choice or "cancel"
+
+
+def resume(
+    project_arg: Optional[str] = typer.Argument(None, help="Project name or ID."),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Project name or ID."),
+    keep_session: bool = typer.Option(False, "--keep-session", help="Keep current project session active when switching."),
+    compact: bool = typer.Option(False, "--compact", help="Compact output."),
+    json: bool = typer.Option(False, "--json", help="Output as JSON."),
+    no_tasks: bool = typer.Option(False, "--no-tasks", help="Hide tasks in output."),
+    open_browser: bool = typer.Option(False, "--open", help="Open project in browser after resuming."),
+) -> None:
+    """Begin or resume work on a project."""
+    from projectmemory_cli import credentials
+    token = credentials.get_token()
+    if not token:
+        output.error("Not logged in. Run: pm login")
+        raise SystemExit(2)
+
+    output.configure(json_mode=json)
+    client = APIClient.from_env()
+
+    target_arg = project_arg or project
+
+    # Resolve target project
+    try:
+        target = resolve_project(client, arg=target_arg)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if not target:
+        output.error("No project selected. Run: pm resume <project-name>")
+        raise SystemExit(1)
+
+    # Check if we need to handle switching
+    current_id = config.get_current_project_id()
+    if current_id and str(current_id) != str(target.id) and not keep_session:
+        # Check if current project has an active session
+        current_session = get_active_session_for_project(client, int(current_id))
+        if current_session:
+            # Find current project name
+            try:
+                all_projects = fetch_projects(client)
+                from projectmemory_cli.project_context import find_project_by_name_or_id
+                current_proj = find_project_by_name_or_id(all_projects, current_id)
+                current_name = current_proj.name if current_proj else f"Project #{current_id}"
+            except APIError:
+                current_name = f"Project #{current_id}"
+
+            switch_choice = _switch_prompt(current_name)
+
+            if switch_choice == "cancel":
+                output.info("Cancelled.")
+                raise SystemExit(7)
+            if switch_choice == "end":
+                from projectmemory_cli.commands.sessions import _run_end_session
+                _run_end_session(client, int(current_id), current_session, interactive=True)
+
+    # Resume / start session for target project
+    try:
+        data = client.post(f"/api/cli/projects/{target.id}/resume/")
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    session_state = data.get("session_state", "started")
+    context_data = data.get("context", {})
+
+    try:
+        ctx = ProjectContext.model_validate(context_data)
+    except Exception:
+        ctx = None
+
+    active_session = ctx.active_session if ctx else None
+
+    # Check for old session
+    if active_session and _session_age_hours(active_session) > _OLD_SESSION_HOURS:
+        result = _handle_old_session(client, target, active_session)
+        if result is None:
+            # Start fresh
+            data = client.post(f"/api/cli/projects/{target.id}/resume/")
+            session_state = data.get("session_state", "started")
+            context_data = data.get("context", {})
+            ctx = ProjectContext.model_validate(context_data)
+            active_session = ctx.active_session if ctx else None
+
+    # Set as current project
+    config.set_current_project(target.id)
+
+    if json:
+        import json as _json
+        output.print_json(data)
+        return
+
+    if ctx:
+        if not compact:
+            _display_resume(ctx, session_state, show_tasks=not no_tasks)
+        else:
+            output.success(f"[bold]{target.name}[/bold] — {session_state}")
+    else:
+        output.success(f"[bold]{target.name}[/bold] — session {session_state}")
+
+    if open_browser:
+        import webbrowser
+        url = target.web_url or f"https://projectmemory.app/app/projects/{target.id}/"
+        webbrowser.open(url)