projectmemory-cli 0.1.0__py3-none-any.whl

projectmemory_cli/commands/tasks.py

@@ -0,0 +1,435 @@
+"""Task commands: pm task list/show/add/edit/done/snooze/reopen/delete, pm done."""
+from __future__ import annotations
+
+from typing import Optional
+
+import questionary
+import typer
+
+from projectmemory_cli import git, output
+from projectmemory_cli.api.client import APIClient
+from projectmemory_cli.api.errors import APIError
+from projectmemory_cli.models.api import Task, TaskCounts
+from projectmemory_cli.project_context import guard_project_session
+
+app = typer.Typer(help="Task 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()
+
+
+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_task(task: Task) -> None:
+    status = "✓" if task.is_completed else ("💤" if task.is_snoozed else "○")
+    na = " [dim]→ next action[/dim]" if task.is_next_action else ""
+    output.info(f"  {status} [bold]#{task.id}[/bold] {task.title}{na}")
+    if task.description:
+        output.hint(f"      {task.description[:100]}")
+    if task.priority != "medium":
+        output.hint(f"      Priority: {task.priority}")
+    if task.due_date:
+        output.hint(f"      Due: {task.due_date}")
+    if task.has_linked_commits:
+        output.hint(f"      Commits: {task.linked_commit_count}")
+
+
+def _display_tasks_table(tasks: list[Task], title: str = "Tasks") -> None:
+    if not tasks:
+        output.hint("(none)")
+        return
+    headers = ["#", "Status", "Title", "Priority", "Due"]
+    rows = []
+    for t in tasks:
+        status = "done" if t.is_completed else ("snoozed" if t.is_snoozed else "open")
+        na = " →" if t.is_next_action else ""
+        rows.append([str(t.id), status, t.title[:50] + na, t.priority, t.due_date or "—"])
+    output.table(headers, rows, title=title)
+
+
+def _offer_commit_link(client: APIClient, session_id: int, task: Task, project_id: int) -> None:
+    """After completing a task, optionally link a recent commit."""
+    root = git.get_repo_root()
+    if not root:
+        return
+
+    # Check if project has GitHub connection
+    try:
+        ctx_data = client.get(f"/api/cli/projects/{project_id}/context/")
+        github = ctx_data.get("github", {})
+        if not github.get("connected"):
+            return
+        repo_full_name = github.get("repository", {}).get("full_name", "")
+    except APIError:
+        return
+
+    commits = git.get_recent_commits(root, limit=10)
+    if not commits:
+        return
+
+    output.blank()
+    output.info("[bold]Recent commits:[/bold]")
+    choices = [questionary.Choice("Skip", value=None)]
+    choices.extend(questionary.Choice(f"{c.short_sha} {c.message[:60]}", value=c) for c in commits)
+
+    selected = questionary.select("Select a commit, or press Enter to skip:", choices=choices).ask()
+    if not selected:
+        return
+
+    sc = _session_client(client, session_id)
+    try:
+        sc.post(
+            f"/api/cli/tasks/{task.id}/commits/link/",
+            json={
+                "sha": selected.sha,
+                "message": selected.message,
+                "author_name": selected.author,
+                "repository_full_name": repo_full_name,
+            },
+            project_name=task.project_name,
+        )
+        output.success(f"Commit [dim]{selected.short_sha}[/dim] linked.")
+    except APIError as exc:
+        output.warn(f"Could not link commit: {exc}")
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+@app.command("list")
+def task_list(
+    status: str = typer.Option("open", "--status", "-s", help="open|completed|snoozed|all"),
+    open_only: bool = typer.Option(False, "--open", help="Show open tasks."),
+    completed: bool = typer.Option(False, "--completed", help="Show completed tasks."),
+    snoozed: bool = typer.Option(False, "--snoozed", help="Show snoozed tasks."),
+    all_tasks: bool = typer.Option(False, "--all", help="Show all tasks."),
+    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 tasks for the current project."""
+    output.configure(json_mode=json)
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+
+    if all_tasks:
+        status = "all"
+    elif completed:
+        status = "completed"
+    elif snoozed:
+        status = "snoozed"
+    elif open_only:
+        status = "open"
+
+    params: dict = {"status": status}
+    if search:
+        params["search"] = search
+
+    try:
+        data = client.get(f"/api/cli/projects/{project.id}/tasks/", params=params)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if json:
+        output.print_json(data)
+        return
+
+    tasks = [Task.model_validate(t) for t in data.get("tasks", [])]
+    counts = data.get("counts", {})
+    _display_tasks_table(tasks, title=f"{project.name} — {status} tasks")
+    output.hint(f"open: {counts.get('open', 0)}  snoozed: {counts.get('snoozed', 0)}  done: {counts.get('completed', 0)}")
+
+
+@app.command("show")
+def task_show(
+    task_id: int = typer.Argument(...),
+    json: bool = typer.Option(False, "--json"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Show details of a task."""
+    output.configure(json_mode=json)
+    client = _require_client()
+    guard_project_session(client, project_arg=project_arg)
+    try:
+        data = client.get(f"/api/cli/tasks/{task_id}/")
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    if json:
+        output.print_json(data)
+        return
+    task = Task.model_validate(data.get("task", {}))
+    output.blank()
+    _display_task(task)
+    if task.github_commits:
+        output.blank()
+        output.info("[bold]Linked commits:[/bold]")
+        for c in task.github_commits:
+            output.hint(f"  {c.get('short_sha','?')} {c.get('message','')[:60]}")
+    output.blank()
+
+
+@app.command("add")
+def task_add(
+    title: Optional[str] = typer.Argument(None, help="Task title."),
+    description: Optional[str] = typer.Option(None, "--description", "-d"),
+    priority: Optional[str] = typer.Option(None, "--priority", help="low|medium|high"),
+    due: Optional[str] = typer.Option(None, "--due", help="Due date (YYYY-MM-DD)."),
+    next_action: bool = typer.Option(False, "--next", help="Set as Next Action."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Add a new task."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    if not title:
+        title = questionary.text("Task title:").ask()
+        if not title:
+            raise SystemExit(7)
+
+    payload: dict = {"title": title}
+    if description:
+        payload["description"] = description
+    if priority:
+        payload["priority"] = priority
+    if due:
+        payload["due_date"] = due
+    if next_action:
+        payload["set_as_next_action"] = True
+
+    try:
+        data = sc.post(f"/api/cli/projects/{project.id}/tasks/", json=payload, project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    task = Task.model_validate(data.get("task", {}))
+    output.success(f"Task #{task.id}: [bold]{task.title}[/bold]")
+    if next_action:
+        output.success("Set as Next Action.")
+
+
+@app.command("edit")
+def task_edit(
+    task_id: int = typer.Argument(...),
+    title: Optional[str] = typer.Option(None, "--title"),
+    description: Optional[str] = typer.Option(None, "--description", "-d"),
+    priority: Optional[str] = typer.Option(None, "--priority"),
+    due: Optional[str] = typer.Option(None, "--due"),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Edit a task."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    payload: dict = {}
+    if title:
+        payload["title"] = title
+    if description is not None:
+        payload["description"] = description
+    if priority:
+        payload["priority"] = priority
+    if due is not None:
+        payload["due_date"] = due
+
+    if not payload:
+        output.warn("No changes specified.")
+        raise SystemExit(0)
+
+    try:
+        data = sc.patch(f"/api/cli/tasks/{task_id}/", json=payload, project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    task = Task.model_validate(data.get("task", {}))
+    output.success(f"Task #{task.id} updated.")
+
+
+@app.command("done")
+def task_done(
+    task_id: int = typer.Argument(...),
+    commit: Optional[str] = typer.Option(None, "--commit", help="Commit ref to link (e.g. HEAD)."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Complete a task (and optionally link a commit)."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    # 1. Complete task immediately
+    try:
+        data = sc.post(f"/api/cli/tasks/{task_id}/complete/", project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    task = Task.model_validate(data.get("task", {}))
+    output.success(f"Task #{task.id} completed.")
+
+    # 2. Commit linking
+    if commit:
+        # Direct commit ref
+        root = git.get_repo_root()
+        sha = git.resolve_sha(commit, root) if root else ""
+        if not sha:
+            output.warn(f"Could not resolve commit ref: {commit!r}")
+        else:
+            info = git.get_commit_info(sha, root)
+            try:
+                ctx_data = client.get(f"/api/cli/projects/{project.id}/context/")
+                repo_full = ctx_data.get("github", {}).get("repository", {}).get("full_name", "")
+                sc.post(
+                    f"/api/cli/tasks/{task_id}/commits/link/",
+                    json={
+                        "sha": sha,
+                        "message": info.message if info else "",
+                        "author_name": info.author if info else "",
+                        "repository_full_name": repo_full,
+                    },
+                    project_name=project.name,
+                )
+                output.success(f"Commit {sha[:8]} linked.")
+            except APIError as exc:
+                output.warn(f"Could not link commit: {exc}")
+    else:
+        # Offer interactive selection
+        _offer_commit_link(client, session.id, task, project.id)
+
+
+@app.command("snooze")
+def task_snooze(
+    task_id: int = typer.Argument(...),
+    choice: Optional[str] = typer.Option(None, "--choice", help="tomorrow|next_week|next_month|someday"),
+    until: Optional[str] = typer.Option(None, "--until", help="Date YYYY-MM-DD (for pick_date)."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Snooze a task."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    sc = _session_client(client, session.id)
+
+    if not choice:
+        choice = questionary.select(
+            "Snooze until:",
+            choices=[
+                questionary.Choice("Tomorrow", value="tomorrow"),
+                questionary.Choice("Next week", value="next_week"),
+                questionary.Choice("Next month", value="next_month"),
+                questionary.Choice("Someday", value="someday"),
+                questionary.Choice("Pick a date", value="pick_date"),
+            ],
+        ).ask()
+
+    if not choice:
+        raise SystemExit(7)
+
+    payload: dict = {"choice": choice}
+    if choice == "pick_date":
+        if not until:
+            until = questionary.text("Date (YYYY-MM-DD):").ask()
+        payload["snoozed_until"] = until
+
+    try:
+        data = sc.post(f"/api/cli/tasks/{task_id}/snooze/", json=payload, project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    task = Task.model_validate(data.get("task", {}))
+    snooze_str = task.snoozed_until or "someday"
+    output.success(f"Task #{task_id} snoozed until {snooze_str}.")
+
+
+@app.command("reopen")
+def task_reopen(
+    task_id: int = typer.Argument(...),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Reopen a completed task."""
+    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/tasks/{task_id}/reopen/", project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    output.success(f"Task #{task_id} reopened.")
+
+
+@app.command("delete")
+def task_delete(
+    task_id: int = typer.Argument(...),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Delete a task."""
+    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 task #{task_id}?", default=False)
+        if not confirmed:
+            output.info("Cancelled.")
+            raise SystemExit(7)
+
+    try:
+        sc.delete(f"/api/cli/tasks/{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} deleted.")
+
+
+# ---------------------------------------------------------------------------
+# pm done — interactive shortcut
+# ---------------------------------------------------------------------------
+
+def done_interactive(
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Interactive task completion shortcut."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+
+    try:
+        data = client.get(f"/api/cli/projects/{project.id}/tasks/", params={"status": "open"})
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    tasks = [Task.model_validate(t) for t in data.get("tasks", [])]
+    if not tasks:
+        output.info("No open tasks.")
+        return
+
+    task = questionary.select(
+        "Which task did you complete?",
+        choices=[questionary.Choice(f"#{t.id} {t.title}", value=t) for t in tasks],
+    ).ask()
+
+    if not task:
+        raise SystemExit(7)
+
+    sc = _session_client(client, session.id)
+    try:
+        result = sc.post(f"/api/cli/tasks/{task.id}/complete/", project_name=project.name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    completed_task = Task.model_validate(result.get("task", {}))
+    output.success(f"Task #{completed_task.id} completed.")
+    _offer_commit_link(client, session.id, completed_task, project.id)

projectmemory_cli/config.py

@@ -0,0 +1,101 @@
+"""Configuration management.
+
+Storage: ~/.config/projectmemory/config.toml  (via platformdirs)
+
+Environment overrides (highest priority):
+  PROJECTMEMORY_API_URL      → api_url
+  PROJECTMEMORY_TOKEN        → token (not written, read-only override)
+  PROJECTMEMORY_PROJECT      → current_project_id
+  PROJECTMEMORY_NO_COLOR     → color = false
+"""
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+from platformdirs import user_config_dir
+
+APP_NAME = "projectmemory"
+CONFIG_DIR = Path(user_config_dir(APP_NAME))
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+DEFAULTS: dict[str, Any] = {
+    "api_url": "https://projectmemory.app",
+    "current_project_id": "",
+    "output": "table",
+    "color": True,
+    "editor": os.environ.get("EDITOR", "nano"),
+}
+
+
+def _load_file() -> dict[str, Any]:
+    if not CONFIG_FILE.exists():
+        return {}
+    try:
+        return tomllib.loads(CONFIG_FILE.read_text())
+    except Exception:
+        return {}
+
+
+def _save_file(data: dict[str, Any]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(tomli_w.dumps(data))
+
+
+def load() -> dict[str, Any]:
+    """Return the merged config: defaults → file → environment."""
+    cfg = dict(DEFAULTS)
+    cfg.update(_load_file())
+
+    # Environment overrides
+    if val := os.environ.get("PROJECTMEMORY_API_URL"):
+        cfg["api_url"] = val.rstrip("/")
+    if os.environ.get("PROJECTMEMORY_NO_COLOR"):
+        cfg["color"] = False
+    if val := os.environ.get("PROJECTMEMORY_PROJECT"):
+        cfg["current_project_id"] = val
+
+    cfg["api_url"] = (cfg.get("api_url") or DEFAULTS["api_url"]).rstrip("/")
+    return cfg
+
+
+def get(key: str, default: Any = None) -> Any:
+    return load().get(key, default)
+
+
+def set_key(key: str, value: Any) -> None:
+    data = _load_file()
+    data[key] = value
+    _save_file(data)
+
+
+def reset() -> None:
+    _save_file({})
+
+
+def set_current_project(project_id: int | str) -> None:
+    set_key("current_project_id", str(project_id))
+
+
+def get_current_project_id() -> str:
+    # env takes precedence
+    if val := os.environ.get("PROJECTMEMORY_PROJECT"):
+        return val
+    return str(get("current_project_id", "") or "")
+
+
+def get_api_url() -> str:
+    return str(get("api_url", DEFAULTS["api_url"])).rstrip("/")
+
+
+def get_editor() -> str:
+    return str(get("editor", DEFAULTS["editor"]))
+
+
+def all_settings() -> dict[str, Any]:
+    """Return all settings suitable for display (masks token)."""
+    cfg = load()
+    return {k: v for k, v in cfg.items()}

projectmemory_cli/credentials.py

@@ -0,0 +1,98 @@
+"""Secure token storage.
+
+Priority order:
+  1. PROJECTMEMORY_TOKEN environment variable  (read-only)
+  2. OS keyring  (keyring library)
+  3. Fallback: ~/.config/projectmemory/credentials.json  (mode 600)
+
+Passwords are never stored.
+"""
+from __future__ import annotations
+
+import json
+import os
+import stat
+from pathlib import Path
+
+from platformdirs import user_config_dir
+
+APP_NAME = "projectmemory"
+KEYRING_SERVICE = "projectmemory-cli"
+KEYRING_USERNAME = "token"
+CRED_FILE = Path(user_config_dir(APP_NAME)) / "credentials.json"
+
+
+def _keyring_available() -> bool:
+    try:
+        import keyring  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def get_token() -> str | None:
+    # 1. Environment variable
+    if val := os.environ.get("PROJECTMEMORY_TOKEN"):
+        return val.strip()
+
+    # 2. OS keyring
+    if _keyring_available():
+        try:
+            import keyring
+            token = keyring.get_password(KEYRING_SERVICE, KEYRING_USERNAME)
+            if token:
+                return token.strip()
+        except Exception:
+            pass
+
+    # 3. Fallback file
+    if CRED_FILE.exists():
+        try:
+            data = json.loads(CRED_FILE.read_text())
+            token = data.get("token", "")
+            if token:
+                return token.strip()
+        except Exception:
+            pass
+
+    return None
+
+
+def save_token(token: str) -> bool:
+    """Save token. Returns True if saved to keyring, False if fallback file."""
+    if _keyring_available():
+        try:
+            import keyring
+            keyring.set_password(KEYRING_SERVICE, KEYRING_USERNAME, token)
+            return True
+        except Exception:
+            pass
+
+    # Fallback file
+    _write_cred_file({"token": token})
+    return False
+
+
+def delete_token() -> None:
+    """Remove token from all storage locations."""
+    if _keyring_available():
+        try:
+            import keyring
+            keyring.delete_password(KEYRING_SERVICE, KEYRING_USERNAME)
+        except Exception:
+            pass
+
+    if CRED_FILE.exists():
+        try:
+            CRED_FILE.unlink()
+        except Exception:
+            pass
+
+
+def _write_cred_file(data: dict) -> None:
+    CRED_FILE.parent.mkdir(parents=True, exist_ok=True)
+    CRED_FILE.write_text(json.dumps(data))
+    try:
+        CRED_FILE.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600
+    except Exception:
+        pass