projectmemory-cli 0.1.0__py3-none-any.whl

projectmemory_cli/commands/next_action.py

@@ -0,0 +1,282 @@
+"""Next Action commands: pm next, pm next set, pm next task, pm next issue, pm next clear."""
+from __future__ import annotations
+
+from typing import Optional
+
+import questionary
+import typer
+
+from projectmemory_cli import output
+from projectmemory_cli.api.client import APIClient
+from projectmemory_cli.api.errors import APIError
+from projectmemory_cli.project_context import guard_project_session
+
+app = typer.Typer(help="Next Action commands.", no_args_is_help=False)
+
+
+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 _session_client(client: APIClient, session_id: int) -> APIClient:
+    return APIClient(base_url=client.base_url, token=client.token, session_id=session_id, debug=client.debug)
+
+
+def _display_next_action(na: dict) -> None:
+    title = na.get("title", "")
+    source_type = na.get("source_type", "manual")
+    linked = na.get("linked_source")
+
+    if not title:
+        output.info("[dim](no next action set)[/dim]")
+        return
+
+    output.blank()
+    output.header("Next Action")
+    output.info(f"  {title}")
+    if source_type == "manual":
+        output.hint("  Manual")
+    elif linked:
+        t = linked.get("type", source_type)
+        lid = linked.get("id", "")
+        ltitle = linked.get("title", "")
+        output.hint(f"  Linked {t} #{lid}: {ltitle}")
+    else:
+        output.hint(f"  Source: {source_type}")
+    output.blank()
+
+
+def run_next_action_menu(client: APIClient, project, session, *, project_arg: str | None = None) -> bool:
+    """Run the same unified Next Action choices used by web, via CLI orchestration.
+
+    Returns True when a backend change was attempted successfully.
+    """
+    session_client = _session_client(client, session.id)
+    choice = questionary.select(
+        "Next Action:",
+        choices=[
+            questionary.Choice("Write Next Action", value="write"),
+            questionary.Choice("Create and link a task", value="create_task"),
+            questionary.Choice("Link an existing task", value="link_task"),
+            questionary.Choice("Link an open issue", value="link_issue"),
+            questionary.Choice("Clear Next Action", value="clear"),
+            questionary.Choice("Cancel", value="cancel"),
+        ],
+    ).ask()
+
+    if not choice or choice == "cancel":
+        return False
+
+    try:
+        if choice == "write":
+            text = questionary.text("Next Action:").ask()
+            if not text:
+                return False
+            data = session_client.patch(
+                f"/api/cli/projects/{project.id}/next-action/",
+                json={"title": text},
+                project_name=project.name,
+            )
+            output.success(f"Next Action set: [bold]{text}[/bold]")
+            _display_next_action(data.get("next_action", {}))
+            return True
+
+        if choice == "create_task":
+            title = questionary.text("Task title:").ask()
+            if not title:
+                return False
+            task_data = session_client.post(
+                f"/api/cli/projects/{project.id}/tasks/",
+                json={"title": title},
+                project_name=project.name,
+            )
+            task_id = task_data["task"]["id"]
+            data = session_client.post(
+                f"/api/cli/projects/{project.id}/next-action/task/",
+                json={"task_id": task_id},
+                project_name=project.name,
+            )
+            output.success(f"Task #{task_id} created and set as Next Action.")
+            _display_next_action(data.get("next_action", {}))
+            return True
+
+        if choice == "link_task":
+            tasks_data = client.get(f"/api/cli/projects/{project.id}/tasks/", params={"status": "open"})
+            tasks = tasks_data.get("tasks", [])
+            if not tasks:
+                output.warn("No open tasks.")
+                return False
+            task = questionary.select(
+                "Select task:",
+                choices=[questionary.Choice(f"#{t['id']} {t['title']}", value=t) for t in tasks],
+            ).ask()
+            if not task:
+                return False
+            data = session_client.post(
+                f"/api/cli/projects/{project.id}/next-action/task/",
+                json={"task_id": task["id"]},
+                project_name=project.name,
+            )
+            output.success(f"Task #{task['id']} set as Next Action.")
+            _display_next_action(data.get("next_action", {}))
+            return True
+
+        if choice == "link_issue":
+            issues_data = client.get(f"/api/cli/projects/{project.id}/issues/", params={"status": "open"})
+            issues = issues_data.get("issues", [])
+            if not issues:
+                output.warn("No open issues.")
+                return False
+            issue = questionary.select(
+                "Select issue:",
+                choices=[questionary.Choice(f"#{i['id']} {i['description']}", value=i) for i in issues],
+            ).ask()
+            if not issue:
+                return False
+            data = session_client.post(
+                f"/api/cli/projects/{project.id}/next-action/issue/",
+                json={"issue_id": issue["id"]},
+                project_name=project.name,
+            )
+            output.success(f"Issue #{issue['id']} set as Next Action.")
+            _display_next_action(data.get("next_action", {}))
+            return True
+
+        if choice == "clear":
+            data = session_client.post(
+                f"/api/cli/projects/{project.id}/next-action/clear/",
+                project_name=project.name,
+            )
+            output.success("Next Action cleared.")
+            _display_next_action(data.get("next_action", {}))
+            return True
+
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    return False
+
+
+@app.callback(invoke_without_command=True)
+def next_default(
+    ctx: typer.Context,
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Show the current Next Action when no subcommand is supplied."""
+    if ctx.invoked_subcommand is not None:
+        return
+    next_show(project_arg=project_arg)
+
+
+@app.command("show")
+def next_show(
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Show the current Next Action."""
+    client = _require_client()
+    project, _session = guard_project_session(client, project_arg=project_arg)
+    try:
+        data = client.get(f"/api/cli/projects/{project.id}/next-action/")
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    _display_next_action(data.get("next_action", {}))
+
+
+@app.command("set")
+def next_set(
+    text: Optional[str] = typer.Argument(None, help="Next Action text. Omit for interactive menu."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Set the Next Action manually or use the unified interactive menu."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    session_client = _session_client(client, session.id)
+
+    if text:
+        try:
+            data = session_client.patch(
+                f"/api/cli/projects/{project.id}/next-action/",
+                json={"title": text},
+                project_name=project.name,
+            )
+        except APIError as exc:
+            output.error(str(exc))
+            raise SystemExit(exc.exit_code)
+        output.success(f"Next Action set: [bold]{text}[/bold]")
+        _display_next_action(data.get("next_action", {}))
+        return
+
+    changed = run_next_action_menu(client, project, session, project_arg=project_arg)
+    if not changed:
+        output.info("No changes made.")
+
+
+@app.command("task")
+def next_task(
+    task_id: int = typer.Argument(..., help="Task ID to set as Next Action."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Link a task as the Next Action."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    session_client = _session_client(client, session.id)
+    try:
+        data = session_client.post(
+            f"/api/cli/projects/{project.id}/next-action/task/",
+            json={"task_id": task_id},
+            project_name=project.name,
+        )
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success(f"Task #{task_id} set as Next Action.")
+    _display_next_action(data.get("next_action", {}))
+
+
+@app.command("issue")
+def next_issue(
+    issue_id: int = typer.Argument(..., help="Issue ID to set as Next Action."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Link an issue as the Next Action."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    session_client = _session_client(client, session.id)
+    try:
+        data = session_client.post(
+            f"/api/cli/projects/{project.id}/next-action/issue/",
+            json={"issue_id": issue_id},
+            project_name=project.name,
+        )
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success(f"Issue #{issue_id} set as Next Action.")
+    _display_next_action(data.get("next_action", {}))
+
+
+@app.command("clear")
+def next_clear(
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Clear the Next Action."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    session_client = _session_client(client, session.id)
+    try:
+        data = session_client.post(
+            f"/api/cli/projects/{project.id}/next-action/clear/",
+            project_name=project.name,
+        )
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success("Next Action cleared.")
+    _display_next_action(data.get("next_action", {}))

projectmemory_cli/commands/notes.py

@@ -0,0 +1,231 @@
+"""Note commands: pm note list/show/add/edit/delete, pm capture."""
+from __future__ import annotations
+
+import sys
+from typing import Optional
+
+import questionary
+import typer
+
+from projectmemory_cli import output
+from projectmemory_cli.api.client import APIClient
+from projectmemory_cli.api.errors import APIError
+from projectmemory_cli.models.api import Note
+from projectmemory_cli.project_context import guard_project_session
+
+app = typer.Typer(help="Note 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 _session_client(client: APIClient, session_id: int) -> APIClient:
+    return APIClient(base_url=client.base_url, token=client.token, session_id=session_id)
+
+
+def _display_note(note: Note) -> None:
+    output.blank()
+    if note.title:
+        output.info(f"[bold]#{note.id} {note.title}[/bold]")
+    else:
+        output.info(f"[bold]#{note.id}[/bold]")
+    output.info(note.content)
+    output.hint(f"Updated {output.format_ago(note.updated_at)}")
+    output.blank()
+
+
+@app.command("list")
+def note_list(
+    search: Optional[str] = typer.Option(None, "--search", help="Search query."),
+    json: bool = typer.Option(False, "--json"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """List notes for the current project."""
+    output.configure(json_mode=json)
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+
+    params: dict = {}
+    if search:
+        params["search"] = search
+
+    try:
+        data = client.get(f"/api/cli/projects/{project.id}/notes/", params=params)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if json:
+        output.print_json(data)
+        return
+
+    notes = [Note.model_validate(n) for n in data.get("notes", [])]
+    if not notes:
+        output.hint("No notes.")
+        return
+    headers = ["#", "Title", "Updated"]
+    rows = [[str(n.id), n.title or n.content[:50], output.format_ago(n.updated_at)] for n in notes]
+    output.table(headers, rows, title=f"{project.name} — Notes ({data.get('count', len(notes))})")
+
+
+@app.command("show")
+def note_show(
+    note_id: int = typer.Argument(...),
+    json: bool = typer.Option(False, "--json"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Show a note's full content."""
+    output.configure(json_mode=json)
+    client = _require_client()
+    guard_project_session(client, project_arg=project_arg)
+    try:
+        data = client.get(f"/api/cli/notes/{note_id}/")
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    if json:
+        output.print_json(data)
+        return
+    note = Note.model_validate(data.get("note", {}))
+    _display_note(note)
+
+
+@app.command("add")
+def note_add(
+    content: Optional[str] = typer.Argument(None, help="Note content."),
+    title: Optional[str] = typer.Option(None, "--title", "-t", help="Note title."),
+    editor: bool = typer.Option(False, "--editor", "-e", help="Open editor for note content."),
+    stdin: bool = typer.Option(False, "--stdin", help="Read content from stdin."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Add a note to the current project."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    if stdin or (not content and not sys.stdin.isatty()):
+        content = sys.stdin.read().strip()
+    elif editor:
+        from projectmemory_cli.commands.memory import _open_in_editor
+        content = _open_in_editor(content or "")
+    elif not content:
+        content = questionary.text("Note content:").ask() or ""
+
+    if not content:
+        output.info("No content provided.")
+        raise SystemExit(0)
+
+    if not title:
+        title = ""
+
+    try:
+        data = sc.post(
+            f"/api/cli/projects/{project.id}/notes/",
+            json={"content": content, "title": title},
+            project_name=project.name,
+        )
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    note = Note.model_validate(data.get("note", {}))
+    output.success(f"Note #{note.id} created.")
+
+
+@app.command("edit")
+def note_edit(
+    note_id: int = typer.Argument(...),
+    title: Optional[str] = typer.Option(None, "--title", "-t"),
+    content: Optional[str] = typer.Option(None, "--content"),
+    editor: bool = typer.Option(False, "--editor", "-e"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Edit a note."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    payload: dict = {}
+    if title is not None:
+        payload["title"] = title
+
+    if editor:
+        # Fetch current content first
+        try:
+            current_data = client.get(f"/api/cli/notes/{note_id}/")
+            current_note = current_data.get("note", {})
+            current_content = current_note.get("content", "")
+        except APIError:
+            current_content = ""
+
+        from projectmemory_cli.commands.memory import _open_in_editor
+        content = _open_in_editor(current_content)
+
+    if content is not None:
+        payload["content"] = content
+
+    if not payload:
+        output.warn("No changes specified.")
+        raise SystemExit(0)
+
+    try:
+        sc.patch(f"/api/cli/notes/{note_id}/", json=payload, project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success(f"Note #{note_id} updated.")
+
+
+@app.command("delete")
+def note_delete(
+    note_id: int = typer.Argument(...),
+    yes: bool = typer.Option(False, "--yes", "-y"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Delete a note."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    if not yes:
+        confirmed = typer.confirm(f"Delete note #{note_id}?", default=False)
+        if not confirmed:
+            output.info("Cancelled.")
+            raise SystemExit(7)
+
+    try:
+        sc.delete(f"/api/cli/notes/{note_id}/", project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success(f"Note #{note_id} deleted.")
+
+
+# ---------------------------------------------------------------------------
+# pm capture — quick note shortcut
+# ---------------------------------------------------------------------------
+
+@app.command("search")
+def note_search(
+    query: str = typer.Argument(..., help="Search query."),
+    json: bool = typer.Option(False, "--json"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Search notes in the current project."""
+    note_list(search=query, json=json, project_arg=project_arg)
+
+
+def capture(
+    text: Optional[str] = typer.Argument(None, help="Note content."),
+    title: Optional[str] = typer.Option(None, "--title", "-t"),
+    stdin: bool = typer.Option(False, "--stdin"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Quick note capture (shortcut for pm note add)."""
+    note_add(content=text, title=title, editor=False, stdin=stdin, project_arg=project_arg)