cli-anything-medcare 0.1.0__tar.gz

cli_anything_medcare-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: cli-anything-medcare
+Version: 0.1.0
+Summary: CLI-Anything harness for the Medcare FastAPI backend
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.28
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

cli_anything_medcare-0.1.0/cli_anything/medcare/__main__.py

@@ -0,0 +1,4 @@
+from cli_anything.medcare.medcare_cli import cli
+
+if __name__ == "__main__":
+    cli()

cli_anything_medcare-0.1.0/cli_anything/medcare/core/case_notes.py

@@ -0,0 +1,63 @@
+"""Case notes domain operations."""
+
+from typing import Any, List, Optional
+from cli_anything.medcare.core.client import MedcareClient
+
+
+def list_case_notes(client: MedcareClient, patient_uuid: str) -> Any:
+    return client.get(f"/patient/case_notes/v2/{patient_uuid}")
+
+
+def get_case_note(client: MedcareClient, note_uuid: str) -> Any:
+    return client.get(f"/patient/case_notes/v2/note/{note_uuid}")
+
+
+def create_case_note(
+    client: MedcareClient,
+    patient_uuid: str,
+    note_date: str,
+    note_time: str,
+    title: Optional[str] = None,
+    details: Optional[str] = None,
+    remarks: Optional[str] = None,
+    actions: Optional[str] = None,
+    is_private: bool = False,
+    note_categories: Optional[List[str]] = None,
+) -> Any:
+    payload = {
+        "patient_uuid": patient_uuid,
+        "note_date": note_date,
+        "note_time": note_time,
+        "title": title,
+        "details": details,
+        "remarks": remarks,
+        "actions": actions,
+        "is_private": is_private,
+        "note_categories": note_categories or [],
+    }
+    return client.post("/patient/case_notes/v2/create", data=payload)
+
+
+def update_case_note(client: MedcareClient, note_uuid: str, payload: dict) -> Any:
+    return client.put(f"/patient/case_notes/v2/update/{note_uuid}", data=payload)
+
+
+def delete_case_note(client: MedcareClient, note_uuid: str) -> Any:
+    return client.delete(f"/patient/case_notes/v2/delete/{note_uuid}")
+
+
+def generate_case_note_report(
+    client: MedcareClient, patient_id: str, design_type: str = "new"
+) -> Any:
+    return client.post(
+        f"/patient/case_notes/v2/report/{patient_id}",
+        data={"designtype": design_type},
+    )
+
+
+def list_case_note_categories(client: MedcareClient) -> Any:
+    return client.get("/patient/case_notes/v2/categories")
+
+
+def list_case_note_templates(client: MedcareClient) -> Any:
+    return client.get("/patient/case_notes/v2/templates")

cli_anything_medcare-0.1.0/cli_anything/medcare/core/client.py

@@ -0,0 +1,45 @@
+"""HTTP client wrapper for the Medcare FastAPI backend."""
+
+import json
+from typing import Any, Optional
+import requests
+from cli_anything.medcare.utils.session import require_token
+
+
+class MedcareClient:
+    def __init__(self, base_url: Optional[str] = None, token: Optional[str] = None):
+        if base_url and token:
+            self.base_url = base_url.rstrip("/")
+            self.token = token
+        else:
+            self.base_url, self.token = require_token()
+
+    def _headers(self) -> dict:
+        return {"Authorization": f"Bearer {self.token}"}
+
+    def get(self, path: str, params: Optional[dict] = None) -> Any:
+        url = f"{self.base_url}{path}"
+        r = requests.get(url, headers=self._headers(), params=params, timeout=30)
+        r.raise_for_status()
+        return r.json()
+
+    def post(self, path: str, data: Any = None, files: Optional[dict] = None) -> Any:
+        url = f"{self.base_url}{path}"
+        if files:
+            r = requests.post(url, headers=self._headers(), data=data, files=files, timeout=60)
+        else:
+            r = requests.post(url, headers=self._headers(), json=data, timeout=30)
+        r.raise_for_status()
+        return r.json()
+
+    def put(self, path: str, data: Any = None) -> Any:
+        url = f"{self.base_url}{path}"
+        r = requests.put(url, headers=self._headers(), json=data, timeout=30)
+        r.raise_for_status()
+        return r.json()
+
+    def delete(self, path: str) -> Any:
+        url = f"{self.base_url}{path}"
+        r = requests.delete(url, headers=self._headers(), timeout=30)
+        r.raise_for_status()
+        return r.json()

cli_anything_medcare-0.1.0/cli_anything/medcare/core/lab_reports.py

@@ -0,0 +1,46 @@
+"""Lab report domain operations."""
+
+from pathlib import Path
+from typing import Any, Optional
+from cli_anything.medcare.core.client import MedcareClient
+
+
+def get_lab_reports(client: MedcareClient, patient_uuid: str) -> Any:
+    return client.get(f"/health_info/lab_report/patient/{patient_uuid}")
+
+
+def get_lab_report(client: MedcareClient, report_uuid: str) -> Any:
+    return client.get(f"/health_info/lab_report/get/{report_uuid}")
+
+
+def get_lab_trends(client: MedcareClient, patient_uuid: str) -> Any:
+    return client.get(f"/health_info/lab_report/patient/{patient_uuid}/trends")
+
+
+def upload_lab_report(client: MedcareClient, patient_uuid: str, pdf_path: str) -> Any:
+    path = Path(pdf_path)
+    if not path.exists():
+        raise FileNotFoundError(f"PDF not found: {pdf_path}")
+    with open(path, "rb") as f:
+        return client.post(
+            f"/health_info/lab_report/upload/{patient_uuid}",
+            files={"file": (path.name, f, "application/pdf")},
+        )
+
+
+def update_lab_report(
+    client: MedcareClient,
+    report_uuid: str,
+    remarks: Optional[str] = None,
+    is_verified: Optional[bool] = None,
+) -> Any:
+    payload: dict = {}
+    if remarks is not None:
+        payload["remarks"] = remarks
+    if is_verified is not None:
+        payload["is_verified"] = is_verified
+    return client.put(f"/health_info/lab_report/update/{report_uuid}", data=payload)
+
+
+def delete_lab_report(client: MedcareClient, report_uuid: str) -> Any:
+    return client.delete(f"/health_info/lab_report/delete/{report_uuid}")

cli_anything_medcare-0.1.0/cli_anything/medcare/core/medication.py

@@ -0,0 +1,20 @@
+"""Medication domain operations."""
+
+from typing import Any
+from cli_anything.medcare.core.client import MedcareClient
+
+
+def get_medications(client: MedcareClient, patient_id: str) -> Any:
+    return client.get(f"/patient/v3/medication/{patient_id}")
+
+
+def get_daily_medication(client: MedcareClient, patient_id: str) -> Any:
+    return client.get(f"/daily-medication/{patient_id}")
+
+
+def get_medication_monitoring(client: MedcareClient, patient_id: str) -> Any:
+    return client.get(f"/medication-monitoring/{patient_id}")
+
+
+def get_health_summary(client: MedcareClient, patient_id: str) -> Any:
+    return client.get(f"/patient/v5/health-summary/{patient_id}")

cli_anything_medcare-0.1.0/cli_anything/medcare/core/patients.py

@@ -0,0 +1,32 @@
+"""Patient domain operations."""
+
+from typing import Any, Optional
+from cli_anything.medcare.core.client import MedcareClient
+
+
+def search_patients(client: MedcareClient, term: str) -> Any:
+    return client.get(f"/patient/v2/search/{term}")
+
+
+def list_patients(client: MedcareClient, page: int = 1) -> Any:
+    return client.get(f"/patient/v2/all/{page}")
+
+
+def get_patient(client: MedcareClient, patient_id: str) -> Any:
+    return client.get(f"/patient/v2/get/{patient_id}")
+
+
+def create_patient(client: MedcareClient, payload: dict) -> Any:
+    return client.post("/patient/v2/create", data=payload)
+
+
+def update_patient(client: MedcareClient, patient_id: str, payload: dict) -> Any:
+    return client.put(f"/patient/v2/update/{patient_id}", data=payload)
+
+
+def delete_patient(client: MedcareClient, patient_id: str) -> Any:
+    return client.delete(f"/patient/v2/delete/{patient_id}")
+
+
+def list_patients_by_condition(client: MedcareClient, condition: str, page: int = 1) -> Any:
+    return client.get("/patient-list-by-conditions/by-condition", params={"condition": condition, "page": page})

cli_anything_medcare-0.1.0/cli_anything/medcare/core/staff.py

@@ -0,0 +1,12 @@
+"""Staff/organisation domain operations."""
+
+from typing import Any
+from cli_anything.medcare.core.client import MedcareClient
+
+
+def list_staff(client: MedcareClient) -> Any:
+    return client.get("/admin/staffs")
+
+
+def get_staff(client: MedcareClient, firebase_uid: str) -> Any:
+    return client.get(f"/admin/staff/{firebase_uid}")

cli_anything_medcare-0.1.0/cli_anything/medcare/medcare_cli.py

@@ -0,0 +1,419 @@
+"""Medcare CLI — read-only data access for patients, lab reports, case notes, medication, staff."""
+
+import json
+import sys
+from typing import Optional
+
+import click
+import requests
+
+from cli_anything.medcare.core.client import MedcareClient
+from cli_anything.medcare.core import patients, lab_reports, case_notes, medication, staff
+from cli_anything.medcare.utils.session import save_token, save_session, clear_session, get_session
+from cli_anything.medcare.utils import auth as _auth
+from cli_anything.medcare.utils.repl_skin import ReplSkin
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _client(ctx: click.Context) -> MedcareClient:
+    return MedcareClient()
+
+
+def _out(ctx: click.Context, data) -> None:
+    if ctx.obj.get("json"):
+        click.echo(json.dumps(data, indent=2, default=str))
+    else:
+        if isinstance(data, (dict, list)):
+            click.echo(json.dumps(data, indent=2, default=str))
+        else:
+            click.echo(str(data))
+
+
+def _handle_error(e: Exception) -> None:
+    if isinstance(e, requests.HTTPError):
+        try:
+            detail = e.response.json().get("detail", str(e))
+        except Exception:
+            detail = str(e)
+        click.echo(f"API error {e.response.status_code}: {detail}", err=True)
+    else:
+        click.echo(f"Error: {e}", err=True)
+    sys.exit(1)
+
+
+# ── Root group ────────────────────────────────────────────────────────────────
+
+@click.group()
+@click.option("--json", "json_mode", is_flag=True, default=False, help="Output raw JSON.")
+@click.pass_context
+def cli(ctx: click.Context, json_mode: bool) -> None:
+    """Medcare CLI — read-only data access for the Medcare backend."""
+    ctx.ensure_object(dict)
+    ctx.obj["json"] = json_mode
+
+
+# ── Auth ──────────────────────────────────────────────────────────────────────
+
+@cli.command()
+@click.option("--url", default="https://api.aipharm.xyz", show_default=True, help="Medcare API base URL.")
+@click.option("--token", default=None, hidden=True, help="Pre-issued Firebase ID token (agent/CI use only — skips role check).")
+def login(url: str, token: str) -> None:
+    """Log in to Medcare. Prompts for email and password."""
+    # Agent / CI mode: token provided directly, skip interactive flow.
+    if token:
+        save_token(url, token)
+        click.echo(f"Session saved (token mode). Base URL: {url}")
+        return
+
+    email = click.prompt("Email")
+    password = click.prompt("Password", hide_input=True)
+
+    click.echo("Authenticating…")
+    try:
+        resp = _auth.login(url, email, password)
+    except ValueError as e:
+        click.echo(str(e), err=True)
+        sys.exit(1)
+
+    id_token = resp["firebase_token"]
+    local_id = resp["user_id"]
+
+    # Role check — only branch managers and admin users may use the CLI.
+    click.echo("Checking access…")
+    try:
+        c = MedcareClient(base_url=url, token=id_token)
+        profile = staff.get_staff(c, local_id)
+    except Exception as e:
+        click.echo(f"Could not verify role: {e}", err=True)
+        sys.exit(1)
+
+    is_branch_manager = profile.get("isBranchManager", False)
+    staff_role = profile.get("StaffRole", "")
+
+    if not (is_branch_manager or staff_role == "user"):
+        click.echo(
+            f"Access denied — role '{staff_role}' is not authorised to use this CLI.\n"
+            "Only branch managers and admin users are allowed.",
+            err=True,
+        )
+        sys.exit(1)
+
+    save_session(url, id_token, resp["refresh_token"], local_id, email)
+    click.echo(f"Logged in as {email} (role: {staff_role}, branch manager: {is_branch_manager})")
+
+
+@cli.command()
+def logout() -> None:
+    """Log out and revoke tokens server-side."""
+    data = get_session()
+    if data.get("token") and data.get("base_url"):
+        _auth.logout_server(data["base_url"], data["token"])
+    clear_session()
+    click.echo("Logged out.")
+
+
+@cli.command()
+def whoami() -> None:
+    """Show current session info."""
+    data = get_session()
+    if not data or not data.get("token"):
+        click.echo("Not logged in.")
+        return
+    click.echo(f"URL  : {data.get('base_url', 'n/a')}")
+    click.echo(f"Email: {data.get('email', '(token mode)')}")
+    issued = data.get("issued_at")
+    if issued:
+        import time
+        age_min = int((time.time() - issued) / 60)
+        click.echo(f"Token: {age_min} min old (auto-refreshes at 55 min)")
+    else:
+        click.echo(f"Token: {data.get('token', '')[:24]}… (manual token mode)")
+
+
+# ── Patient commands ──────────────────────────────────────────────────────────
+
+@cli.group()
+def patient() -> None:
+    """Patient search and lookup."""
+
+
+@patient.command("search")
+@click.argument("term")
+@click.pass_context
+def patient_search(ctx, term: str) -> None:
+    """Search patients by name, IC, or ref ID."""
+    try:
+        _out(ctx, patients.search_patients(_client(ctx), term))
+    except Exception as e:
+        _handle_error(e)
+
+
+@patient.command("list")
+@click.option("--page", default=1, show_default=True, help="Page number.")
+@click.pass_context
+def patient_list(ctx, page: int) -> None:
+    """List patients (paginated)."""
+    try:
+        _out(ctx, patients.list_patients(_client(ctx), page))
+    except Exception as e:
+        _handle_error(e)
+
+
+@patient.command("get")
+@click.argument("patient_id")
+@click.pass_context
+def patient_get(ctx, patient_id: str) -> None:
+    """Get a patient by ID."""
+    try:
+        _out(ctx, patients.get_patient(_client(ctx), patient_id))
+    except Exception as e:
+        _handle_error(e)
+
+
+@patient.command("by-condition")
+@click.argument("condition")
+@click.option("--page", default=1, show_default=True)
+@click.pass_context
+def patient_by_condition(ctx, condition: str, page: int) -> None:
+    """List patients by medical condition tag."""
+    try:
+        _out(ctx, patients.list_patients_by_condition(_client(ctx), condition, page))
+    except Exception as e:
+        _handle_error(e)
+
+
+# ── Lab report commands ───────────────────────────────────────────────────────
+
+@cli.group()
+def lab() -> None:
+    """Lab report data and trends."""
+
+
+@lab.command("list")
+@click.argument("patient_uuid")
+@click.pass_context
+def lab_list(ctx, patient_uuid: str) -> None:
+    """List all lab reports for a patient."""
+    try:
+        _out(ctx, lab_reports.get_lab_reports(_client(ctx), patient_uuid))
+    except Exception as e:
+        _handle_error(e)
+
+
+@lab.command("get")
+@click.argument("report_uuid")
+@click.pass_context
+def lab_get(ctx, report_uuid: str) -> None:
+    """Get a single lab report with all results."""
+    try:
+        _out(ctx, lab_reports.get_lab_report(_client(ctx), report_uuid))
+    except Exception as e:
+        _handle_error(e)
+
+
+@lab.command("trends")
+@click.argument("patient_uuid")
+@click.pass_context
+def lab_trends(ctx, patient_uuid: str) -> None:
+    """Show lab result trends for a patient."""
+    try:
+        _out(ctx, lab_reports.get_lab_trends(_client(ctx), patient_uuid))
+    except Exception as e:
+        _handle_error(e)
+
+
+# ── Case note commands ────────────────────────────────────────────────────────
+
+@cli.group()
+def note() -> None:
+    """Case note lookup and reference data."""
+
+
+@note.command("list")
+@click.argument("patient_uuid")
+@click.pass_context
+def note_list(ctx, patient_uuid: str) -> None:
+    """List all case notes for a patient."""
+    try:
+        _out(ctx, case_notes.list_case_notes(_client(ctx), patient_uuid))
+    except Exception as e:
+        _handle_error(e)
+
+
+@note.command("get")
+@click.argument("note_uuid")
+@click.pass_context
+def note_get(ctx, note_uuid: str) -> None:
+    """Get a single case note."""
+    try:
+        _out(ctx, case_notes.get_case_note(_client(ctx), note_uuid))
+    except Exception as e:
+        _handle_error(e)
+
+
+@note.command("report")
+@click.argument("patient_id")
+@click.option("--design", default="new", type=click.Choice(["old", "new", "markdown"]), show_default=True)
+@click.pass_context
+def note_report(ctx, patient_id: str, design: str) -> None:
+    """Generate a PDF case note report for a patient."""
+    try:
+        _out(ctx, case_notes.generate_case_note_report(_client(ctx), patient_id, design))
+    except Exception as e:
+        _handle_error(e)
+
+
+@note.command("categories")
+@click.pass_context
+def note_categories(ctx) -> None:
+    """List available case note categories."""
+    try:
+        _out(ctx, case_notes.list_case_note_categories(_client(ctx)))
+    except Exception as e:
+        _handle_error(e)
+
+
+@note.command("templates")
+@click.pass_context
+def note_templates(ctx) -> None:
+    """List available case note templates."""
+    try:
+        _out(ctx, case_notes.list_case_note_templates(_client(ctx)))
+    except Exception as e:
+        _handle_error(e)
+
+
+# ── Medication commands ───────────────────────────────────────────────────────
+
+@cli.group()
+def med() -> None:
+    """Medication and health summary."""
+
+
+@med.command("list")
+@click.argument("patient_id")
+@click.pass_context
+def med_list(ctx, patient_id: str) -> None:
+    """List medications for a patient."""
+    try:
+        _out(ctx, medication.get_medications(_client(ctx), patient_id))
+    except Exception as e:
+        _handle_error(e)
+
+
+@med.command("daily")
+@click.argument("patient_id")
+@click.pass_context
+def med_daily(ctx, patient_id: str) -> None:
+    """Show daily medication schedule for a patient."""
+    try:
+        _out(ctx, medication.get_daily_medication(_client(ctx), patient_id))
+    except Exception as e:
+        _handle_error(e)
+
+
+@med.command("monitoring")
+@click.argument("patient_id")
+@click.pass_context
+def med_monitoring(ctx, patient_id: str) -> None:
+    """Show medication monitoring data for a patient."""
+    try:
+        _out(ctx, medication.get_medication_monitoring(_client(ctx), patient_id))
+    except Exception as e:
+        _handle_error(e)
+
+
+@med.command("summary")
+@click.argument("patient_id")
+@click.pass_context
+def med_summary(ctx, patient_id: str) -> None:
+    """Show health summary for a patient."""
+    try:
+        _out(ctx, medication.get_health_summary(_client(ctx), patient_id))
+    except Exception as e:
+        _handle_error(e)
+
+
+# ── Staff commands ────────────────────────────────────────────────────────────
+
+@cli.group()
+def staff_cmd() -> None:
+    """Staff and organisation lookup."""
+
+
+staff_cmd.name = "staff"
+
+
+@staff_cmd.command("list")
+@click.pass_context
+def staff_list(ctx) -> None:
+    """List all staff in the organisation."""
+    try:
+        _out(ctx, staff.list_staff(_client(ctx)))
+    except Exception as e:
+        _handle_error(e)
+
+
+@staff_cmd.command("get")
+@click.argument("firebase_uid")
+@click.pass_context
+def staff_get(ctx, firebase_uid: str) -> None:
+    """Get a staff member by Firebase UID."""
+    try:
+        _out(ctx, staff.get_staff(_client(ctx), firebase_uid))
+    except Exception as e:
+        _handle_error(e)
+
+
+# ── Preview command ───────────────────────────────────────────────────────────
+
+@cli.command("preview")
+@click.argument("patient_id")
+@click.pass_context
+def preview(ctx, patient_id: str) -> None:
+    """Print a compact health snapshot for a patient."""
+    c = _client(ctx)
+    lines = []
+    try:
+        p = patients.get_patient(c, patient_id)
+        info = p.get("personal_info", p)
+        lines.append(f"Patient : {info.get('name', patient_id)}")
+        lines.append(f"IC      : {info.get('ic', 'n/a')}")
+        lines.append(f"Gender  : {info.get('gender', 'n/a')}")
+        lines.append(f"DOB     : {info.get('date_of_birth', 'n/a')}")
+    except Exception:
+        lines.append(f"Patient : {patient_id} (fetch failed)")
+
+    try:
+        labs = lab_reports.get_lab_reports(c, patient_id)
+        count = len(labs) if isinstance(labs, list) else labs.get("total", "?")
+        lines.append(f"Lab Rpts: {count}")
+    except Exception:
+        lines.append("Lab Rpts: (unavailable)")
+
+    try:
+        notes = case_notes.list_case_notes(c, patient_id)
+        count = len(notes) if isinstance(notes, list) else notes.get("total", "?")
+        lines.append(f"Notes   : {count}")
+    except Exception:
+        lines.append("Notes   : (unavailable)")
+
+    if ctx.obj.get("json"):
+        click.echo(json.dumps({"patient_id": patient_id, "summary": lines}))
+    else:
+        click.echo("\n".join(lines))
+
+
+# ── REPL entry ────────────────────────────────────────────────────────────────
+
+@cli.command("repl")
+@click.option("--json", "json_mode", is_flag=True, default=False)
+@click.pass_context
+def repl(ctx, json_mode: bool) -> None:
+    """Start interactive REPL session."""
+    skin = ReplSkin(cli, json_mode=json_mode or ctx.obj.get("json", False))
+    skin.run()
+
+
+cli.add_command(staff_cmd, name="staff")

cli_anything_medcare-0.1.0/cli_anything/medcare/tests/test_core.py

@@ -0,0 +1,159 @@
+"""Unit tests — no network, no real backend required."""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# ── Session helpers ───────────────────────────────────────────────────────────
+
+def _patch_session_file(tmp_path):
+    session_path = tmp_path / ".medcare_session.json"
+    return patch("cli_anything.medcare.utils.session.SESSION_FILE", session_path)
+
+
+def test_session_save_load(tmp_path):
+    with _patch_session_file(tmp_path):
+        from cli_anything.medcare.utils.session import save_token, get_session
+        save_token("http://localhost:8000", "tok123")
+        data = get_session()
+    assert data["base_url"] == "http://localhost:8000"
+    assert data["token"] == "tok123"
+
+
+def test_session_clear(tmp_path):
+    with _patch_session_file(tmp_path):
+        from cli_anything.medcare.utils.session import save_token, clear_session, get_session
+        save_token("http://localhost:8000", "tok123")
+        clear_session()
+        data = get_session()
+    assert data == {}
+
+
+def test_require_token_missing(tmp_path):
+    with _patch_session_file(tmp_path):
+        from cli_anything.medcare.utils.session import require_token
+        with pytest.raises(RuntimeError, match="Not logged in"):
+            require_token()
+
+
+# ── Client headers ────────────────────────────────────────────────────────────
+
+def test_client_headers():
+    from cli_anything.medcare.core.client import MedcareClient
+    c = MedcareClient(base_url="http://localhost:8000", token="mytoken")
+    assert c._headers() == {"Authorization": "Bearer mytoken"}
+
+
+# ── REPL skin ─────────────────────────────────────────────────────────────────
+
+def test_repl_skin_undo():
+    import click
+    from cli_anything.medcare.utils.repl_skin import ReplSkin
+
+    @click.group()
+    def dummy_cli():
+        pass
+
+    skin = ReplSkin(dummy_cli)
+    skin.push_history("patient list")
+    skin.push_history("lab list abc")
+    assert skin.undo() == "lab list abc"
+    assert skin.undo() == "patient list"
+    assert skin.undo() is None
+
+
+def test_repl_skin_dispatch_calls_cli():
+    import click
+    from cli_anything.medcare.utils.repl_skin import ReplSkin
+
+    @click.group()
+    def dummy_cli():
+        pass
+
+    called_with = []
+
+    def fake_main(args, standalone_mode):
+        called_with.extend(args)
+
+    dummy_cli.main = fake_main
+    skin = ReplSkin(dummy_cli)
+    skin._dispatch("patient list --page 2")
+    assert "patient" in called_with
+    assert "list" in called_with
+
+
+# ── Patient functions ─────────────────────────────────────────────────────────
+
+def test_patient_search_url():
+    from cli_anything.medcare.core import patients
+    mock_client = MagicMock()
+    mock_client.get.return_value = []
+    patients.search_patients(mock_client, "john")
+    mock_client.get.assert_called_once_with("/patient/v2/search/john")
+
+
+def test_patient_list_url():
+    from cli_anything.medcare.core import patients
+    mock_client = MagicMock()
+    mock_client.get.return_value = []
+    patients.list_patients(mock_client, page=3)
+    mock_client.get.assert_called_once_with("/patient/v2/all/3")
+
+
+# ── Lab report functions ──────────────────────────────────────────────────────
+
+def test_lab_upload_missing_file():
+    from cli_anything.medcare.core import lab_reports
+    mock_client = MagicMock()
+    with pytest.raises(FileNotFoundError):
+        lab_reports.upload_lab_report(mock_client, "patient-uuid", "/nonexistent/file.pdf")
+
+
+def test_lab_get_url():
+    from cli_anything.medcare.core import lab_reports
+    mock_client = MagicMock()
+    mock_client.get.return_value = {}
+    lab_reports.get_lab_report(mock_client, "report-uuid-123")
+    mock_client.get.assert_called_once_with("/health_info/lab_report/get/report-uuid-123")
+
+
+# ── Case note functions ───────────────────────────────────────────────────────
+
+def test_case_note_create_payload():
+    from cli_anything.medcare.core import case_notes
+    mock_client = MagicMock()
+    mock_client.post.return_value = {"id": "note-uuid"}
+    case_notes.create_case_note(
+        mock_client,
+        patient_uuid="p-uuid",
+        note_date="2025-01-15",
+        note_time="10.30 A.M.",
+        title="Follow-up",
+        details="Patient stable.",
+    )
+    call_kwargs = mock_client.post.call_args
+    payload = call_kwargs[1]["data"] if call_kwargs[1] else call_kwargs[0][1]
+    assert payload["patient_uuid"] == "p-uuid"
+    assert payload["note_date"] == "2025-01-15"
+    assert payload["title"] == "Follow-up"
+
+
+# ── Medication functions ──────────────────────────────────────────────────────
+
+def test_medication_paths():
+    from cli_anything.medcare.core import medication
+    mock_client = MagicMock()
+    mock_client.get.return_value = {}
+
+    medication.get_medications(mock_client, "pat-1")
+    mock_client.get.assert_called_with("/patient/v3/medication/pat-1")
+
+    medication.get_daily_medication(mock_client, "pat-1")
+    mock_client.get.assert_called_with("/daily-medication/pat-1")
+
+    medication.get_health_summary(mock_client, "pat-1")
+    mock_client.get.assert_called_with("/patient/v5/health-summary/pat-1")

cli_anything_medcare-0.1.0/cli_anything/medcare/tests/test_full_e2e.py

@@ -0,0 +1,182 @@
+"""
+End-to-end tests against a live Medcare backend.
+
+Required env vars:
+  MEDCARE_TEST_URL          — e.g. http://localhost:8000
+  MEDCARE_TEST_TOKEN        — valid Firebase ID token
+  MEDCARE_TEST_PATIENT_UUID — UUID of an existing patient
+
+Run with:
+  MEDCARE_TEST_URL=... MEDCARE_TEST_TOKEN=... MEDCARE_TEST_PATIENT_UUID=... pytest test_full_e2e.py -v
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+URL = os.environ.get("MEDCARE_TEST_URL", "")
+TOKEN = os.environ.get("MEDCARE_TEST_TOKEN", "")
+PATIENT_UUID = os.environ.get("MEDCARE_TEST_PATIENT_UUID", "")
+
+skip_live = pytest.mark.skipif(
+    not (URL and TOKEN),
+    reason="MEDCARE_TEST_URL and MEDCARE_TEST_TOKEN not set",
+)
+skip_patient = pytest.mark.skipif(
+    not PATIENT_UUID,
+    reason="MEDCARE_TEST_PATIENT_UUID not set",
+)
+
+
+def _resolve_cli() -> str:
+    """Return the installed CLI path or fall back to python -m."""
+    force_installed = os.environ.get("CLI_ANYTHING_FORCE_INSTALLED")
+    installed = shutil.which("medcare-agent")
+    if installed:
+        return installed
+    if force_installed:
+        pytest.fail("CLI_ANYTHING_FORCE_INSTALLED=1 but medcare-agent not found in PATH")
+    return None
+
+
+def _run(*args: str) -> subprocess.CompletedProcess:
+    cli_path = _resolve_cli()
+    if cli_path:
+        cmd = [cli_path] + list(args)
+    else:
+        cmd = [sys.executable, "-m", "cli_anything.medcare"] + list(args)
+    return subprocess.run(cmd, capture_output=True, text=True)
+
+
+def _run_json(*args: str) -> dict | list:
+    result = _run(*args, "--json")
+    assert result.returncode == 0, result.stderr
+    return json.loads(result.stdout)
+
+
+# ── Auth ──────────────────────────────────────────────────────────────────────
+
+@skip_live
+def test_login_logout():
+    result = _run("login", "--url", URL, "--token", TOKEN)
+    assert result.returncode == 0
+    assert "Session saved" in result.stdout
+
+    result = _run("whoami")
+    assert result.returncode == 0
+    assert URL in result.stdout
+
+    result = _run("logout")
+    assert result.returncode == 0
+
+    # Re-login for subsequent tests
+    _run("login", "--url", URL, "--token", TOKEN)
+
+
+# ── Patients ──────────────────────────────────────────────────────────────────
+
+@skip_live
+def test_patient_list():
+    _run("login", "--url", URL, "--token", TOKEN)
+    data = _run_json("patient", "list")
+    assert isinstance(data, (list, dict))
+
+
+@skip_live
+def test_patient_search():
+    _run("login", "--url", URL, "--token", TOKEN)
+    result = _run("--json", "patient", "search", "a")
+    assert result.returncode == 0
+    data = json.loads(result.stdout)
+    assert isinstance(data, (list, dict))
+
+
+@skip_live
+@skip_patient
+def test_patient_get():
+    _run("login", "--url", URL, "--token", TOKEN)
+    result = _run("--json", "patient", "get", PATIENT_UUID)
+    assert result.returncode == 0
+    data = json.loads(result.stdout)
+    assert "personal_info" in data or isinstance(data, dict)
+
+
+# ── Lab Reports ───────────────────────────────────────────────────────────────
+
+@skip_live
+@skip_patient
+def test_lab_list():
+    _run("login", "--url", URL, "--token", TOKEN)
+    result = _run("--json", "lab", "list", PATIENT_UUID)
+    assert result.returncode == 0
+    data = json.loads(result.stdout)
+    assert isinstance(data, (list, dict))
+
+
+@skip_live
+@skip_patient
+def test_lab_trends():
+    _run("login", "--url", URL, "--token", TOKEN)
+    result = _run("--json", "lab", "trends", PATIENT_UUID)
+    assert result.returncode == 0
+    data = json.loads(result.stdout)
+    assert isinstance(data, (list, dict))
+
+
+# ── Case Notes ────────────────────────────────────────────────────────────────
+
+@skip_live
+@skip_patient
+def test_note_list():
+    _run("login", "--url", URL, "--token", TOKEN)
+    result = _run("--json", "note", "list", PATIENT_UUID)
+    assert result.returncode == 0
+    data = json.loads(result.stdout)
+    assert isinstance(data, (list, dict))
+
+
+@skip_live
+def test_note_categories():
+    _run("login", "--url", URL, "--token", TOKEN)
+    result = _run("--json", "note", "categories")
+    assert result.returncode == 0
+    data = json.loads(result.stdout)
+    assert isinstance(data, (list, dict))
+
+
+# ── Staff ─────────────────────────────────────────────────────────────────────
+
+@skip_live
+def test_staff_list():
+    _run("login", "--url", URL, "--token", TOKEN)
+    result = _run("--json", "staff", "list")
+    assert result.returncode == 0
+    data = json.loads(result.stdout)
+    assert isinstance(data, (list, dict))
+
+
+# ── Preview ───────────────────────────────────────────────────────────────────
+
+@skip_live
+@skip_patient
+def test_preview():
+    _run("login", "--url", URL, "--token", TOKEN)
+    result = _run("preview", PATIENT_UUID)
+    assert result.returncode == 0
+    assert "Patient" in result.stdout
+
+
+# ── Installed command ─────────────────────────────────────────────────────────
+
+def test_installed_command_help():
+    """Verify the installed CLI entry point runs."""
+    cli_path = _resolve_cli()
+    if not cli_path:
+        pytest.skip("medcare-agent not installed; install with: pip install -e .")
+    result = subprocess.run([cli_path, "--help"], capture_output=True, text=True)
+    assert result.returncode == 0
+    assert "Medcare" in result.stdout

cli_anything_medcare-0.1.0/cli_anything/medcare/utils/auth.py

@@ -0,0 +1,42 @@
+"""Backend auth — calls /v1/auth/* endpoints instead of Firebase directly."""
+
+import requests
+
+
+def login(base_url: str, email: str, password: str) -> dict:
+    """POST /v1/auth/login → {firebase_token, refresh_token, user_id, email, display_name}"""
+    resp = requests.post(
+        f"{base_url}/v1/auth/login",
+        json={"email": email, "password": password, "origin": "medcare-cli"},
+        timeout=15,
+    )
+    if resp.status_code == 401:
+        detail = resp.json().get("detail", "Authentication failed.")
+        raise ValueError(detail)
+    resp.raise_for_status()
+    return resp.json()  # LoginResponse shape
+
+
+def refresh(base_url: str, refresh_token: str) -> dict:
+    """POST /v1/auth/refresh → {firebase_token, refresh_token}"""
+    resp = requests.post(
+        f"{base_url}/v1/auth/refresh",
+        json={"refresh_token": refresh_token},
+        timeout=15,
+    )
+    if resp.status_code in (400, 401):
+        raise ValueError("Refresh token expired — please log in again.")
+    resp.raise_for_status()
+    return resp.json()  # RefreshTokenResponse shape
+
+
+def logout_server(base_url: str, token: str) -> None:
+    """POST /v1/auth/logout — revokes all refresh tokens server-side."""
+    try:
+        requests.post(
+            f"{base_url}/v1/auth/logout",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+    except Exception:
+        pass  # best-effort; local session is cleared regardless

cli_anything_medcare-0.1.0/cli_anything/medcare/utils/repl_skin.py

@@ -0,0 +1,76 @@
+"""Unified REPL skin for the Medcare CLI harness."""
+
+import json
+import sys
+from typing import Callable, Optional
+import click
+
+
+BANNER = """\
+╔══════════════════════════════════════════╗
+║        Medcare CLI  •  type 'help'       ║
+╚══════════════════════════════════════════╝
+"""
+
+PROMPT = "medcare> "
+
+
+class ReplSkin:
+    """Interactive REPL that delegates lines to a Click group."""
+
+    def __init__(self, cli_group: click.Group, json_mode: bool = False):
+        self.cli = cli_group
+        self.json_mode = json_mode
+        self._history: list[str] = []
+
+    # ── History ──────────────────────────────────────────────────────────────
+
+    def push_history(self, line: str) -> None:
+        self._history.append(line)
+
+    def undo(self) -> Optional[str]:
+        return self._history.pop() if self._history else None
+
+    # ── Dispatch ─────────────────────────────────────────────────────────────
+
+    def _dispatch(self, line: str) -> None:
+        args = line.strip().split()
+        if not args:
+            return
+        if self.json_mode and "--json" not in args:
+            args.append("--json")
+        try:
+            self.cli.main(args=args, standalone_mode=False)
+        except click.UsageError as e:
+            click.echo(f"Error: {e}", err=True)
+        except SystemExit:
+            pass
+        except Exception as e:
+            click.echo(f"Error: {e}", err=True)
+
+    # ── Run ──────────────────────────────────────────────────────────────────
+
+    def run(self) -> None:
+        click.echo(BANNER)
+        while True:
+            try:
+                line = input(PROMPT).strip()
+            except (EOFError, KeyboardInterrupt):
+                click.echo("\nBye.")
+                break
+
+            if not line:
+                continue
+            if line in ("exit", "quit", "q"):
+                click.echo("Bye.")
+                break
+            if line == "undo":
+                last = self.undo()
+                click.echo(f"Removed from history: {last}" if last else "Nothing to undo.")
+                continue
+            if line in ("help", "?"):
+                self._dispatch("--help")
+                continue
+
+            self.push_history(line)
+            self._dispatch(line)

cli_anything_medcare-0.1.0/cli_anything/medcare/utils/session.py

@@ -0,0 +1,106 @@
+"""
+Session management: persist credentials to ~/.medcare_session.json.
+Locked writes prevent concurrent JSON corruption.
+Auto-refreshes the Firebase ID token when it is older than 55 minutes
+by calling the backend /v1/auth/refresh endpoint.
+"""
+
+import json
+import fcntl
+import time
+from pathlib import Path
+
+SESSION_FILE = Path.home() / ".medcare_session.json"
+
+_TOKEN_TTL = 55 * 60  # refresh 5 min before Firebase's 1-hour expiry
+
+
+def _load_raw() -> dict:
+    if not SESSION_FILE.exists():
+        return {}
+    try:
+        with open(SESSION_FILE, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def _save_raw(data: dict) -> None:
+    tmp = SESSION_FILE.with_suffix(".tmp")
+    with open(tmp, "w") as f:
+        fcntl.flock(f, fcntl.LOCK_EX)
+        json.dump(data, f, indent=2)
+        fcntl.flock(f, fcntl.LOCK_UN)
+    tmp.replace(SESSION_FILE)
+
+
+def get_session() -> dict:
+    return _load_raw()
+
+
+def save_session(
+    base_url: str,
+    token: str,
+    refresh_token: str,
+    local_id: str,
+    email: str,
+) -> None:
+    data = _load_raw()
+    data.update(
+        base_url=base_url.rstrip("/"),
+        token=token,
+        refresh_token=refresh_token,
+        local_id=local_id,
+        email=email,
+        issued_at=time.time(),
+    )
+    _save_raw(data)
+
+
+def save_token(base_url: str, token: str) -> None:
+    """Agent / CI mode: store only base_url + token, no auto-refresh."""
+    data = _load_raw()
+    data["base_url"] = base_url.rstrip("/")
+    data["token"] = token
+    data.pop("issued_at", None)  # absent = skip auto-refresh
+    _save_raw(data)
+
+
+def clear_session() -> None:
+    if SESSION_FILE.exists():
+        SESSION_FILE.unlink()
+
+
+def require_token() -> tuple[str, str]:
+    """Return (base_url, token). Auto-refreshes via backend if token is near expiry."""
+    data = _load_raw()
+    base_url = data.get("base_url")
+    token = data.get("token")
+
+    if not base_url or not token:
+        raise RuntimeError("Not logged in. Run: medcare-agent login")
+
+    issued_at = data.get("issued_at")
+    refresh_token = data.get("refresh_token")
+
+    if issued_at and refresh_token and (time.time() - issued_at) > _TOKEN_TTL:
+        try:
+            from cli_anything.medcare.utils.auth import refresh as backend_refresh
+            new = backend_refresh(base_url, refresh_token)
+            token = new["firebase_token"]
+            data["token"] = token
+            data["refresh_token"] = new["refresh_token"]
+            data["issued_at"] = time.time()
+            _save_raw(data)
+        except Exception:
+            raise RuntimeError(
+                "Session expired and token refresh failed. Run: medcare-agent login"
+            )
+
+    return base_url, token
+
+
+def update_session_key(key: str, value) -> None:
+    data = _load_raw()
+    data[key] = value
+    _save_raw(data)

cli_anything_medcare-0.1.0/cli_anything_medcare.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: cli-anything-medcare
+Version: 0.1.0
+Summary: CLI-Anything harness for the Medcare FastAPI backend
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.28
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

cli_anything_medcare-0.1.0/cli_anything_medcare.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+pyproject.toml
+setup.py
+cli_anything/medcare/__init__.py
+cli_anything/medcare/__main__.py
+cli_anything/medcare/medcare_cli.py
+cli_anything/medcare/core/__init__.py
+cli_anything/medcare/core/case_notes.py
+cli_anything/medcare/core/client.py
+cli_anything/medcare/core/lab_reports.py
+cli_anything/medcare/core/medication.py
+cli_anything/medcare/core/patients.py
+cli_anything/medcare/core/staff.py
+cli_anything/medcare/tests/test_core.py
+cli_anything/medcare/tests/test_full_e2e.py
+cli_anything/medcare/utils/auth.py
+cli_anything/medcare/utils/repl_skin.py
+cli_anything/medcare/utils/session.py
+cli_anything_medcare.egg-info/PKG-INFO
+cli_anything_medcare.egg-info/SOURCES.txt
+cli_anything_medcare.egg-info/dependency_links.txt
+cli_anything_medcare.egg-info/entry_points.txt
+cli_anything_medcare.egg-info/requires.txt
+cli_anything_medcare.egg-info/top_level.txt

cli_anything_medcare-0.1.0/cli_anything_medcare.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cli_anything_medcare-0.1.0/cli_anything_medcare.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+medcare = cli_anything.medcare.medcare_cli:cli
+medcare-agent = cli_anything.medcare.medcare_cli:cli

cli_anything_medcare-0.1.0/cli_anything_medcare.egg-info/requires.txt

@@ -0,0 +1,2 @@
+click>=8.0
+requests>=2.28

cli_anything_medcare-0.1.0/cli_anything_medcare.egg-info/top_level.txt

@@ -0,0 +1 @@
+cli_anything

cli_anything_medcare-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"

cli_anything_medcare-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cli_anything_medcare-0.1.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_namespace_packages
+
+setup(
+    name="cli-anything-medcare",
+    version="0.1.0",
+    description="CLI-Anything harness for the Medcare FastAPI backend",
+    packages=find_namespace_packages(include=["cli_anything.*"]),
+    install_requires=[
+        "click>=8.0",
+        "requests>=2.28",
+    ],
+    entry_points={
+        "console_scripts": [
+            "medcare-agent=cli_anything.medcare.medcare_cli:cli",
+            "medcare=cli_anything.medcare.medcare_cli:cli",
+        ]
+    },
+    python_requires=">=3.10",
+)