projectmemory-cli 0.1.0__py3-none-any.whl

projectmemory_cli/commands/commits.py

@@ -0,0 +1,147 @@
+"""Commit commands: pm commit link."""
+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.project_context import guard_project_session
+
+app = typer.Typer(help="Commit linking 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, debug=client.debug)
+
+
+def _project_repo(client: APIClient, project_id: int) -> str:
+    ctx_data = client.get(f"/api/cli/projects/{project_id}/context/")
+    github = ctx_data.get("github", {})
+    if not github.get("connected"):
+        output.error("This project has no connected GitHub repository.")
+        output.hint("Connect a repository in the web app first.")
+        raise SystemExit(3)
+    repo_full = github.get("repository", {}).get("full_name", "")
+    if not repo_full:
+        output.error("Could not determine the connected GitHub repository.")
+        raise SystemExit(3)
+    return repo_full
+
+
+def _verify_local_repo_matches(repo_full: str, root) -> None:
+    local_remote = git.normalize_github_repo(git.get_remote_url(root)) if root else ""
+    if local_remote and local_remote.lower() != repo_full.lower():
+        output.error(
+            f"Repository mismatch: local repo is '{local_remote}', "
+            f"but this project is connected to '{repo_full.lower()}'."
+        )
+        raise SystemExit(3)
+
+
+def _resolve_commit(ref: str, root) -> tuple[str, object | None]:
+    sha = git.resolve_sha(ref, root) if root else ""
+    if not sha and ref:
+        sha = ref
+    if not sha:
+        output.error("Could not resolve commit. Ensure you are in a git repository.")
+        raise SystemExit(1)
+    return sha, git.get_commit_info(sha, root)
+
+
+def _link_commit(client: APIClient, session_id: int, project_name: str, task_id: int, sha: str, info, repo_full: str) -> None:
+    sc = _session_client(client, session_id)
+    payload: dict = {"sha": sha, "repository_full_name": repo_full}
+    if info:
+        payload["message"] = info.message
+        payload["author_name"] = info.author
+    try:
+        data = sc.post(f"/api/cli/tasks/{task_id}/commits/link/", json=payload, project_name=project_name)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    if data.get("created", False):
+        output.success(f"Commit {sha[:8]} linked to task #{task_id}.")
+    else:
+        output.info(f"Commit {sha[:8]} was already linked to task #{task_id}.")
+
+
+@app.command("link")
+def commit_link(
+    sha: Optional[str] = typer.Argument(None, help="Commit SHA or ref, e.g. HEAD."),
+    task_id: Optional[int] = typer.Option(None, "--task", "-t", help="Completed task ID."),
+    project_arg: Optional[str] = typer.Option(None, "--project", "-p"),
+) -> None:
+    """Link a local git commit to a completed task."""
+    client = _require_client()
+    project, session = guard_project_session(client, project_arg=project_arg)
+    root = git.get_repo_root()
+    if not root:
+        output.error("Run this command inside a Git repository.")
+        raise SystemExit(1)
+
+    try:
+        repo_full = _project_repo(client, project.id)
+        _verify_local_repo_matches(repo_full, root)
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+
+    if sha and task_id:
+        resolved_sha, info = _resolve_commit(sha, root)
+        _link_commit(client, session.id, project.name, task_id, resolved_sha, info, repo_full)
+        return
+
+    commits = git.get_recent_commits(root, limit=10)
+    if not commits:
+        output.info("No recent local commits found.")
+        raise SystemExit(0)
+
+    try:
+        tasks_data = client.get(f"/api/cli/projects/{project.id}/tasks/", params={"status": "completed"})
+    except APIError as exc:
+        output.error(str(exc))
+        raise SystemExit(exc.exit_code)
+    completed_tasks = [t for t in tasks_data.get("tasks", []) if not t.get("has_linked_commits")]
+    if not completed_tasks:
+        output.info("No completed tasks without linked commits.")
+        raise SystemExit(0)
+
+    selected_commit = None
+    if sha:
+        resolved_sha, info = _resolve_commit(sha, root)
+    else:
+        selected_commit = questionary.select(
+            "Select commit:",
+            choices=[questionary.Choice(f"{c.short_sha} {c.message[:70]}", value=c) for c in commits]
+            + [questionary.Choice("Cancel", value=None)],
+        ).ask()
+        if not selected_commit:
+            output.info("Cancelled.")
+            raise SystemExit(7)
+        resolved_sha, info = selected_commit.sha, selected_commit
+
+    if not task_id:
+        selected_task = questionary.select(
+            "Select completed task:",
+            choices=[questionary.Choice(f"#{t['id']} {t['title']}", value=t) for t in completed_tasks]
+            + [questionary.Choice("Cancel", value=None)],
+        ).ask()
+        if not selected_task:
+            output.info("Cancelled.")
+            raise SystemExit(7)
+        task_id = selected_task["id"]
+
+    _link_commit(client, session.id, project.name, task_id, resolved_sha, info, repo_full)

projectmemory_cli/commands/config.py

@@ -0,0 +1,56 @@
+"""Configuration commands: pm config show, pm config set, pm config reset."""
+from __future__ import annotations
+
+import typer
+
+from projectmemory_cli import config, output
+
+
+def show() -> None:
+    """Display current configuration."""
+    cfg = config.all_settings()
+    output.blank()
+    output.info("[bold]Configuration[/bold]")
+    output.blank()
+    for key, value in cfg.items():
+        output.kv(key, str(value))
+    output.blank()
+    output.hint(f"Config file: {config.CONFIG_FILE}")
+
+
+def set_value(
+    key: str = typer.Argument(..., help="Config key to set."),
+    value: str = typer.Argument(..., help="Value to assign."),
+) -> None:
+    """Set a configuration value."""
+    valid_keys = set(config.DEFAULTS.keys())
+    if key not in valid_keys:
+        output.error(f"Unknown config key: {key!r}")
+        output.hint(f"Valid keys: {', '.join(sorted(valid_keys))}")
+        raise SystemExit(4)
+
+    # Type coercion
+    current = config.DEFAULTS.get(key)
+    if isinstance(current, bool):
+        coerced: object = value.lower() in ("true", "1", "yes", "on")
+    elif isinstance(current, int):
+        try:
+            coerced = int(value)
+        except ValueError:
+            output.error(f"{key} must be an integer.")
+            raise SystemExit(4)
+    else:
+        coerced = value
+
+    config.set_key(key, coerced)
+    output.success(f"{key} = {coerced!r}")
+
+
+def reset() -> None:
+    """Reset all configuration to defaults."""
+    confirmed = typer.confirm("Reset all configuration to defaults?", default=False)
+    if not confirmed:
+        output.info("Cancelled.")
+        raise SystemExit(7)
+    config.reset()
+    output.success("Configuration reset to defaults.")

projectmemory_cli/commands/doctor.py

@@ -0,0 +1,375 @@
+"""Diagnostic command: pm doctor."""
+from __future__ import annotations
+
+import platform
+import sys
+import time
+from typing import Any, Optional
+
+import httpx
+import typer
+from rich.table import Table
+
+from projectmemory_cli import __version__, config, credentials, git, output
+from projectmemory_cli.api.client import APIClient
+from projectmemory_cli.api.errors import APIError
+from projectmemory_cli.project_context import get_mapped_project_id_for_cwd
+
+
+Status = str
+
+
+def _status(ok: bool | None, label: str) -> dict[str, Any]:
+    if ok is True:
+        return {"status": "ok", "label": label, "icon": "✓"}
+    if ok is False:
+        return {"status": "error", "label": label, "icon": "✗"}
+    return {"status": "warning", "label": label, "icon": "⚠"}
+
+
+def _mask_url(url: str) -> str:
+    # Avoid leaking basic-auth style URLs if a user configured one accidentally.
+    if "@" in url and "://" in url:
+        scheme, rest = url.split("://", 1)
+        return f"{scheme}://***@{rest.split('@', 1)[1]}"
+    return url
+
+
+def _safe_get(url: str, token: str | None = None) -> tuple[bool, int | None, float | None, str]:
+    headers = {"Accept": "application/json", "User-Agent": f"projectmemory-cli/{__version__}"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    start = time.perf_counter()
+    try:
+        resp = httpx.get(url, headers=headers, timeout=8.0)
+        latency = (time.perf_counter() - start) * 1000
+        return True, resp.status_code, latency, ""
+    except Exception as exc:
+        latency = (time.perf_counter() - start) * 1000
+        return False, None, latency, str(exc)
+
+
+def _add_table(title: str, rows: list[tuple[str, str]]) -> None:
+    table = Table(title=title, show_header=False, box=None, padding=(0, 2))
+    table.add_column("Field", style="dim")
+    table.add_column("Value")
+    for key, value in rows:
+        table.add_row(key, value)
+    output.console.print(table)
+
+
+def _health_line(state: dict[str, Any]) -> str:
+    icon = state.get("icon", "•")
+    label = state.get("label", "")
+    status = state.get("status", "")
+    if status == "ok":
+        return f"[green]{icon}[/green] {label}"
+    if status == "error":
+        return f"[red]{icon}[/red] {label}"
+    return f"[yellow]{icon}[/yellow] {label}"
+
+
+def _print_checks(checks: list[dict[str, Any]]) -> None:
+    output.header("Checks")
+    for check in checks:
+        output.info(_health_line(check))
+
+
+def _exit_code(checks: list[dict[str, Any]]) -> int:
+    if any(c.get("status") == "error" for c in checks):
+        return 2
+    if any(c.get("status") == "warning" for c in checks):
+        return 1
+    return 0
+
+
+def _user_from_auth_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    return payload.get("user") or payload.get("account") or {}
+
+
+def doctor(
+    json: bool = typer.Option(False, "--json", help="Output diagnostic report as JSON."),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Include extra endpoint/status details."),
+    no_network: bool = typer.Option(False, "--no-network", help="Skip API/network checks."),
+) -> None:
+    """Diagnose CLI configuration, authentication, backend, project, session, and Git state."""
+    output.configure(json_mode=json)
+
+    cfg = config.load()
+    api_url = config.get_api_url()
+    token = credentials.get_token()
+    token_source = "none"
+    if token:
+        import os
+        if os.environ.get("PROJECTMEMORY_TOKEN"):
+            token_source = "environment"
+        elif credentials.CRED_FILE.exists():
+            token_source = "keyring or fallback file"
+        else:
+            token_source = "keyring"
+
+    checks: list[dict[str, Any]] = []
+    report: dict[str, Any] = {
+        "cli": {
+            "version": __version__,
+            "python": platform.python_version(),
+            "python_executable": sys.executable,
+            "os": f"{platform.system()} {platform.release()}",
+            "config_file": str(config.CONFIG_FILE),
+            "api_url": _mask_url(api_url),
+            "output_mode": cfg.get("output", "table"),
+            "color": bool(cfg.get("color", True)),
+        },
+        "authentication": {
+            "logged_in": bool(token),
+            "token_present": bool(token),
+            "token_source": token_source,
+            "token_valid": None,
+            "token_expiration": None,
+            "email": None,
+        },
+        "backend": {
+            "reachable": None,
+            "latency_ms": None,
+            "version": None,
+            "environment": None,
+        },
+        "current_project": {
+            "name": None,
+            "id": config.get_current_project_id() or None,
+            "mapping_status": "not mapped",
+            "active_session": None,
+            "session_id": None,
+            "session_started_at": None,
+            "session_duration": None,
+        },
+        "git": {},
+        "connectivity": {},
+        "subscription": {
+            "plan": None,
+            "read_only": None,
+            "email_verified": None,
+            "email_verification_required": None,
+        },
+        "checks": checks,
+    }
+
+    if token:
+        checks.append(_status(True, "Token found"))
+    else:
+        checks.append(_status(False, "Not logged in"))
+
+    root = git.get_repo_root()
+    mapped = get_mapped_project_id_for_cwd()
+    if mapped:
+        report["current_project"]["mapping_status"] = f"mapped to project #{mapped[0]} ({mapped[1]})"
+    if root:
+        remote_url = git.get_remote_url(root)
+        report["git"] = {
+            "repository_detected": True,
+            "root": str(root),
+            "branch": git.get_current_branch(root),
+            "commit": git.get_short_head_sha(root),
+            "remote_origin_url": remote_url,
+            "remote_github_repository": git.normalize_github_repo(remote_url),
+            "linked_to_current_project": None,
+            "repository_match": None,
+        }
+        checks.append(_status(True, "Git repository detected"))
+    else:
+        report["git"] = {"repository_detected": False, "message": "No Git repository detected."}
+        checks.append(_status(None, "No Git repository detected"))
+
+    auth_payload: dict[str, Any] = {}
+    projects_payload: dict[str, Any] = {}
+    sessions_payload: dict[str, Any] = {}
+    current_project: dict[str, Any] | None = None
+
+    if no_network:
+        report["backend"]["reachable"] = None
+        report["connectivity"]["network_checks"] = "skipped"
+        checks.append(_status(None, "Network checks skipped"))
+    else:
+        reachable, status_code, latency, error = _safe_get(f"{api_url}/api/cli/auth/status/", token=token)
+        report["backend"].update({"reachable": reachable, "latency_ms": round(latency or 0, 1), "auth_status_code": status_code})
+        report["connectivity"]["backend_api"] = {"reachable": reachable, "status_code": status_code, "error": error}
+        if reachable:
+            checks.append(_status(True, f"Backend reachable ({round(latency or 0)} ms)"))
+        else:
+            checks.append(_status(False, "Backend unreachable"))
+
+        if token:
+            client = APIClient.from_env()
+            try:
+                auth_payload = client.get("/api/cli/auth/status/")
+                user = _user_from_auth_payload(auth_payload)
+                report["authentication"].update({
+                    "token_valid": bool(auth_payload.get("authenticated", True)),
+                    "token_expiration": auth_payload.get("expires_at") or auth_payload.get("token_expires_at"),
+                    "email": user.get("email"),
+                })
+                report["subscription"].update({
+                    "plan": user.get("plan"),
+                    "read_only": user.get("read_only") or user.get("is_read_only"),
+                    "email_verified": user.get("email_verified"),
+                    "email_verification_required": user.get("email_verification_required"),
+                })
+                checks.append(_status(True, "Logged in"))
+                if user.get("email_verified") is False:
+                    checks.append(_status(False, "Email not verified"))
+            except APIError as exc:
+                report["authentication"].update({"token_valid": False, "error": str(exc)})
+                checks.append(_status(False, "Token invalid or expired"))
+
+            try:
+                sessions_payload = client.get("/api/cli/session/status/")
+                report["connectivity"]["session_endpoint"] = {"reachable": True}
+                checks.append(_status(True, "Session endpoint reachable"))
+            except APIError as exc:
+                report["connectivity"]["session_endpoint"] = {"reachable": False, "error": str(exc)}
+                checks.append(_status(False, "Session endpoint unavailable"))
+
+            try:
+                projects_payload = client.get("/api/cli/projects/")
+                report["connectivity"]["projects_endpoint"] = {"reachable": True}
+            except APIError as exc:
+                report["connectivity"]["projects_endpoint"] = {"reachable": False, "error": str(exc)}
+
+    current_id = str(config.get_current_project_id() or "")
+    projects = projects_payload.get("projects", []) if projects_payload else []
+    if current_id and projects:
+        for project in projects:
+            if str(project.get("id")) == current_id:
+                current_project = project
+                break
+    elif mapped and projects:
+        for project in projects:
+            if str(project.get("id")) == str(mapped[0]):
+                current_project = project
+                break
+
+    if current_project:
+        report["current_project"].update({
+            "name": current_project.get("name"),
+            "id": current_project.get("id"),
+        })
+        active = current_project.get("active_session") or None
+        if not active:
+            for session in sessions_payload.get("active_sessions", []) if sessions_payload else []:
+                if str(session.get("project")) == str(current_project.get("id")):
+                    active = session
+                    break
+        if active:
+            report["current_project"].update({
+                "active_session": True,
+                "session_id": active.get("id"),
+                "session_started_at": active.get("started_at"),
+                "session_duration": output.format_duration(int(active.get("duration_seconds") or 0)),
+            })
+            checks.append(_status(True, "Active session"))
+        else:
+            report["current_project"]["active_session"] = False
+            checks.append(_status(None, "No active session for current project"))
+
+        github = current_project.get("github", {}) or {}
+        repo = github.get("repository") or {}
+        report["connectivity"]["github_integration"] = {
+            "connected": bool(github.get("connected")),
+            "repository": repo.get("full_name"),
+            "last_synced_at": github.get("last_synced_at"),
+        }
+        if github.get("connected"):
+            checks.append(_status(True, "GitHub integration connected"))
+        else:
+            checks.append(_status(None, "No connected GitHub repository"))
+
+        if root:
+            local_repo = report["git"].get("remote_github_repository")
+            connected_repo = (repo.get("full_name") or "").lower()
+            linked = mapped and str(mapped[0]) == str(current_project.get("id"))
+            match = bool(local_repo and connected_repo and local_repo == connected_repo)
+            report["git"].update({
+                "linked_to_current_project": bool(linked),
+                "connected_project_repository": connected_repo or None,
+                "repository_match": match if connected_repo else None,
+            })
+            if connected_repo and local_repo and not match:
+                checks.append(_status(None, "Repository mismatch"))
+    elif current_id:
+        checks.append(_status(None, "Current project not found or unavailable offline"))
+    else:
+        checks.append(_status(None, "No current CLI project"))
+
+    if json:
+        output.print_json(report)
+        raise typer.Exit(_exit_code(checks))
+
+    output.blank()
+    output.project_banner("Project Memory Doctor")
+    _print_checks(checks)
+
+    output.blank()
+    _add_table("CLI", [
+        ("Version", report["cli"]["version"]),
+        ("Python", report["cli"]["python"]),
+        ("OS", report["cli"]["os"]),
+        ("Config", report["cli"]["config_file"]),
+        ("API URL", report["cli"]["api_url"]),
+        ("Output", str(report["cli"]["output_mode"])),
+        ("Color", "enabled" if report["cli"]["color"] else "disabled"),
+    ])
+
+    _add_table("Authentication", [
+        ("Logged in", "yes" if report["authentication"]["logged_in"] else "no"),
+        ("Email", str(report["authentication"].get("email") or "unknown")),
+        ("Token", "present, hidden" if token else "not found"),
+        ("Token valid", str(report["authentication"].get("token_valid"))),
+        ("Token expiration", str(report["authentication"].get("token_expiration") or "unknown")),
+    ])
+
+    _add_table("Backend", [
+        ("Reachable", str(report["backend"].get("reachable"))),
+        ("Latency", f"{report['backend'].get('latency_ms')} ms" if report["backend"].get("latency_ms") is not None else "unknown"),
+        ("Version", str(report["backend"].get("version") or "unknown")),
+        ("Environment", str(report["backend"].get("environment") or "unknown")),
+    ])
+
+    _add_table("Current Project", [
+        ("Project", str(report["current_project"].get("name") or "unknown")),
+        ("Project ID", str(report["current_project"].get("id") or "unknown")),
+        ("Mapping", str(report["current_project"].get("mapping_status") or "not mapped")),
+        ("Active session", str(report["current_project"].get("active_session"))),
+        ("Session ID", str(report["current_project"].get("session_id") or "unknown")),
+        ("Started", str(report["current_project"].get("session_started_at") or "unknown")),
+        ("Duration", str(report["current_project"].get("session_duration") or "unknown")),
+    ])
+
+    git_rows = []
+    if report["git"].get("repository_detected"):
+        git_rows = [
+            ("Repository", "detected"),
+            ("Root", str(report["git"].get("root") or "unknown")),
+            ("Branch", str(report["git"].get("branch") or "unknown")),
+            ("Commit", str(report["git"].get("commit") or "unknown")),
+            ("Remote", str(report["git"].get("remote_origin_url") or "unknown")),
+            ("Linked to current project", str(report["git"].get("linked_to_current_project"))),
+            ("Repository match", str(report["git"].get("repository_match"))),
+        ]
+    else:
+        git_rows = [("Repository", "No Git repository detected.")]
+    _add_table("Git", git_rows)
+
+    _add_table("Subscription", [
+        ("Plan", str(report["subscription"].get("plan") or "unknown")),
+        ("Read-only", str(report["subscription"].get("read_only"))),
+        ("Email verified", str(report["subscription"].get("email_verified"))),
+        ("Verification required", str(report["subscription"].get("email_verification_required"))),
+    ])
+
+    if verbose:
+        output.blank()
+        output.header("Connectivity Details")
+        for key, value in report["connectivity"].items():
+            output.kv(key, str(value))
+
+    raise typer.Exit(_exit_code(checks))