freelancer-payment-protection-cli 0.1.0__py3-none-any.whl

freelancer_payment_protection_cli/__init__.py

@@ -0,0 +1,6 @@
+"""freelancer-payment-protection-cli — command-line client for the
+freelancer-payment-protection API (invoice escalation, legal document
+generation, and client risk scoring for freelancers).
+"""
+
+__version__ = "0.1.0"

freelancer_payment_protection_cli/api.py

@@ -0,0 +1,89 @@
+"""
+Thin HTTP client for the freelancer-payment-protection FastAPI backend.
+
+Every route this module calls is a real endpoint read directly from
+apps/api/app/routers/*.py in the target repo:
+  - clients.py:       GET/POST /api/v1/clients, GET/PUT/DELETE /api/v1/clients/{id}
+  - invoices.py:       GET/POST /api/v1/invoices, GET /api/v1/invoices/{id},
+                        PATCH /api/v1/invoices/{id}/status
+  - escalations.py:    GET /api/v1/escalations, POST /api/v1/escalations/{id}/draft,
+                        GET /api/v1/escalations/{id}/history
+  - risk_scoring.py:    POST /api/v1/risk/score
+"""
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from . import auth, config
+
+
+class ApiError(RuntimeError):
+    def __init__(self, status_code: int, detail: str):
+        super().__init__(f"{status_code}: {detail}")
+        self.status_code = status_code
+        self.detail = detail
+
+
+class ApiClient:
+    def __init__(self, base_url: str | None = None, http: httpx.Client | None = None):
+        self.base_url = (base_url or config.api_url()).rstrip("/")
+        self._http = http or httpx.Client(timeout=30.0)
+        self._owns_http = http is None
+
+    def close(self) -> None:
+        if self._owns_http:
+            self._http.close()
+
+    def __enter__(self) -> "ApiClient":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+    def _request(self, method: str, path: str, retried: bool = False, **kwargs: Any) -> httpx.Response:
+        token = auth.get_valid_access_token(client=self._http)
+        headers = kwargs.pop("headers", {}) or {}
+        headers["Authorization"] = f"Bearer {token}"
+        url = f"{self.base_url}{path}"
+        response = self._http.request(method, url, headers=headers, **kwargs)
+
+        if response.status_code == 401 and not retried:
+            # Access token was rejected server-side (e.g. expired sooner than
+            # our local clock expected). Force a refresh and retry once.
+            creds = auth.load_credentials()
+            if creds is not None:
+                refreshed = auth.refresh(creds.refresh_token, client=self._http)
+                auth.save_credentials(refreshed)
+                return self._request(method, path, retried=True, **kwargs)
+
+        if response.status_code >= 400:
+            raise ApiError(response.status_code, _error_detail(response))
+
+        return response
+
+    def get(self, path: str, params: dict | None = None) -> Any:
+        return self._request("GET", path, params=params).json()
+
+    def post(self, path: str, json_body: dict | None = None) -> Any:
+        return self._request("POST", path, json=json_body).json()
+
+    def patch(self, path: str, json_body: dict | None = None) -> Any:
+        return self._request("PATCH", path, json=json_body).json()
+
+    def put(self, path: str, json_body: dict | None = None) -> Any:
+        return self._request("PUT", path, json=json_body).json()
+
+    def delete(self, path: str) -> None:
+        self._request("DELETE", path)
+
+
+def _error_detail(response: httpx.Response) -> str:
+    try:
+        data = response.json()
+        if isinstance(data, dict) and "detail" in data:
+            return str(data["detail"])
+        return str(data)
+    except ValueError:
+        return response.text

freelancer_payment_protection_cli/auth.py

@@ -0,0 +1,223 @@
+"""
+Authentication against Supabase's own REST auth API.
+
+The backend (apps/api/app/middleware/auth.py) validates Supabase-issued JWTs
+directly — it never mints tokens itself. So this CLI authenticates the same
+way the web app's Supabase client does: it calls Supabase's documented
+password-grant token endpoint directly, using the project's public anon key
+as the `apikey` header. The anon key is safe to ship in a client (that is
+its documented purpose in Supabase's own docs); it is not a secret.
+
+Reference: https://supabase.com/docs/reference/auth/token-password-grant
+"""
+from __future__ import annotations
+
+import json
+import os
+import stat
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from . import config
+
+
+class AuthError(RuntimeError):
+    """Raised when login, token storage, or token refresh fails."""
+
+
+@dataclass
+class Credentials:
+    access_token: str
+    refresh_token: str
+    expires_at: float  # unix timestamp
+    token_type: str = "bearer"
+
+    def is_expired(self, skew_seconds: int = 30) -> bool:
+        return time.time() >= (self.expires_at - skew_seconds)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Credentials":
+        return cls(
+            access_token=data["access_token"],
+            refresh_token=data["refresh_token"],
+            expires_at=float(data["expires_at"]),
+            token_type=data.get("token_type", "bearer"),
+        )
+
+
+def _supabase_headers() -> dict:
+    anon_key = config.supabase_anon_key()
+    if not anon_key:
+        raise AuthError(
+            "FPP_SUPABASE_ANON_KEY (or SUPABASE_ANON_KEY) is not set. "
+            "The CLI needs your Supabase project's anon key to authenticate, "
+            "the same public key the web app uses — see README.md 'Login and "
+            "authentication'."
+        )
+    return {"apikey": anon_key, "Content-Type": "application/json"}
+
+
+def _require_supabase_url() -> str:
+    url = config.supabase_url()
+    if not url:
+        raise AuthError(
+            "FPP_SUPABASE_URL (or SUPABASE_URL) is not set. Point it at your "
+            "Supabase project URL, e.g. https://your-project.supabase.co."
+        )
+    return url.rstrip("/")
+
+
+def login(email: str, password: str, client: httpx.Client | None = None) -> Credentials:
+    """
+    Calls Supabase's password-grant token endpoint directly:
+    POST {SUPABASE_URL}/auth/v1/token?grant_type=password
+    Body: {"email": ..., "password": ...}
+    Header: apikey: <anon key>
+    """
+    base = _require_supabase_url()
+    headers = _supabase_headers()
+    owns_client = client is None
+    http = client or httpx.Client(timeout=15.0)
+    try:
+        response = http.post(
+            f"{base}/auth/v1/token",
+            params={"grant_type": "password"},
+            headers=headers,
+            json={"email": email, "password": password},
+        )
+    except httpx.HTTPError as exc:
+        raise AuthError(f"Could not reach Supabase auth endpoint: {exc}") from exc
+    finally:
+        if owns_client:
+            http.close()
+
+    if response.status_code >= 400:
+        detail = _extract_error(response)
+        raise AuthError(f"Login failed ({response.status_code}): {detail}")
+
+    body = response.json()
+    return _credentials_from_token_response(body)
+
+
+def refresh(refresh_token: str, client: httpx.Client | None = None) -> Credentials:
+    """
+    Calls Supabase's refresh-token grant:
+    POST {SUPABASE_URL}/auth/v1/token?grant_type=refresh_token
+    Body: {"refresh_token": ...}
+    """
+    base = _require_supabase_url()
+    headers = _supabase_headers()
+    owns_client = client is None
+    http = client or httpx.Client(timeout=15.0)
+    try:
+        response = http.post(
+            f"{base}/auth/v1/token",
+            params={"grant_type": "refresh_token"},
+            headers=headers,
+            json={"refresh_token": refresh_token},
+        )
+    except httpx.HTTPError as exc:
+        raise AuthError(f"Could not reach Supabase auth endpoint: {exc}") from exc
+    finally:
+        if owns_client:
+            http.close()
+
+    if response.status_code >= 400:
+        detail = _extract_error(response)
+        raise AuthError(f"Token refresh failed ({response.status_code}): {detail}")
+
+    body = response.json()
+    return _credentials_from_token_response(body)
+
+
+def _credentials_from_token_response(body: dict) -> Credentials:
+    access_token = body.get("access_token")
+    refresh_token = body.get("refresh_token")
+    expires_in = body.get("expires_in", 3600)
+    if not access_token or not refresh_token:
+        raise AuthError(f"Unexpected response from Supabase auth endpoint: {body}")
+    return Credentials(
+        access_token=access_token,
+        refresh_token=refresh_token,
+        expires_at=time.time() + float(expires_in),
+        token_type=body.get("token_type", "bearer"),
+    )
+
+
+def _extract_error(response: httpx.Response) -> str:
+    try:
+        data = response.json()
+        return data.get("error_description") or data.get("msg") or data.get("error") or response.text
+    except (json.JSONDecodeError, ValueError):
+        return response.text
+
+
+def save_credentials(creds: Credentials) -> Path:
+    path = config.credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(creds.to_dict(), indent=2))
+    os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)  # chmod 600
+    return path
+
+
+def load_credentials() -> Credentials | None:
+    path = config.credentials_path()
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text())
+        return Credentials.from_dict(data)
+    except (json.JSONDecodeError, KeyError, ValueError):
+        return None
+
+
+def clear_credentials() -> bool:
+    path = config.credentials_path()
+    if path.exists():
+        path.unlink()
+        return True
+    return False
+
+
+def get_valid_access_token(client: httpx.Client | None = None) -> str:
+    """
+    Returns a valid access token, transparently refreshing (and persisting
+    the refreshed tokens) if the cached one has expired.
+    """
+    creds = load_credentials()
+    if creds is None:
+        raise AuthError("Not logged in. Run `fpp login` first.")
+
+    if creds.is_expired():
+        creds = refresh(creds.refresh_token, client=client)
+        save_credentials(creds)
+
+    return creds.access_token
+
+
+def decode_claims_unverified(token: str) -> dict[str, Any]:
+    """
+    Best-effort decode of the JWT payload for display purposes only
+    (`whoami`). Does not verify the signature — verification is the
+    backend's job (apps/api/app/middleware/auth.py); the CLI only reads
+    the claims to show the user which workspace/session is cached.
+    """
+    import base64
+
+    parts = token.split(".")
+    if len(parts) != 3:
+        return {}
+    payload = parts[1]
+    padding = "=" * (-len(payload) % 4)
+    try:
+        decoded = base64.urlsafe_b64decode(payload + padding)
+        return json.loads(decoded)
+    except (ValueError, json.JSONDecodeError):
+        return {}

freelancer_payment_protection_cli/commands/auth_cmds.py

@@ -0,0 +1,84 @@
+"""login / logout / whoami — Supabase password-grant auth, cached locally."""
+from __future__ import annotations
+
+import click
+
+from .. import auth
+from ..output import emit, emit_error, error_boundary, kv_table
+
+
+@click.command()
+def login() -> None:
+    """
+    Log in with your email and password.
+
+    Calls Supabase's own REST auth endpoint directly
+    (POST {SUPABASE_URL}/auth/v1/token?grant_type=password) using your
+    project's anon key — the same call the web app's Supabase client
+    makes. Requires FPP_SUPABASE_URL (or SUPABASE_URL) and
+    FPP_SUPABASE_ANON_KEY (or SUPABASE_ANON_KEY) to be set in your
+    environment.
+
+    On success, caches the access_token and refresh_token to
+    ~/.config/freelancer-payment-protection-cli/credentials.json (mode
+    600). Later commands silently refresh the access token using the
+    cached refresh_token once it expires.
+    """
+    email = click.prompt("Email")
+    password = click.prompt("Password", hide_input=True)
+
+    with error_boundary(as_json=False):
+        creds = auth.login(email, password)
+        path = auth.save_credentials(creds)
+    click.echo(f"Logged in as {email}.")
+    click.echo(f"Credentials cached at {path}")
+
+
+@click.command()
+def logout() -> None:
+    """Delete the locally cached credentials."""
+    removed = auth.clear_credentials()
+    if removed:
+        click.echo("Logged out. Cached credentials removed.")
+    else:
+        click.echo("Not logged in — nothing to remove.")
+
+
+@click.command()
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def whoami(as_json: bool) -> None:
+    """Show the workspace and session info from the cached access token."""
+    creds = auth.load_credentials()
+    if creds is None:
+        emit_error("Not logged in. Run `fpp login` first.", as_json)
+        raise SystemExit(1)
+
+    claims = auth.decode_claims_unverified(creds.access_token)
+    workspace_id = claims.get("workspace_id")
+    data = {
+        "workspace_id": workspace_id,
+        "email": claims.get("email"),
+        "expires_at": creds.expires_at,
+        "expired": creds.is_expired(),
+    }
+
+    if not workspace_id:
+        note = (
+            "Warning: cached token has no workspace_id claim. The backend's "
+            "get_current_workspace() dependency requires one — API calls "
+            "will fail with 401 until you log in with an account that has "
+            "a workspace_id configured on its Supabase JWT."
+        )
+        if not as_json:
+            click.echo(note, err=True)
+        else:
+            data["warning"] = note
+
+    human = kv_table(
+        [
+            ("Workspace ID", workspace_id or "(none)"),
+            ("Email", claims.get("email", "(unknown)")),
+            ("Token expired", data["expired"]),
+        ]
+    )
+    emit(data, as_json, human=human)

freelancer_payment_protection_cli/commands/client_cmds.py

@@ -0,0 +1,111 @@
+"""
+client list / show / risk
+
+Wraps apps/api/app/routers/clients.py and risk_scoring.py. ClientResponse
+fields (camelCase over the wire, same alias-generator pattern as
+InvoiceResponse): id, workspaceId, name, email, company, industry,
+country, riskScore, riskLevel, totalInvoiced, totalOutstanding,
+paymentTermsDays, averagePaymentDelay, contractUrl, notes, createdAt,
+updatedAt.
+
+risk_scoring.py's RiskScoreRequest is a plain (non-aliased) BaseModel with
+a single `client_id` field — unlike the other schemas in this repo, it
+does NOT accept a camelCase `clientId` key, so the CLI sends snake_case
+here specifically.
+"""
+from __future__ import annotations
+
+import click
+
+from ..api import ApiClient
+from ..output import emit, error_boundary, kv_table, simple_table
+
+RISK_LEVELS = {"low", "medium", "high", "critical"}
+
+
+@click.group()
+def client() -> None:
+    """Manage clients and client risk scoring."""
+
+
+@client.command("list")
+@click.option("--risk-level", type=click.Choice(sorted(RISK_LEVELS)), help="Filter by risk level.")
+@click.option("--search", help="Search by name or company.")
+@click.option("--page", default=1, show_default=True, type=int)
+@click.option("--page-size", default=20, show_default=True, type=int, help="Max 100 (server-enforced).")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def list_clients(risk_level: str | None, search: str | None, page: int, page_size: int, as_json: bool) -> None:
+    """List clients for the current workspace. GET /api/v1/clients"""
+    params = {"page": page, "page_size": page_size}
+    if risk_level:
+        params["risk_level"] = risk_level
+    if search:
+        params["search"] = search
+
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            clients = api.get("/api/v1/clients", params=params)
+
+    rows = [
+        [c["name"], c.get("company") or "-", c["riskLevel"], f"{c['riskScore']:.0f}", f"{c['totalOutstanding']:.2f}", c["id"]]
+        for c in clients
+    ]
+    human = simple_table(["NAME", "COMPANY", "RISK LEVEL", "RISK SCORE", "OUTSTANDING", "ID"], rows)
+    emit(clients, as_json, human=human)
+
+
+@client.command("show")
+@click.argument("client_id")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def show_client(client_id: str, as_json: bool) -> None:
+    """Show a single client. GET /api/v1/clients/{client_id}"""
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            c = api.get(f"/api/v1/clients/{client_id}")
+
+    human = kv_table(
+        [
+            ("Name", c["name"]),
+            ("Company", c.get("company") or "-"),
+            ("Email", c["email"]),
+            ("Risk level", c["riskLevel"]),
+            ("Risk score", c["riskScore"]),
+            ("Total invoiced", c["totalInvoiced"]),
+            ("Total outstanding", c["totalOutstanding"]),
+            ("Payment terms (days)", c["paymentTermsDays"]),
+            ("Average payment delay (days)", c["averagePaymentDelay"]),
+            ("Client ID", c["id"]),
+        ]
+    )
+    emit(c, as_json, human=human)
+
+
+@client.command("risk")
+@click.argument("client_id")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def client_risk(client_id: str, as_json: bool) -> None:
+    """
+    Compute (or re-compute) a client's AI risk score.
+    POST /api/v1/risk/score  body: {"client_id": ...}
+
+    Score is 0-100. Thresholds (apps/api/app/services/risk_service.py's
+    _compute_heuristic_risk): 0-25 low, 26-50 medium, 51-75 high, 76-100 critical.
+    Rate-limited server-side to 30 requests/minute per the @limiter.limit
+    decorator on this route.
+    """
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            result = api.post("/api/v1/risk/score", json_body={"client_id": client_id})
+
+    factors = result.get("factors") or []
+    factor_lines = "\n".join(f"  - {f.get('name', '?')}: {f.get('description', '')}" for f in factors)
+    human = kv_table(
+        [
+            ("Score", result.get("score")),
+            ("Level", result.get("level")),
+            ("Reasoning", result.get("reasoning") or "-"),
+        ]
+    )
+    if factor_lines:
+        human += f"\nFactors:\n{factor_lines}"
+    emit(result, as_json, human=human)

freelancer_payment_protection_cli/commands/escalation_cmds.py

@@ -0,0 +1,142 @@
+"""
+escalation list / status / advance
+
+Wraps apps/api/app/routers/escalations.py, which exposes exactly three
+routes: GET "" (all active escalations grouped by stage), POST
+"/{invoice_id}/draft" (AI-drafts the next stage's email), and GET
+"/{invoice_id}/history" (past escalation events for one invoice). There is
+no endpoint in this API that persists a stage change — draft_escalation_email
+in apps/api/app/services/escalation_service.py only computes and returns
+what the next stage's email would say; it never writes escalation_stage
+back to the database. `advance` below reflects that honestly: it drafts
+the next-stage email and says so, it does not claim to move the invoice
+to that stage.
+
+`status` is not a single endpoint either — the closest real equivalent is
+the invoice's own escalationStage/daysPastDue/nextEscalationDate fields
+(GET /api/v1/invoices/{id}) plus its escalation history
+(GET /api/v1/escalations/{id}/history), so this command calls both.
+
+Stage order (apps/api/app/services/escalation_service.py STAGE_ORDER):
+  polite_reminder -> firm_notice -> final_warning -> legal_demand -> legal_action
+This product's documented policy calls for 7d -> 7d -> 5d -> 7d minimum
+waits between stages, but the /draft endpoint itself does not enforce
+those waits — it only checks stage order (get_next_stage), so a draft can
+be requested at any time regardless of how recently the previous stage
+was sent.
+"""
+from __future__ import annotations
+
+import click
+
+from ..api import ApiClient
+from ..output import emit, error_boundary, kv_table, simple_table
+
+STAGE_ORDER = ["polite_reminder", "firm_notice", "final_warning", "legal_demand", "legal_action"]
+
+
+@click.group()
+def escalation() -> None:
+    """Manage invoice escalations."""
+
+
+@escalation.command("list")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def list_escalations(as_json: bool) -> None:
+    """List every active escalation, grouped by stage. GET /api/v1/escalations"""
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            grouped = api.get("/api/v1/escalations")
+
+    rows = []
+    for stage in STAGE_ORDER:
+        for item in grouped.get(stage, []):
+            rows.append(
+                [
+                    stage,
+                    item["invoiceNumber"],
+                    f"{item['amount']:.2f} {item['currency']}",
+                    item["daysPastDue"],
+                    item["clientName"],
+                    item["invoiceId"],
+                ]
+            )
+    human = simple_table(["STAGE", "INVOICE #", "AMOUNT", "DAYS PAST DUE", "CLIENT", "INVOICE ID"], rows)
+    emit(grouped, as_json, human=human)
+
+
+@escalation.command("status")
+@click.argument("invoice_id")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def escalation_status(invoice_id: str, as_json: bool) -> None:
+    """
+    Show an invoice's current escalation stage and its history.
+    Combines GET /api/v1/invoices/{invoice_id} with
+    GET /api/v1/escalations/{invoice_id}/history.
+    """
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            inv = api.get(f"/api/v1/invoices/{invoice_id}")
+            history = api.get(f"/api/v1/escalations/{invoice_id}/history")
+
+    combined = {"invoice": inv, "history": history}
+
+    lines = [
+        kv_table(
+            [
+                ("Invoice #", inv["invoiceNumber"]),
+                ("Status", inv["status"]),
+                ("Current stage", inv.get("escalationStage") or "(none)"),
+                ("Days past due", inv["daysPastDue"]),
+                ("Next escalation date", inv.get("nextEscalationDate") or "-"),
+                ("Last escalated at", inv.get("lastEscalatedAt") or "-"),
+            ]
+        )
+    ]
+    if history:
+        rows = [
+            [h["stage"], h.get("sentAt") or "-", f"{h.get('aiConfidenceScore', 0):.0%}" if h.get("aiConfidenceScore") is not None else "-", h.get("outcome") or "-"]
+            for h in history
+        ]
+        lines.append("\nHistory:")
+        lines.append(simple_table(["STAGE", "SENT AT", "AI CONFIDENCE", "OUTCOME"], rows))
+    else:
+        lines.append("\nNo escalation history yet.")
+
+    emit(combined, as_json, human="\n".join(lines))
+
+
+@escalation.command("advance")
+@click.argument("invoice_id")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def escalation_advance(invoice_id: str, as_json: bool) -> None:
+    """
+    AI-draft the next escalation stage's email for an invoice.
+    POST /api/v1/escalations/{invoice_id}/draft
+
+    This previews what the next stage's email would say. It does not
+    change the invoice's stored escalation stage: the backend has no
+    endpoint that persists that change today, only this preview endpoint.
+    Send/record the actual escalation through the product's own workflow.
+    """
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            draft = api.post(f"/api/v1/escalations/{invoice_id}/draft")
+
+    if "error" in draft:
+        emit(draft, as_json, human=f"{draft['error']}\n{draft.get('message', '')}")
+        return
+
+    human = kv_table(
+        [
+            ("Next stage", f"{draft.get('stage')} ({draft.get('stage_label', '')})"),
+            ("Subject", draft.get("subject")),
+            ("Confidence", draft.get("confidence_score")),
+        ]
+    )
+    human += f"\n\n{draft.get('body', '')}"
+    human += (
+        "\n\n(Preview only — no stage change was persisted. This API does not "
+        "expose an endpoint that writes the stage back to the invoice.)"
+    )
+    emit(draft, as_json, human=human)

freelancer_payment_protection_cli/commands/invoice_cmds.py

@@ -0,0 +1,145 @@
+"""
+invoice list / create / show / set-status
+
+Wraps apps/api/app/routers/invoices.py. Every field name below matches
+apps.api.app.schemas.invoice.{InvoiceCreate,InvoiceStatusUpdate,InvoiceResponse}
+exactly. Those schemas use a camelCase alias generator with
+populate_by_name=True and FastAPI's default response_model_by_alias=True,
+so requests accept either casing but responses are camelCase over the wire
+(clientId, invoiceNumber, dueDate, daysPastDue, escalationStage,
+sourceSystem, externalId, lineItems, lastEscalatedAt, nextEscalationDate,
+evidenceCount, createdAt, updatedAt).
+"""
+from __future__ import annotations
+
+import click
+
+from ..api import ApiClient
+from ..output import emit, error_boundary, simple_table
+
+VALID_STATUSES = {"paid", "pending", "overdue", "disputed", "written_off"}
+
+
+@click.group()
+def invoice() -> None:
+    """Manage invoices (apps/api/app/routers/invoices.py)."""
+
+
+@invoice.command("list")
+@click.option("--status", "status_filter", type=click.Choice(sorted(VALID_STATUSES)), help="Filter by invoice status.")
+@click.option("--client-id", help="Filter by client ID.")
+@click.option("--page", default=1, show_default=True, type=int)
+@click.option("--page-size", default=20, show_default=True, type=int, help="Max 100 (server-enforced).")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def list_invoices(status_filter: str | None, client_id: str | None, page: int, page_size: int, as_json: bool) -> None:
+    """List invoices for the current workspace. GET /api/v1/invoices"""
+    params = {"page": page, "page_size": page_size}
+    if status_filter:
+        params["status"] = status_filter
+    if client_id:
+        params["client_id"] = client_id
+
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            invoices = api.get("/api/v1/invoices", params=params)
+
+    rows = [
+        [
+            inv["invoiceNumber"],
+            inv["status"],
+            f"{inv['amount']:.2f} {inv['currency']}",
+            inv["daysPastDue"],
+            inv.get("escalationStage") or "-",
+            inv["id"],
+        ]
+        for inv in invoices
+    ]
+    human = simple_table(["INVOICE #", "STATUS", "AMOUNT", "DAYS PAST DUE", "STAGE", "ID"], rows)
+    emit(invoices, as_json, human=human)
+
+
+@invoice.command("create")
+@click.option("--client-id", required=True)
+@click.option("--invoice-number", required=True)
+@click.option("--amount", required=True, type=float)
+@click.option("--currency", default="USD", show_default=True)
+@click.option("--due-date", required=True, help="ISO 8601 datetime, e.g. 2026-08-15T00:00:00Z")
+@click.option("--source-system", default=None)
+@click.option("--external-id", default=None)
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def create_invoice(
+    client_id: str,
+    invoice_number: str,
+    amount: float,
+    currency: str,
+    due_date: str,
+    source_system: str | None,
+    external_id: str | None,
+    as_json: bool,
+) -> None:
+    """Create an invoice. POST /api/v1/invoices"""
+    body = {
+        "clientId": client_id,
+        "invoiceNumber": invoice_number,
+        "amount": amount,
+        "currency": currency,
+        "dueDate": due_date,
+        "sourceSystem": source_system,
+        "externalId": external_id,
+        "lineItems": [],
+    }
+
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            created = api.post("/api/v1/invoices", json_body=body)
+
+    human = f"Created invoice {created['invoiceNumber']} ({created['id']}) — {created['amount']:.2f} {created['currency']}"
+    emit(created, as_json, human=human)
+
+
+@invoice.command("show")
+@click.argument("invoice_id")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def show_invoice(invoice_id: str, as_json: bool) -> None:
+    """Show a single invoice. GET /api/v1/invoices/{invoice_id}"""
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            inv = api.get(f"/api/v1/invoices/{invoice_id}")
+
+    from ..output import kv_table
+
+    human = kv_table(
+        [
+            ("Invoice #", inv["invoiceNumber"]),
+            ("Status", inv["status"]),
+            ("Amount", f"{inv['amount']:.2f} {inv['currency']}"),
+            ("Due date", inv["dueDate"]),
+            ("Days past due", inv["daysPastDue"]),
+            ("Escalation stage", inv.get("escalationStage") or "-"),
+            ("Next escalation date", inv.get("nextEscalationDate") or "-"),
+            ("Last escalated at", inv.get("lastEscalatedAt") or "-"),
+            ("Evidence count", inv["evidenceCount"]),
+            ("Client ID", inv["clientId"]),
+            ("Invoice ID", inv["id"]),
+        ]
+    )
+    emit(inv, as_json, human=human)
+
+
+@invoice.command("set-status")
+@click.argument("invoice_id")
+@click.argument("new_status", type=click.Choice(sorted(VALID_STATUSES)))
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def set_invoice_status(invoice_id: str, new_status: str, as_json: bool) -> None:
+    """
+    Update an invoice's status. PATCH /api/v1/invoices/{invoice_id}/status
+
+    Setting status to "paid" also clears escalationStage and
+    nextEscalationDate server-side (see invoices.py update_invoice_status).
+    """
+    with error_boundary(as_json):
+        with ApiClient() as api:
+            updated = api.patch(f"/api/v1/invoices/{invoice_id}/status", json_body={"status": new_status})
+
+    human = f"Invoice {updated['invoiceNumber']} status set to {updated['status']}."
+    emit(updated, as_json, human=human)

freelancer_payment_protection_cli/config.py

@@ -0,0 +1,45 @@
+"""
+Configuration and credential-storage paths.
+
+The API base URL and Supabase project settings are read from environment
+variables so the same CLI build works against any deployment (local dev
+server, self-hosted, or a hosted instance) without hardcoding a URL that
+does not exist for every installer of this package.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+CLI_NAME = "freelancer-payment-protection-cli"
+
+# Backend API base URL. Defaults to the FastAPI dev server's default port
+# (apps/api/README instructions: `uvicorn app.main:app --reload` serves on
+# http://localhost:8000, with routers mounted under /api/v1).
+DEFAULT_API_URL = "http://localhost:8000"
+
+
+def api_url() -> str:
+    return os.environ.get("FPP_API_URL", DEFAULT_API_URL).rstrip("/")
+
+
+def supabase_url() -> str | None:
+    # FPP_SUPABASE_URL takes precedence; falls back to the same SUPABASE_URL
+    # name the backend's own .env.example uses, since the anon-key auth
+    # endpoint lives on the same Supabase project as the backend.
+    return os.environ.get("FPP_SUPABASE_URL") or os.environ.get("SUPABASE_URL")
+
+
+def supabase_anon_key() -> str | None:
+    return os.environ.get("FPP_SUPABASE_ANON_KEY") or os.environ.get("SUPABASE_ANON_KEY")
+
+
+def config_dir() -> Path:
+    override = os.environ.get("FPP_CONFIG_DIR")
+    if override:
+        return Path(override)
+    return Path.home() / ".config" / CLI_NAME
+
+
+def credentials_path() -> Path:
+    return config_dir() / "credentials.json"

freelancer_payment_protection_cli/main.py

@@ -0,0 +1,43 @@
+"""CLI entry point. Registered as console scripts `fpp` and
+`freelancer-payment-protection` (see pyproject.toml [project.scripts])."""
+from __future__ import annotations
+
+import click
+
+from . import __version__
+from .commands.auth_cmds import login, logout, whoami
+from .commands.client_cmds import client
+from .commands.escalation_cmds import escalation
+from .commands.invoice_cmds import invoice
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="freelancer-payment-protection-cli")
+def cli() -> None:
+    """
+    Command-line client for freelancer-payment-protection: automated
+    invoice escalation, legal document generation, and client risk
+    scoring for freelancers.
+
+    Every command talks to a real freelancer-payment-protection API
+    instance (default http://localhost:8000, override with FPP_API_URL).
+    Log in first with `fpp login`.
+
+    Every data-returning command supports --json for scripting/agent use.
+    """
+
+
+cli.add_command(login)
+cli.add_command(logout)
+cli.add_command(whoami)
+cli.add_command(invoice)
+cli.add_command(escalation)
+cli.add_command(client)
+
+
+def main() -> None:
+    cli()
+
+
+if __name__ == "__main__":
+    main()

freelancer_payment_protection_cli/output.py

@@ -0,0 +1,72 @@
+"""Shared output helpers: --json passthrough vs. a plain human-readable table."""
+from __future__ import annotations
+
+import json
+from contextlib import contextmanager
+from typing import Any, Iterator
+
+import click
+
+from .api import ApiError
+from .auth import AuthError
+
+
+@contextmanager
+def error_boundary(as_json: bool) -> Iterator[None]:
+    """
+    Wraps a command body: turns ApiError/AuthError into a clean message
+    (JSON-shaped when --json is set) and a non-zero exit, instead of a
+    Python traceback.
+    """
+    try:
+        yield
+    except ApiError as exc:
+        emit_error(exc.detail, as_json, status_code=exc.status_code)
+        raise SystemExit(1)
+    except AuthError as exc:
+        emit_error(str(exc), as_json)
+        raise SystemExit(1)
+
+
+def emit(data: Any, as_json: bool, human: str | None = None) -> None:
+    """
+    Prints `data` as JSON when --json is set, otherwise prints `human` if
+    given, else falls back to a generic key/value dump of `data`.
+    """
+    if as_json:
+        click.echo(json.dumps(data, indent=2, default=str))
+        return
+    if human is not None:
+        click.echo(human)
+        return
+    click.echo(json.dumps(data, indent=2, default=str))
+
+
+def emit_error(message: str, as_json: bool, status_code: int | None = None) -> None:
+    if as_json:
+        payload: dict[str, Any] = {"error": message}
+        if status_code is not None:
+            payload["status_code"] = status_code
+        click.echo(json.dumps(payload, indent=2), err=False)
+    else:
+        click.echo(f"Error: {message}", err=True)
+
+
+def kv_table(rows: list[tuple[str, Any]]) -> str:
+    width = max((len(k) for k, _ in rows), default=0)
+    return "\n".join(f"{k.ljust(width)} : {v}" for k, v in rows)
+
+
+def simple_table(headers: list[str], rows: list[list[Any]]) -> str:
+    if not rows:
+        return "(no results)"
+    widths = [len(h) for h in headers]
+    str_rows = [[str(cell) for cell in row] for row in rows]
+    for row in str_rows:
+        for i, cell in enumerate(row):
+            widths[i] = max(widths[i], len(cell))
+    lines = ["  ".join(h.ljust(widths[i]) for i, h in enumerate(headers))]
+    lines.append("  ".join("-" * w for w in widths))
+    for row in str_rows:
+        lines.append("  ".join(cell.ljust(widths[i]) for i, cell in enumerate(row)))
+    return "\n".join(lines)

freelancer_payment_protection_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.4
+Name: freelancer-payment-protection-cli
+Version: 0.1.0
+Summary: Command-line client for freelancer-payment-protection: automated invoice escalation, legal document generation, and client risk scoring for freelancers.
+Project-URL: Homepage, https://github.com/RudrenduPaul/freelancer-payment-protection
+Project-URL: Repository, https://github.com/RudrenduPaul/freelancer-payment-protection
+Project-URL: Bug Tracker, https://github.com/RudrenduPaul/freelancer-payment-protection/issues
+Author: Rudrendu Paul, Sourav Nandy
+License: Proprietary
+License-File: LICENSE
+Keywords: agent-native,cli,fastapi,freelance,invoice-escalation,invoicing,risk-scoring,supabase
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Accounting
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: click<9,>=8.1
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov<7,>=5.0; extra == 'dev'
+Requires-Dist: pytest<9,>=8.0; extra == 'dev'
+Requires-Dist: respx<1,>=0.21; extra == 'dev'
+Requires-Dist: twine<7,>=5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# freelancer-payment-protection-cli
+
+Command-line client for [freelancer-payment-protection](https://github.com/RudrenduPaul/freelancer-payment-protection):
+automated invoice escalation, legal document generation, and client risk
+scoring for freelancers. This package wraps the project's FastAPI backend
+(`apps/api/app/routers/*.py`) so the same clients, invoices, escalations,
+and risk-scoring data you'd otherwise reach through the dashboard or the
+raw HTTP API is scriptable from a terminal or an agent.
+
+![Login and first command](../../docs/demo.gif)
+
+## Install
+
+```bash
+pip install freelancer-payment-protection-cli
+```
+
+Or with [uv](https://docs.astral.sh/uv/) / [pipx](https://pipx.pypa.io/):
+
+```bash
+uvx freelancer-payment-protection-cli --help
+pipx install freelancer-payment-protection-cli
+```
+
+Requires Python 3.10+. The console command is installed as both `fpp`
+(short form) and `freelancer-payment-protection` (full form) — they are the
+same entry point.
+
+## Configuration
+
+The CLI needs to know two things: which backend API to talk to, and which
+Supabase project issues your login tokens.
+
+| Variable | Purpose | Default |
+|---|---|---|
+| `FPP_API_URL` | Backend API base URL | `http://localhost:8000` |
+| `FPP_SUPABASE_URL` (or `SUPABASE_URL`) | Your Supabase project URL | none, required for `login` |
+| `FPP_SUPABASE_ANON_KEY` (or `SUPABASE_ANON_KEY`) | Your Supabase project's anon key | none, required for `login` |
+
+The anon key is the same public key the web app's Supabase client uses —
+it is not a secret, and it's the key already in `apps/web/.env.example` as
+`NEXT_PUBLIC_SUPABASE_ANON_KEY`.
+
+## Login and authentication
+
+```bash
+export FPP_SUPABASE_URL="https://your-project.supabase.co"
+export FPP_SUPABASE_ANON_KEY="your-anon-key"
+fpp login
+```
+
+`fpp login` prompts for your email and password, then calls Supabase's own
+REST auth endpoint directly:
+
+```
+POST {SUPABASE_URL}/auth/v1/token?grant_type=password
+Header: apikey: <anon key>
+Body:   {"email": ..., "password": ...}
+```
+
+This is the same call the web dashboard's Supabase client makes — the CLI
+never talks to a login endpoint of its own, because the backend
+(`apps/api/app/middleware/auth.py`) doesn't mint tokens; it only validates
+Supabase-issued JWTs. On success, the returned `access_token` and
+`refresh_token` are cached to `~/.config/freelancer-payment-protection-cli/credentials.json`
+(mode 600). Every later command reads the JWT's `workspace_id` claim the
+same way `get_current_workspace()` does server-side, and transparently
+refreshes the access token with the cached refresh token once it expires.
+
+Run `fpp logout` to delete the cached credentials, or `fpp whoami` to see
+which workspace and email the cached token resolves to.
+
+## Commands
+
+Every data-returning command supports `--json` for scripting and agent use.
+
+```
+fpp login                                   Log in (prompts for email/password)
+fpp logout                                  Remove cached credentials
+fpp whoami [--json]                         Show cached workspace/session info
+
+fpp invoice list [--status] [--client-id] [--page] [--page-size] [--json]
+fpp invoice create --client-id --invoice-number --amount --due-date [...] [--json]
+fpp invoice show <invoice-id> [--json]
+fpp invoice set-status <invoice-id> <status> [--json]
+
+fpp escalation list [--json]                Active escalations, grouped by stage
+fpp escalation status <invoice-id> [--json] Current stage + full history
+fpp escalation advance <invoice-id> [--json] AI-draft the next stage's email
+
+fpp client list [--risk-level] [--search] [--page] [--page-size] [--json]
+fpp client show <client-id> [--json]
+fpp client risk <client-id> [--json]        Compute/refresh the AI risk score
+```
+
+Run `fpp --help` or `fpp <command> --help` for full flag references.
+
+![Filtering invoices, scoring a client, and checking escalation status](../../docs/usage.gif)
+
+### A note on `escalation advance`
+
+The backend's escalation router (`apps/api/app/routers/escalations.py`)
+exposes exactly three routes: list active escalations, draft the next
+stage's email, and read history. There is no route that persists a stage
+change — `draft_escalation_email` in `escalation_service.py` computes and
+returns what the next stage's email would say, but never writes
+`escalation_stage` back to the database. `fpp escalation advance` calls
+that draft endpoint and shows you the preview; it does not claim to move
+the invoice to the next stage, because the API it wraps doesn't do that
+either.
+
+### JSON output for agents/scripts
+
+```bash
+fpp invoice list --status overdue --json | jq '.[] | {id, invoiceNumber, daysPastDue}'
+fpp client risk "$CLIENT_ID" --json | jq '.level'
+```
+
+Field names in `--json` output match the backend's actual Pydantic response
+models exactly (camelCase, e.g. `invoiceNumber`, `daysPastDue`,
+`escalationStage`) since the CLI passes the API's response straight
+through rather than remapping it.
+
+## FAQ
+
+**What is this, and how is it different from just calling the API with curl?**
+It's a typed command-line wrapper around the same backend the web
+dashboard uses — invoices, escalations, and client risk scoring — with
+persistent login (so you're not re-attaching a bearer token to every
+request), human-readable tables by default, and a `--json` flag on every
+data command for piping into `jq`, scripts, or an agent's tool-calling
+loop. The differentiator versus curl is session handling (login once,
+silent token refresh after) and consistent, documented output shapes
+instead of hand-rolled request construction.
+
+**What platforms and Python versions does it support?**
+Python 3.10 through 3.13, on any OS `pip`/`uvx`/`pipx` runs on (Linux,
+macOS, Windows). It has no compiled dependencies — the only runtime
+dependencies are `click` and `httpx`, both pure-Python-installable wheels.
+
+**How do I log in, and where are my credentials stored?**
+Run `fpp login`, enter your email and password when prompted. The CLI
+calls Supabase's password-grant token endpoint directly (see "Login and
+authentication" above) and caches the resulting access and refresh tokens
+to `~/.config/freelancer-payment-protection-cli/credentials.json` with
+file mode 600 (owner read/write only). Nothing is sent anywhere except
+Supabase's own auth endpoint and the backend API you configure via
+`FPP_API_URL`.
+
+**I ran a command and got `Error: Internal Server Error` — is that a CLI bug?**
+Usually not. The CLI's error handling surfaces whatever the backend
+returned; a 500 means the backend itself failed. Two real, backend-side
+causes to check first: (1) `fpp client risk` and `fpp escalation advance`
+both trigger AI calls through `packages/legal_ai/client.py` — if
+`ANTHROPIC_API_KEY` isn't a real key on the server, `client risk` falls
+back to a heuristic score automatically, but `escalation advance` has no
+such fallback and will 500. (2) Confirm you're running a backend build
+that includes the `packages/legal_ai` module-name fix and the
+`risk_scoring.py` request-parameter fix — both were real bugs in this
+repo (a hyphenated `packages/legal-ai` directory that the code imports as
+`packages.legal_ai`, and a rate-limiter/parameter-name collision on
+`/api/v1/risk/score`) that this CLI's own end-to-end testing surfaced and
+this same change fixed. A plain 401 means your cached token expired and
+couldn't refresh — run `fpp login` again.
+
+**Does `fpp escalation advance` actually send the escalation email or move the invoice to the next stage?**
+No. It calls the backend's `/api/v1/escalations/{id}/draft` endpoint,
+which only returns an AI-drafted preview of what the next stage's email
+would say. The backend has no endpoint today that persists a stage change
+or sends the email — see "A note on `escalation advance`" above.
+
+**Can I point this at a self-hosted or non-default backend?**
+Yes. Set `FPP_API_URL` to your backend's base URL (default is
+`http://localhost:8000`, matching the FastAPI dev server's default port).
+Every command reads that variable at call time, so switching environments
+is just re-exporting it.
+
+**What's the licensing situation — can I use or modify this commercially?**
+This CLI ships from the same repository as, and under the same license
+as, freelancer-payment-protection itself: a proprietary license, copyright
+Rudrendu Paul and Sourav Nandy, all rights reserved. Personal, academic,
+commercial, or scheduled use requires explicit written permission from
+both owners — see the `LICENSE` file. This is not an MIT/Apache-style
+open-source license; publishing it to PyPI makes it installable, not
+freely reusable.
+
+**Why isn't there a hosted/default API URL I can just start using?**
+freelancer-payment-protection is self-hosted software, not a hosted
+multi-tenant SaaS with a public API endpoint today. You (or whoever
+operates your workspace) runs the backend; the CLI just needs its URL.
+
+## Development
+
+```bash
+cd packages/cli
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+All HTTP calls (to Supabase and to the backend API) are mocked in tests
+with `respx` — the test suite makes no live network calls.
+
+## Contributing
+
+This package lives inside the freelancer-payment-protection monorepo. See
+the repository root for contribution guidelines.
+
+## License
+
+Proprietary — see [`LICENSE`](./LICENSE). Contact the owners (see
+`LICENSE`) before any use beyond installing and running the package as
+published.

freelancer_payment_protection_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+freelancer_payment_protection_cli/__init__.py,sha256=AamRexv0y8UFRRerE5RRy9efDpNVEq90dQNyMo5TD9k,220
+freelancer_payment_protection_cli/api.py,sha256=FTx01e3xmeeXMtG317qXKOqpX7k_RrXaYDb8XxZTL6Q,3304
+freelancer_payment_protection_cli/auth.py,sha256=qemALBy0Hviwo91apFbETzYRCv80HF4L1pUETq22QE4,7114
+freelancer_payment_protection_cli/config.py,sha256=n_nupRlHbLM6hwatshgV0gV8Q0A-GhXJ6-OkW0iSCKM,1500
+freelancer_payment_protection_cli/main.py,sha256=iiENxnwmfmKMIJz7snlT3r-twB-qPfMUvU0cbKNMJ9I,1179
+freelancer_payment_protection_cli/output.py,sha256=uz0EfFx_HQOyaZKM2n-157pD2flKRbwyb9sdhZPf8xo,2337
+freelancer_payment_protection_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+freelancer_payment_protection_cli/commands/auth_cmds.py,sha256=2cpWSRSJGC4ok6X2dCxXlCAK0s7CBSGOhx4SIUNgEb4,2825
+freelancer_payment_protection_cli/commands/client_cmds.py,sha256=OeV9eOgmQG6MSOrR6ZtTcutTHIsQpwUkxUjIy5dV6mw,4239
+freelancer_payment_protection_cli/commands/escalation_cmds.py,sha256=z2lq8lTsu8fvzYmCaGyIlmx-bgsL94o4tAJZ1M938rk,5615
+freelancer_payment_protection_cli/commands/invoice_cmds.py,sha256=ngjQHJ9lKav41cR3zpO87d1iTE55unE7zWZYSznwmXQ,5528
+freelancer_payment_protection_cli-0.1.0.dist-info/METADATA,sha256=YYdPV1vyINyR3nARVtyasFDGK_tC5qQk5NIkSi5g1f4,11029
+freelancer_payment_protection_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+freelancer_payment_protection_cli-0.1.0.dist-info/entry_points.txt,sha256=8pJ-LhzXWMeMbCde3Asj-PiMPiXOMv8ArOQs432yGdg,144
+freelancer_payment_protection_cli-0.1.0.dist-info/licenses/LICENSE,sha256=eQNth9Qd5zQvzMfAcHNSHxZOEVMRIDM_sqj0MU89wyc,1400
+freelancer_payment_protection_cli-0.1.0.dist-info/RECORD,,

freelancer_payment_protection_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

freelancer_payment_protection_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+fpp = freelancer_payment_protection_cli.main:main
+freelancer-payment-protection = freelancer_payment_protection_cli.main:main

freelancer_payment_protection_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,35 @@
+Copyright (c) 2026 Rudrendu Paul and Sourav Nandy. All rights reserved.
+
+PROPRIETARY LICENSE
+
+This software and associated documentation files (the "Software") are the
+exclusive intellectual property of Rudrendu Paul and Sourav Nandy
+("the Owners").
+
+RESTRICTIONS
+
+1. No use, copying, modification, merging, publishing, distribution,
+   sublicensing, or selling of this Software — in whole or in part — is
+   permitted without prior written approval from both Owners.
+
+2. Any personal, academic, commercial, or scheduled use of this Software
+   requires explicit written permission obtained directly from:
+
+       Rudrendu Paul   — https://github.com/RudrenduPaul
+       Sourav Nandy    — (contact via Rudrendu Paul)
+
+3. Unauthorized use of this Software for any purpose, including but not
+   limited to building competing products, white-labeling, or redistribution,
+   is strictly prohibited and may result in legal action.
+
+TO REQUEST PERMISSION
+
+Submit a written request describing your intended use to the Owners. Approval
+is granted solely at the discretion of both Owners and may be subject to
+additional terms or a commercial licensing agreement.
+
+DISCLAIMER
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL THE OWNERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR
+OTHER LIABILITY ARISING FROM THE USE OF OR INABILITY TO USE THE SOFTWARE.