crowdtime-cli 0.1.0__py3-none-any.whl

crowdtime_cli/main.py

@@ -0,0 +1,334 @@
+"""CrowdTime CLI - Main entry point.
+
+Registers all command groups, handles magic default routing,
+and provides short aliases for common commands.
+"""
+
+from __future__ import annotations
+
+import sys
+from datetime import date, timedelta
+from decimal import Decimal
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from . import __version__
+from .client import APIError, CrowdTimeClient
+from .formatters import format_error, format_status, format_timer, print_json
+from .models import TimeEntry, User
+
+from .commands import (
+    ai_cmd,
+    auth_cmd,
+    clients_cmd,
+    config_cmd,
+    favorites_cmd,
+    log_cmd,
+    org_cmd,
+    projects_cmd,
+    report_cmd,
+    skill_cmd,
+    tasks_cmd,
+    timer_cmd,
+)
+
+console = Console()
+
+app = typer.Typer(
+    name="crowdtime",
+    help="CrowdTime - AI-powered time tracking from the command line.",
+    rich_markup_mode="rich",
+    no_args_is_help=False,
+    invoke_without_command=True,
+)
+
+# Register command groups
+app.add_typer(auth_cmd.app, name="auth")
+app.add_typer(timer_cmd.app, name="timer")
+app.add_typer(log_cmd.app, name="log")
+app.add_typer(projects_cmd.app, name="projects")
+app.add_typer(clients_cmd.app, name="clients")
+app.add_typer(tasks_cmd.app, name="tasks")
+app.add_typer(report_cmd.app, name="report")
+app.add_typer(ai_cmd.app, name="ai")
+app.add_typer(org_cmd.app, name="org")
+app.add_typer(config_cmd.app, name="config")
+app.add_typer(favorites_cmd.app, name="favorites")
+app.add_typer(skill_cmd.app, name="skill")
+
+
+# ─── Status command (default when no subcommand given) ──────────────────────
+
+
+def _show_status(output_json: bool = False) -> None:
+    """Show the full status dashboard."""
+    try:
+        client = CrowdTimeClient(require_auth=True, require_org=True)
+    except SystemExit:
+        return
+
+    # Fetch user info
+    try:
+        user_data = client.get("/api/v1/auth/me/", org_scoped=False)
+        user = User(**user_data)
+        user_name = user.display_name
+    except (APIError, SystemExit):
+        user_name = "Unknown"
+
+    org_name = client.org_slug or "No org"
+
+    # Fetch running timer
+    running_entry: TimeEntry | None = None
+    try:
+        running_data = client.get("/time/running/")
+        running_entry = TimeEntry(**running_data)
+    except APIError:
+        pass
+
+    # Fetch today's entries
+    today = date.today()
+    today_entries: list[TimeEntry] = []
+    try:
+        today_data = client.get("/time/daily/{}/".format(today.isoformat()))
+        if isinstance(today_data, list):
+            today_list = today_data
+        elif isinstance(today_data, dict):
+            today_list = today_data.get("entries", today_data.get("results", []))
+        else:
+            today_list = []
+        today_entries = [TimeEntry(**item) for item in today_list]
+    except APIError:
+        pass
+
+    # Fetch this week's entries
+    week_entries: list[TimeEntry] | None = None
+    try:
+        monday = today - timedelta(days=today.weekday())
+        week_data = client.get("/time/weekly/{}/".format(monday.isoformat()))
+        if isinstance(week_data, list):
+            week_list = week_data
+        elif isinstance(week_data, dict):
+            week_list = week_data.get("entries", week_data.get("results", []))
+        else:
+            week_list = []
+        week_entries = [TimeEntry(**item) for item in week_list]
+    except APIError:
+        pass
+
+    if output_json:
+        print_json({
+            "user": user_name,
+            "organization": org_name,
+            "running_timer": running_entry.model_dump(mode="json") if running_entry else None,
+            "today_entries": [e.model_dump(mode="json") for e in today_entries],
+            "today_total": str(sum((e.duration or Decimal("0")) for e in today_entries if not e.is_running)),
+        })
+        return
+
+    format_status(
+        user_name=user_name,
+        org_name=org_name,
+        running_entry=running_entry,
+        today_entries=today_entries,
+        daily_target=client.config.daily_target,
+        week_entries=week_entries,
+    )
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-v", help="Show version."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """CrowdTime - AI-powered time tracking from the command line."""
+    if version:
+        console.print(f"crowdtime-cli {__version__}")
+        raise typer.Exit()
+
+    if ctx.invoked_subcommand is None:
+        _show_status(output_json=output_json)
+
+
+# ─── Short alias commands ───────────────────────────────────────────────────
+
+
+@app.command("status", hidden=False)
+def status_cmd(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Show current status dashboard."""
+    _show_status(output_json=output_json)
+
+
+@app.command("s", hidden=True)
+def status_alias(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Alias for 'status'."""
+    _show_status(output_json=output_json)
+
+
+@app.command("t", hidden=True)
+def timer_status_alias(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Alias for 'timer status'."""
+    timer_cmd.status(output_json=output_json)
+
+
+@app.command("ts", hidden=True)
+def timer_start_alias(
+    description: str = typer.Argument("", help="What are you working on?"),
+    project: Optional[str] = typer.Option(None, "--project", "-p"),
+    task: Optional[str] = typer.Option(None, "--task", "-t"),
+    billable: Optional[bool] = typer.Option(None, "--billable/--no-billable", "-b/-B"),
+    output_json: bool = typer.Option(False, "--json"),
+) -> None:
+    """Alias for 'timer start'."""
+    timer_cmd.start(
+        description=description, project=project, task=task,
+        billable=billable, output_json=output_json,
+    )
+
+
+@app.command("tx", hidden=True)
+def timer_stop_alias(
+    note: Optional[str] = typer.Option(None, "--note", "-n"),
+    output_json: bool = typer.Option(False, "--json"),
+) -> None:
+    """Alias for 'timer stop'."""
+    timer_cmd.stop(note=note, output_json=output_json)
+
+
+@app.command("l", hidden=True)
+def log_alias(
+    duration: str = typer.Argument(..., help="Duration (e.g. 2h, 2h30m, 2:30)."),
+    description: Optional[str] = typer.Argument(None),
+    project: Optional[str] = typer.Option(None, "--project", "-p"),
+    task: Optional[str] = typer.Option(None, "--task", "-t"),
+    date: Optional[str] = typer.Option(None, "--date", "-d"),
+    billable: Optional[bool] = typer.Option(None, "--billable/--no-billable", "-b/-B"),
+    output_json: bool = typer.Option(False, "--json"),
+) -> None:
+    """Alias for 'log create'."""
+    log_cmd.create(
+        duration=duration, description=description, project=project,
+        task=task, date=date, billable=billable, output_json=output_json,
+    )
+
+
+@app.command("ll", hidden=True)
+def log_list_alias(
+    date: Optional[str] = typer.Option(None, "--date", "-d"),
+    week: bool = typer.Option(False, "--week", "-w"),
+    month: bool = typer.Option(False, "--month", "-m"),
+    from_date: Optional[str] = typer.Option(None, "--from"),
+    to_date: Optional[str] = typer.Option(None, "--to"),
+    project: Optional[str] = typer.Option(None, "--project", "-p"),
+    format_output: str = typer.Option("table", "--format"),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Alias for 'log list'."""
+    log_cmd.list_entries(
+        date=date, week=week, month=month,
+        from_date=from_date, to_date=to_date, project=project,
+        format_output=format_output, output_json=output_json,
+    )
+
+
+@app.command("r", hidden=True)
+def report_alias(
+    ctx: typer.Context,
+    today_flag: bool = typer.Option(False, "--today"),
+    yesterday_flag: bool = typer.Option(False, "--yesterday"),
+    week: bool = typer.Option(False, "--week", "-w"),
+    last_week: bool = typer.Option(False, "--last-week"),
+    month: bool = typer.Option(False, "--month", "-m"),
+    from_date: Optional[str] = typer.Option(None, "--from"),
+    to_date: Optional[str] = typer.Option(None, "--to"),
+    project: Optional[str] = typer.Option(None, "--project", "-p"),
+    group_by: str = typer.Option("project", "--group-by", "-g"),
+    format_output: str = typer.Option("table", "--format", "-f"),
+) -> None:
+    """Alias for 'report'."""
+    report_cmd.report(
+        ctx=ctx,
+        today_flag=today_flag, yesterday_flag=yesterday_flag, week=week,
+        last_week=last_week, month=month, from_date=from_date, to_date=to_date,
+        project=project, group_by=group_by, format_output=format_output,
+    )
+
+
+@app.command("p", hidden=True)
+def projects_list_alias(
+    archived: bool = typer.Option(False, "--archived", "-a"),
+    output_json: bool = typer.Option(False, "--json"),
+) -> None:
+    """Alias for 'projects list'."""
+    projects_cmd.list_projects(archived=archived, output_json=output_json)
+
+
+# ─── Magic routing: unrecognized text -> ai parse ────────────────────────────
+
+
+def _is_known_command(arg: str) -> bool:
+    """Check if an argument is a known command or subcommand."""
+    known = {
+        "auth", "timer", "log", "projects", "clients", "tasks", "report", "ai",
+        "org", "config", "favorites", "skill", "status", "s", "t", "ts", "tx",
+        "l", "ll", "r", "p", "--help", "-h", "--version", "-v", "--json",
+    }
+    return arg in known
+
+
+_LOG_SUBCOMMANDS = {"list", "edit", "delete", "create", "--help", "-h", "--json"}
+
+
+def _fix_log_routing() -> None:
+    """Auto-insert 'create' for `ct log -p ... 2h "work"` style invocations.
+
+    When `ct log` is followed by args that aren't a known log subcommand,
+    the user intends `ct log create ...`. Insert 'create' so Typer routes
+    correctly without the callback needing positional args (which would
+    break subcommand routing).
+    """
+    if len(sys.argv) > 2 and sys.argv[1] == "log":
+        second = sys.argv[2]
+        if second not in _LOG_SUBCOMMANDS:
+            sys.argv = [sys.argv[0], "log", "create"] + sys.argv[2:]
+
+
+def _original_main() -> None:
+    """CLI entry point with magic routing and error handling.
+
+    If the first argument is not a known command, treat the entire
+    argument string as natural language and route to 'ai parse'.
+    """
+    if len(sys.argv) > 1:
+        first_arg = sys.argv[1]
+        # If it's not a known command and doesn't start with --, route to ai parse
+        if not first_arg.startswith("-") and not _is_known_command(first_arg):
+            text = " ".join(sys.argv[1:])
+            sys.argv = [sys.argv[0], "ai", "parse", text]
+
+    _fix_log_routing()
+
+    try:
+        app()
+    except APIError as e:
+        format_error(e.message)
+        raise SystemExit(1)
+    except SystemExit:
+        raise
+    except KeyboardInterrupt:
+        raise SystemExit(0)
+    except Exception as e:
+        format_error(f"Unexpected error: {e}")
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    _original_main()

crowdtime_cli/models.py

@@ -0,0 +1,146 @@
+"""Pydantic models for CrowdTime API responses."""
+
+from __future__ import annotations
+
+import datetime as dt
+from decimal import Decimal
+from typing import Any, Optional
+from pydantic import BaseModel, Field, model_validator
+
+
+class User(BaseModel):
+    id: str
+    email: str
+    first_name: str = ""
+    last_name: str = ""
+    timezone: str = "UTC"
+
+    @property
+    def display_name(self) -> str:
+        if self.first_name or self.last_name:
+            return f"{self.first_name} {self.last_name}".strip()
+        return self.email
+
+
+class Organization(BaseModel):
+    id: str
+    name: str
+    slug: str
+    role: str | None = None
+    member_count: int | None = None
+
+
+class Project(BaseModel):
+    id: str
+    name: str
+    code: str = ""
+    client: str | None = None
+    color: str = "#3B82F6"
+    status: str = "active"
+    is_billable: bool = True
+    budget_hours: Decimal | None = None
+    description: str = ""
+
+
+class Task(BaseModel):
+    id: str
+    name: str
+    project: str | None = None
+    project_name: str | None = None
+    is_billable: bool = True
+
+
+class TimeEntry(BaseModel):
+    model_config = {"extra": "ignore"}
+
+    id: str | None = None
+    description: str = ""
+    notes: str = ""
+    project: str | None = None
+    project_name: str | None = None
+    project_code: str | None = None
+    project_color: str | None = None
+    task: str | None = None
+    task_name: str | None = None
+    date: Optional[dt.date] = None
+    start_time: Optional[dt.datetime] = None
+    end_time: Optional[dt.datetime] = None
+    duration: Decimal | None = None
+    hours: Decimal | None = None
+    is_running: bool = False
+    is_billable: bool = True
+    user: str | None = None
+    user_name: str | None = None
+    source: str = ""
+    created_at: Optional[dt.datetime] = None
+    updated_at: Optional[dt.datetime] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_fields(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            # Map API field names to CLI field names
+            if "notes" in data and not data.get("description"):
+                data["description"] = data["notes"]
+            if "hours" in data and not data.get("duration"):
+                data["duration"] = data["hours"]
+        return data
+
+
+class FavoriteEntry(BaseModel):
+    id: str
+    project: str | None = None
+    project_name: str | None = None
+    task: str | None = None
+    task_name: str | None = None
+    description: str = ""
+    is_billable: bool = True
+    use_count: int = 0
+
+
+class ParseResult(BaseModel):
+    parsed_result: dict[str, Any] = Field(default_factory=dict)
+    confidence: float = 0.0
+    ambiguities: list[str] = Field(default_factory=list)
+    parse_log_id: str | None = None
+
+
+class Suggestion(BaseModel):
+    model_config = {"extra": "ignore"}
+
+    project_name: str = ""
+    task_name: str | None = ""
+    description: str = ""
+    estimated_hours: Decimal | None = None
+    reason: str = ""
+
+
+class WeeklySummary(BaseModel):
+    headline: str = ""
+    total_hours: Decimal = Decimal("0")
+    project_breakdown: list[dict[str, Any]] = Field(default_factory=list)
+    insights: list[str] = Field(default_factory=list)
+
+
+class ReportRow(BaseModel):
+    project: str = ""
+    task: str = ""
+    hours: Decimal = Decimal("0")
+    billable_hours: Decimal = Decimal("0")
+    entries_count: int = 0
+
+
+class Member(BaseModel):
+    id: str
+    user_email: str = ""
+    user_name: str = ""
+    role: str = "member"
+    is_active: bool = True
+
+
+class TokenResponse(BaseModel):
+    id: str | None = None
+    name: str = ""
+    key: str = ""
+    key_prefix: str = ""
+    scopes: list[str] = Field(default_factory=list)

crowdtime_cli/oauth.py

@@ -0,0 +1,107 @@
+"""Browser-based OAuth login flow for CrowdTime CLI.
+
+Opens the user's browser for Google OAuth authentication. The CLI polls
+the server for the auth code, then exchanges it for an API token (PKCE-protected).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import secrets
+import time
+import webbrowser
+
+import httpx
+
+
+def run_oauth_flow(server_url: str, timeout: int = 120) -> tuple[str, str] | None:
+    """Run the browser-based OAuth login flow with PKCE protection.
+
+    1. Opens browser for Google OAuth on the server
+    2. Polls the server until the auth code is available
+    3. Exchanges the code + PKCE verifier for an API token
+
+    Args:
+        server_url: The CrowdTime server URL (e.g. https://api.crowdtime.lat).
+        timeout: Max seconds to wait for the user to complete OAuth.
+
+    Returns:
+        Tuple of (api_token, org_slug) on success, or None on failure/timeout.
+    """
+    # Generate PKCE pair
+    code_verifier = secrets.token_hex(32)
+    code_challenge = hashlib.sha256(code_verifier.encode()).hexdigest()
+
+    # Generate state for CSRF protection
+    state = secrets.token_hex(32)
+
+    login_url = (
+        f'{server_url}/api/v1/auth/cli-login/'
+        f'?state={state}&code_challenge={code_challenge}'
+    )
+
+    if not webbrowser.open(login_url):
+        return None
+
+    # Poll the server for the auth code
+    poll_url = f'{server_url}/api/v1/auth/cli-poll/?state={state}'
+    deadline = time.monotonic() + timeout
+    poll_interval = 2  # seconds
+
+    while time.monotonic() < deadline:
+        time.sleep(poll_interval)
+        try:
+            response = httpx.get(poll_url, timeout=10.0)
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('status') == 'complete' and data.get('code'):
+                    return _exchange_code(
+                        server_url=server_url,
+                        code=data['code'],
+                        code_verifier=code_verifier,
+                    )
+        except (httpx.HTTPError, ValueError, KeyError):
+            pass  # Retry on transient errors
+
+    return None
+
+
+def _exchange_code(
+    server_url: str,
+    code: str,
+    code_verifier: str,
+) -> tuple[str, str] | None:
+    """Exchange a one-time auth code for an API token via server-to-server POST.
+
+    Args:
+        server_url: The CrowdTime server URL.
+        code: The one-time auth code from polling.
+        code_verifier: The PKCE verifier to prove we initiated the flow.
+
+    Returns:
+        Tuple of (api_token, org_slug) on success, or None on failure.
+    """
+    try:
+        response = httpx.post(
+            f'{server_url}/api/v1/auth/cli-exchange/',
+            json={
+                'code': code,
+                'code_verifier': code_verifier,
+            },
+            timeout=10.0,
+        )
+
+        if response.status_code != 200:
+            return None
+
+        data = response.json()
+        token = data.get('token')
+        org_slug = data.get('org_slug', '')
+
+        if not token:
+            return None
+
+        return token, org_slug
+
+    except (httpx.HTTPError, ValueError, KeyError):
+        return None

crowdtime_cli/resolvers.py

@@ -0,0 +1,80 @@
+"""Shared name-to-UUID resolution helpers for CLI commands."""
+
+from __future__ import annotations
+
+import re
+
+from rich.console import Console
+
+from .client import APIError, CrowdTimeClient
+
+console = Console(stderr=True)
+
+
+def resolve_task(client: CrowdTimeClient, task_ref: str, project_id: str | None = None) -> str:
+    """Resolve a task name or UUID to a UUID. Auto-assigns to project if needed.
+
+    Args:
+        client: Authenticated API client.
+        task_ref: Task name or UUID.
+        project_id: If provided, ensures the task is assigned to this project.
+
+    Returns:
+        The task UUID string.
+    """
+    # If it looks like a UUID already, use it directly
+    if _looks_like_uuid(task_ref):
+        task_id = task_ref
+    else:
+        # Search org tasks by name
+        data = client.get("/tasks/", params={"search": task_ref})
+        tasks_list = data if isinstance(data, list) else data.get("results", [])
+
+        # Exact match (case-insensitive)
+        task_id = None
+        for t in tasks_list:
+            if t.get("name", "").lower() == task_ref.lower():
+                task_id = t["id"]
+                break
+
+        if task_id is None:
+            # No match — create the task
+            console.print(f"[dim]Task '{task_ref}' not found — creating it...[/dim]")
+            new_task = client.post("/tasks/", data={"name": task_ref})
+            task_id = new_task["id"]
+
+    # If a project is specified, ensure the task is assigned to it
+    if project_id:
+        _ensure_task_assigned_to_project(client, task_id, project_id)
+
+    return task_id
+
+
+def _ensure_task_assigned_to_project(
+    client: CrowdTimeClient, task_id: str, project_id: str
+) -> None:
+    """Check if a task is assigned to a project; assign it if not."""
+    # List tasks currently assigned to the project
+    try:
+        data = client.get(f"/projects/{project_id}/tasks/")
+        assigned = data if isinstance(data, list) else data.get("results", [])
+
+        for pt in assigned:
+            # The response has 'task' (UUID) field
+            if pt.get("task") == task_id:
+                return  # Already assigned
+
+        # Not assigned — assign it
+        console.print(f"[dim]Assigning task to project...[/dim]")
+        client.post(f"/projects/{project_id}/tasks/", data={"task": task_id})
+    except APIError:
+        # If we can't check/assign, let the API validate later
+        pass
+
+
+def _looks_like_uuid(value: str) -> bool:
+    """Quick check if a string looks like a UUID."""
+    return bool(re.match(
+        r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$',
+        value.lower(),
+    ))