projectmemory-cli 0.1.0__py3-none-any.whl

projectmemory_cli/commands/issues.py

@@ -0,0 +1,234 @@
+"""Issue commands: pm issue list/show/add/edit/resolve/reopen/delete."""
+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.models.api import Issue
+from projectmemory_cli.project_context import guard_project_session
+
+app = typer.Typer(help="Issue 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_issue(issue: Issue) -> None:
+    status = "✓ resolved" if issue.is_resolved else "✗ open"
+    na = " [dim]→ next action[/dim]" if issue.is_next_action else ""
+    output.info(f"  {status}  [bold]#{issue.id}[/bold] {issue.description}{na}")
+    if issue.resolution_notes:
+        output.hint(f"      Resolution: {issue.resolution_notes[:80]}")
+    if issue.github_issue:
+        gh = issue.github_issue
+        output.hint(f"      GitHub #{gh.get('number', '?')}: {gh.get('state', '')}")
+
+
+@app.command("list")
+def issue_list(
+    status: str = typer.Option("open", "--status", "-s", help="open|resolved|all"),
+    open_only: bool = typer.Option(False, "--open", help="Show open issues."),
+    resolved: bool = typer.Option(False, "--resolved", help="Show resolved issues."),
+    all_issues: bool = typer.Option(False, "--all", help="Show all issues."),
+    search: Optional[str] = typer.Option(None, "--search"),
+    json: bool = typer.Option(False, "--json"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """List issues for the current project."""
+    output.configure(json_mode=json)
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+
+    if all_issues:
+        status = "all"
+    elif resolved:
+        status = "resolved"
+    elif open_only:
+        status = "open"
+
+    params: dict = {"status": status}
+    if search:
+        params["search"] = search
+
+    try:
+        data = client.get(f"/api/cli/projects/{project.id}/issues/", params=params)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if json:
+        output.print_json(data)
+        return
+
+    issues = [Issue.model_validate(i) for i in data.get("issues", [])]
+    if not issues:
+        output.hint("No issues.")
+        return
+
+    headers = ["#", "Status", "Description", "Next Action"]
+    rows = [
+        [str(i.id), "resolved" if i.is_resolved else "open", i.description[:60], "✓" if i.is_next_action else ""]
+        for i in issues
+    ]
+    output.table(headers, rows, title=f"{project.name} — Issues")
+    counts = data.get("counts", {})
+    if counts:
+        output.hint(f"open: {counts.get('open', 0)}  resolved: {counts.get('resolved', 0)}")
+
+
+@app.command("show")
+def issue_show(
+    issue_id: int = typer.Argument(...),
+    json: bool = typer.Option(False, "--json"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Show issue details."""
+    output.configure(json_mode=json)
+    client = _require_client()
+    guard_project_session(client, project_arg=project_arg)
+    try:
+        data = client.get(f"/api/cli/issues/{issue_id}/")
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    if json:
+        output.print_json(data)
+        return
+    issue = Issue.model_validate(data.get("issue", {}))
+    output.blank()
+    _display_issue(issue)
+    output.blank()
+
+
+@app.command("add")
+def issue_add(
+    description: Optional[str] = typer.Argument(None, help="Issue description."),
+    next_action: bool = typer.Option(False, "--next", help="Set as Next Action."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Report a new issue."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    if not description:
+        description = questionary.text("Issue description:").ask()
+        if not description:
+            raise SystemExit(7)
+
+    payload: dict = {"description": description}
+    if next_action:
+        payload["set_as_next_action"] = True
+
+    try:
+        data = sc.post(f"/api/cli/projects/{project.id}/issues/", json=payload, project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    issue = Issue.model_validate(data.get("issue", {}))
+    output.success(f"Issue #{issue.id} created.")
+    if next_action:
+        output.success("Set as Next Action.")
+
+
+@app.command("edit")
+def issue_edit(
+    issue_id: int = typer.Argument(...),
+    description: Optional[str] = typer.Argument(None),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Edit an issue description."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    if not description:
+        description = questionary.text("New description:").ask()
+        if not description:
+            raise SystemExit(7)
+
+    try:
+        sc.patch(f"/api/cli/issues/{issue_id}/", json={"description": description}, project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success(f"Issue #{issue_id} updated.")
+
+
+@app.command("resolve")
+def issue_resolve(
+    issue_id: int = typer.Argument(...),
+    notes: Optional[str] = typer.Option(None, "--resolution", "--notes", "-n", help="Resolution notes."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Mark an issue as resolved."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    if notes is None:
+        notes = questionary.text("Resolution notes (optional):").ask() or ""
+
+    try:
+        sc.post(f"/api/cli/issues/{issue_id}/resolve/", json={"resolution_notes": notes}, project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success(f"Issue #{issue_id} resolved.")
+
+
+@app.command("reopen")
+def issue_reopen(
+    issue_id: int = typer.Argument(...),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Reopen a resolved issue."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+    try:
+        sc.post(f"/api/cli/issues/{issue_id}/reopen/", project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success(f"Issue #{issue_id} reopened.")
+
+
+@app.command("delete")
+def issue_delete(
+    issue_id: int = typer.Argument(...),
+    yes: bool = typer.Option(False, "--yes", "-y"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Delete an issue."""
+    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 issue #{issue_id}?", default=False)
+        if not confirmed:
+            output.info("Cancelled.")
+            raise SystemExit(7)
+
+    try:
+        sc.delete(f"/api/cli/issues/{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} deleted.")

projectmemory_cli/commands/memory.py

@@ -0,0 +1,235 @@
+"""Memory commands: pm memory show, pm memory status set, pm memory context set, pm memory update."""
+from __future__ import annotations
+
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+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 Memory
+from projectmemory_cli.project_context import guard_project_session
+
+app = typer.Typer(help="Project Memory 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 _open_in_editor(initial: str = "") -> str:
+    editor = config.get_editor()
+    with tempfile.NamedTemporaryFile(suffix=".txt", mode="w", delete=False) as f:
+        f.write(initial)
+        fname = f.name
+    try:
+        subprocess.call([editor, fname])
+        return Path(fname).read_text().strip()
+    finally:
+        Path(fname).unlink(missing_ok=True)
+
+
+def _display_memory(memory: Memory, project_name: str = "") -> None:
+    if project_name:
+        output.project_banner(project_name)
+    output.blank()
+
+    output.header("Next Action")
+    na = memory.next_action
+    if na.title:
+        output.info(f"  {na.title}")
+        if na.linked_source:
+            src = na.linked_source
+            output.hint(f"  Linked {src.type} #{src.id}")
+    else:
+        output.hint("  (none)")
+
+    output.blank()
+    output.header("Current Status")
+    if memory.current_status.title:
+        output.info(f"  {memory.current_status.title}")
+    else:
+        output.hint("  (none)")
+
+    output.blank()
+    output.header("Important Context")
+    if memory.important_context.title:
+        output.info(f"  {memory.important_context.title}")
+    else:
+        output.hint("  (none)")
+
+    output.blank()
+
+
+@app.command("show")
+def memory_show(
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+    json: bool = typer.Option(False, "--json"),
+) -> None:
+    """Display the current Project Memory."""
+    client = _require_client()
+    try:
+        project, session = guard_project_session(client, project_arg=project_arg)
+    except SystemExit:
+        raise
+
+    try:
+        data = client.get(f"/api/cli/projects/{project.id}/memory/")
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if json:
+        output.print_json(data)
+        return
+
+    memory = Memory.model_validate(data.get("memory", {}))
+    _display_memory(memory, project_name=project.name)
+    if project.last_memory_updated_at:
+        output.kv("Last memory updated", output.format_ago(project.last_memory_updated_at))
+
+
+# ---------------------------------------------------------------------------
+# pm memory status set
+# ---------------------------------------------------------------------------
+
+status_app = typer.Typer(help="Current Status commands.", no_args_is_help=False)
+app.add_typer(status_app, name="status")
+
+
+@status_app.command("set")
+def memory_status_set(
+    text: Optional[str] = typer.Argument(None, help="Status text."),
+    editor: bool = typer.Option(False, "--editor", "-e", help="Open in editor."),
+    stdin: bool = typer.Option(False, "--stdin", help="Read from stdin."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Set the Current Status."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    session_client = APIClient(base_url=client.base_url, token=client.token, session_id=session.id)
+
+    if stdin:
+        text = sys.stdin.read().strip()
+    elif editor:
+        text = _open_in_editor(text or "")
+    elif not text:
+        text = questionary.text("Current Status:").ask() or ""
+
+    if not text:
+        output.info("No changes made.")
+        raise SystemExit(0)
+
+    try:
+        session_client.patch(
+            f"/api/cli/projects/{project.id}/memory/",
+            json={"current_status": {"title": text}},
+            project_name=project.name,
+        )
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success(f"Current Status updated.")
+
+
+# ---------------------------------------------------------------------------
+# pm memory context set
+# ---------------------------------------------------------------------------
+
+context_app = typer.Typer(help="Important Context commands.", no_args_is_help=False)
+app.add_typer(context_app, name="context")
+
+
+@context_app.command("set")
+def memory_context_set(
+    text: Optional[str] = typer.Argument(None, help="Context text."),
+    editor: bool = typer.Option(False, "--editor", "-e", help="Open in editor."),
+    stdin: bool = typer.Option(False, "--stdin", help="Read from stdin."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Set the Important Context."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    session_client = APIClient(base_url=client.base_url, token=client.token, session_id=session.id)
+
+    if stdin:
+        text = sys.stdin.read().strip()
+    elif editor:
+        text = _open_in_editor(text or "")
+    elif not text:
+        text = questionary.text("Important Context:").ask() or ""
+
+    if not text:
+        output.info("No changes made.")
+        raise SystemExit(0)
+
+    try:
+        session_client.patch(
+            f"/api/cli/projects/{project.id}/memory/",
+            json={"important_context": {"title": text}},
+            project_name=project.name,
+        )
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success("Important Context updated.")
+
+
+# ---------------------------------------------------------------------------
+# pm memory update (interactive menu)
+# ---------------------------------------------------------------------------
+
+@app.command("update")
+def memory_update(
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Interactively update Project Memory fields."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    session_client = APIClient(base_url=client.base_url, token=client.token, session_id=session.id)
+
+    choice = questionary.select(
+        "Update:",
+        choices=[
+            questionary.Choice("Next Action", value="next"),
+            questionary.Choice("Current Status", value="status"),
+            questionary.Choice("Important Context", value="context"),
+            questionary.Choice("Open Issues", value="issues"),
+        ],
+    ).ask()
+
+    if not choice:
+        raise SystemExit(7)
+
+    if choice == "next":
+        from projectmemory_cli.commands.next_action import next_set
+        next_set(text=None, project_arg=project_arg)
+    elif choice == "status":
+        memory_status_set(text=None, editor=False, stdin=False, project_arg=project_arg)
+    elif choice == "context":
+        memory_context_set(text=None, editor=False, stdin=False, project_arg=project_arg)
+    elif choice == "issues":
+        from projectmemory_cli.commands.issues import issue_add, issue_list
+        action = questionary.select(
+            "Open Issues:",
+            choices=[
+                questionary.Choice("List open issues", value="list"),
+                questionary.Choice("Add issue", value="add"),
+                questionary.Choice("Cancel", value="cancel"),
+            ],
+        ).ask()
+        if action == "list":
+            issue_list(status="open", open_only=True, resolved=False, all_issues=False, search=None, json=False, project_arg=project_arg)
+        elif action == "add":
+            issue_add(description=None, next_action=False, project_arg=project_arg)