crowdtime-cli 0.1.0__py3-none-any.whl

crowdtime_cli/__init__.py

@@ -0,0 +1,3 @@
+"""CrowdTime CLI - AI-powered time tracking from the command line."""
+
+__version__ = "0.1.0"

crowdtime_cli/auth.py

@@ -0,0 +1,69 @@
+"""Authentication and token management for CrowdTime CLI.
+
+Stores API tokens in the system keyring, with file-based fallback.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .config import CONFIG_DIR
+
+SERVICE_NAME = "crowdtime"
+USERNAME = "api_token"
+CREDENTIALS_FILE = CONFIG_DIR / "credentials"
+
+
+def save_token(token: str) -> None:
+    """Store the API token, preferring keyring with file fallback."""
+    try:
+        import keyring
+
+        keyring.set_password(SERVICE_NAME, USERNAME, token)
+    except Exception:
+        _save_token_file(token)
+
+
+def get_token() -> str | None:
+    """Retrieve the stored API token."""
+    try:
+        import keyring
+
+        token = keyring.get_password(SERVICE_NAME, USERNAME)
+        if token:
+            return token
+    except Exception:
+        pass
+    return _get_token_file()
+
+
+def clear_token() -> None:
+    """Remove the stored API token."""
+    try:
+        import keyring
+
+        keyring.delete_password(SERVICE_NAME, USERNAME)
+    except Exception:
+        pass
+    _clear_token_file()
+
+
+def _save_token_file(token: str) -> None:
+    """File-based fallback for token storage."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CREDENTIALS_FILE.write_text(token)
+    CREDENTIALS_FILE.chmod(0o600)
+
+
+def _get_token_file() -> str | None:
+    """File-based fallback for token retrieval."""
+    if CREDENTIALS_FILE.exists():
+        content = CREDENTIALS_FILE.read_text().strip()
+        return content if content else None
+    return None
+
+
+def _clear_token_file() -> None:
+    """Remove file-based token."""
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()

crowdtime_cli/client.py

@@ -0,0 +1,177 @@
+"""HTTP client for the CrowdTime API.
+
+Wraps httpx with auth header injection, org-scoped URL prefixing,
+and friendly error handling.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from rich.console import Console
+
+from .auth import get_token
+from .config import get_config
+
+console = Console(stderr=True)
+
+
+class APIError(Exception):
+    """Raised when an API call fails."""
+
+    def __init__(self, message: str, status_code: int | None = None, detail: Any = None) -> None:
+        self.message = message
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(message)
+
+
+class CrowdTimeClient:
+    """Synchronous HTTP client for the CrowdTime API."""
+
+    def __init__(self, require_auth: bool = True, require_org: bool = False) -> None:
+        self.config = get_config()
+        self.base_url = self.config.server_url
+        self.token = get_token()
+        self.org_slug = self.config.organization
+
+        if require_auth and not self.token:
+            console.print(
+                "[red]Not authenticated.[/red] Please run [bold]ct login[/bold] first."
+            )
+            raise SystemExit(1)
+
+        if require_org and not self.org_slug:
+            console.print(
+                "[red]No organization set.[/red] Please run [bold]ct org switch <slug>[/bold] first."
+            )
+            raise SystemExit(1)
+
+        headers: dict[str, str] = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            headers=headers,
+            timeout=30.0,
+        )
+
+    def _org_prefix(self) -> str:
+        """Return the org-scoped URL prefix."""
+        return f"/api/v1/organizations/{self.org_slug}"
+
+    def _url(self, path: str, org_scoped: bool = True) -> str:
+        """Build the full URL path."""
+        if path.startswith("/api/"):
+            return path
+        if org_scoped and self.org_slug:
+            return f"{self._org_prefix()}/{path.lstrip('/')}"
+        return f"/api/v1/{path.lstrip('/')}"
+
+    def get(self, path: str, params: dict[str, Any] | None = None,
+            org_scoped: bool = True) -> Any:
+        """Make a GET request."""
+        url = self._url(path, org_scoped=org_scoped)
+        response = self._request("GET", url, params=params)
+        return response
+
+    def post(self, path: str, data: dict[str, Any] | None = None,
+             org_scoped: bool = True) -> Any:
+        """Make a POST request."""
+        url = self._url(path, org_scoped=org_scoped)
+        response = self._request("POST", url, json=data)
+        return response
+
+    def patch(self, path: str, data: dict[str, Any] | None = None,
+              org_scoped: bool = True) -> Any:
+        """Make a PATCH request."""
+        url = self._url(path, org_scoped=org_scoped)
+        response = self._request("PATCH", url, json=data)
+        return response
+
+    def delete(self, path: str, org_scoped: bool = True) -> Any:
+        """Make a DELETE request."""
+        url = self._url(path, org_scoped=org_scoped)
+        response = self._request("DELETE", url)
+        return response
+
+    def _request(self, method: str, url: str, **kwargs: Any) -> Any:
+        """Execute an HTTP request with error handling."""
+        try:
+            response = self._client.request(method, url, **kwargs)
+            return self._handle_response(response)
+        except httpx.ConnectError:
+            console.print(
+                f"[red]Cannot connect to server at {self.base_url}[/red]\n"
+                "Is the CrowdTime server running?"
+            )
+            raise SystemExit(1)
+        except httpx.TimeoutException:
+            console.print("[red]Request timed out.[/red] Please try again.")
+            raise SystemExit(1)
+        except APIError:
+            raise
+        except httpx.HTTPError as e:
+            console.print(f"[red]HTTP error:[/red] {e}")
+            raise SystemExit(1)
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        """Check response status and parse JSON."""
+        if response.status_code == 204:
+            return None
+
+        if response.status_code == 401:
+            console.print(
+                "[red]Authentication failed.[/red] Please run [bold]ct login[/bold] to re-authenticate."
+            )
+            raise SystemExit(1)
+
+        if response.status_code == 403:
+            console.print("[red]Permission denied.[/red] You don't have access to this resource.")
+            raise SystemExit(1)
+
+        if response.status_code == 404:
+            raise APIError("Not found", status_code=404)
+
+        if response.status_code >= 500:
+            # Server errors — show a friendly message, not raw HTML
+            try:
+                detail = response.json()
+                msg = detail.get("detail", "Internal server error")
+            except Exception:
+                msg = "Internal server error"
+            raise APIError(
+                f"Server error ({response.status_code}): {msg}",
+                status_code=response.status_code,
+            )
+
+        if response.status_code >= 400:
+            try:
+                detail = response.json()
+            except Exception:
+                detail = response.text
+            msg = detail.get("detail", str(detail)) if isinstance(detail, dict) else str(detail)
+            raise APIError(msg, status_code=response.status_code, detail=detail)
+
+        if not response.content:
+            return None
+
+        try:
+            return response.json()
+        except Exception:
+            return response.text
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self._client.close()
+
+    def __enter__(self) -> CrowdTimeClient:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

crowdtime_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CrowdTime CLI commands."""

crowdtime_cli/commands/ai_cmd.py

@@ -0,0 +1,211 @@
+"""AI commands: parse, suggest, summarize."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..client import APIError, CrowdTimeClient
+from ..formatters import (
+    format_error,
+    format_parse_result,
+    format_success,
+    format_suggestions,
+    print_json,
+)
+from ..models import ParseResult, Suggestion, TimeEntry, WeeklySummary
+from ..utils import format_date, parse_date
+
+app = typer.Typer(name="ai", help="AI-powered time tracking features.")
+console = Console()
+
+
+@app.command()
+def parse(
+    text: str = typer.Argument(..., help="Natural language time entry description."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be created without saving."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Parse natural language into a time entry.
+
+    Examples:
+        ct ai parse "2 hours on project alpha doing code review"
+        ct ai parse "spent yesterday afternoon on bug fixes for client X"
+        ct ai parse "30min standup" --yes
+    """
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = client.post("/ai/parse/", data={"text": text})
+        result = ParseResult(**data)
+
+        if output_json:
+            print_json(result)
+            return
+
+        format_parse_result(result)
+
+        if dry_run:
+            console.print("[dim]Dry run - not saving.[/dim]")
+            return
+
+        if not yes:
+            if not typer.confirm("Create this entry?"):
+                console.print("[dim]Cancelled.[/dim]")
+                return
+
+        # Confirm and create the entry
+        confirm_data = client.post("/ai/parse/confirm/", data={
+            "parse_log_id": result.parse_log_id,
+            "parsed_result": result.parsed_result,
+        })
+        entry = TimeEntry(**confirm_data)
+        format_success("Entry created from AI parse")
+        from ..formatters import format_entry_summary
+        format_entry_summary(entry)
+
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def suggest(
+    date: Optional[str] = typer.Option(None, "--date", "-d", help="Date for suggestions."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Get AI-powered entry suggestions based on your patterns.
+
+    Suggests what you might be working on based on your history.
+    """
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    params: dict = {}
+    if date:
+        try:
+            params["date"] = format_date(parse_date(date))
+        except ValueError as e:
+            format_error(str(e))
+            raise typer.Exit(1)
+
+    try:
+        data = client.get("/ai/suggestions/", params=params)
+        suggestions_list = data if isinstance(data, list) else data.get("results", [])
+        suggestions = [Suggestion(**item) for item in suggestions_list]
+
+        if output_json:
+            print_json(suggestions)
+            return
+
+        format_suggestions(suggestions)
+
+        if suggestions:
+            choice = typer.prompt(
+                "Start a timer with suggestion # (or Enter to skip)",
+                default="",
+                show_default=False,
+            )
+            if choice.strip().isdigit():
+                idx = int(choice.strip()) - 1
+                if 0 <= idx < len(suggestions):
+                    s = suggestions[idx]
+                    payload: dict = {"description": s.description}
+                    if s.project_name:
+                        payload["project"] = s.project_name
+                    if s.task_name:
+                        payload["task"] = s.task_name
+
+                    start_data = client.post("/time/start/", data=payload)
+                    entry = TimeEntry(**start_data)
+                    format_success("Timer started from suggestion")
+                    from ..formatters import format_timer
+                    format_timer(entry)
+                else:
+                    format_error("Invalid selection.")
+
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def summarize(
+    today_flag: bool = typer.Option(False, "--today", help="Summarize today."),
+    week: bool = typer.Option(True, "--week", "-w", help="Summarize this week (default)."),
+    month: bool = typer.Option(False, "--month", "-m", help="Summarize this month."),
+    for_format: str = typer.Option("report", "--for", help="Format for: standup, report, slack."),
+    copy: bool = typer.Option(False, "--copy", "-c", help="Copy to clipboard."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Generate an AI summary of your tracked time.
+
+    Examples:
+        ct ai summarize --week --for standup
+        ct ai summarize --today --for slack --copy
+    """
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    params: dict = {"format": for_format}
+    if today_flag:
+        params["period"] = "today"
+    elif month:
+        params["period"] = "month"
+    else:
+        params["period"] = "week"
+
+    try:
+        data = client.get("/ai/summary/weekly/", params=params)
+        summary = WeeklySummary(**data)
+
+        if output_json:
+            print_json(summary)
+            return
+
+        from ..utils import format_duration
+
+        console.print(f"\n[bold]{summary.headline}[/bold]")
+        console.print(f"Total: [yellow]{format_duration(summary.total_hours)}[/yellow]\n")
+
+        if summary.project_breakdown:
+            console.print("[bold]By Project:[/bold]")
+            for pb in summary.project_breakdown:
+                hours = format_duration(pb.get("hours", 0))
+                console.print(f"  [cyan]{pb.get('project', 'Unknown')}[/cyan]: {hours}")
+
+        if summary.insights:
+            console.print("\n[bold]Insights:[/bold]")
+            for insight in summary.insights:
+                console.print(f"  - {insight}")
+
+        console.print()
+
+        if copy:
+            try:
+                import subprocess
+                text_to_copy = f"{summary.headline}\n"
+                text_to_copy += f"Total: {format_duration(summary.total_hours)}\n"
+                for pb in summary.project_breakdown:
+                    text_to_copy += f"  {pb.get('project', '')}: {format_duration(pb.get('hours', 0))}\n"
+
+                process = subprocess.Popen(
+                    ["pbcopy"], stdin=subprocess.PIPE, text=True
+                )
+                process.communicate(text_to_copy)
+                format_success("Copied to clipboard")
+            except Exception:
+                try:
+                    process = subprocess.Popen(
+                        ["xclip", "-selection", "clipboard"],
+                        stdin=subprocess.PIPE, text=True
+                    )
+                    process.communicate(text_to_copy)
+                    format_success("Copied to clipboard")
+                except Exception:
+                    console.print("[dim]Could not copy to clipboard.[/dim]")
+
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)

crowdtime_cli/commands/auth_cmd.py

@@ -0,0 +1,160 @@
+"""Authentication commands: login, logout, whoami."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..auth import clear_token, get_token, save_token
+from ..client import CrowdTimeClient
+from ..config import get_config
+from ..formatters import format_error, format_success, print_json
+from ..models import User
+
+app = typer.Typer(name="auth", help="Authentication commands.")
+console = Console()
+
+
+@app.command()
+def login(
+    token: Optional[str] = typer.Option(
+        None, "--token", "-t",
+        help="API token for manual authentication (skips browser login).",
+    ),
+    no_browser: bool = typer.Option(
+        False, "--no-browser",
+        help="Don't open a browser. Prompt for token instead.",
+    ),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Authenticate with the CrowdTime server.
+
+    By default, opens your browser for Google OAuth login.
+    Use --token to provide an API token directly, or --no-browser to be prompted.
+    """
+    if token:
+        _login_with_token(token, output_json)
+    elif no_browser:
+        manual_token = typer.prompt("API Token", hide_input=True)
+        if not manual_token or not manual_token.strip():
+            format_error("Token cannot be empty.")
+            raise typer.Exit(1)
+        _login_with_token(manual_token.strip(), output_json)
+    else:
+        _login_with_browser(output_json)
+
+
+def _login_with_token(token: str, output_json: bool) -> None:
+    """Authenticate using a provided API token."""
+    token = token.strip()
+    if not token:
+        format_error("Token cannot be empty.")
+        raise typer.Exit(1)
+
+    save_token(token)
+    try:
+        client = CrowdTimeClient(require_auth=True, require_org=False)
+        data = client.get("/api/v1/auth/me/", org_scoped=False)
+        user = User(**data)
+
+        if output_json:
+            print_json(user)
+        else:
+            format_success(f"Logged in as {user.display_name} ({user.email})")
+    except SystemExit:
+        clear_token()
+        format_error("Invalid token. Could not authenticate.")
+        raise typer.Exit(1)
+
+
+def _login_with_browser(output_json: bool) -> None:
+    """Authenticate via browser-based Google OAuth."""
+    from ..oauth import run_oauth_flow
+
+    config = get_config()
+    server_url = config.server_url
+
+    console.print(f"\n[bold]Opening browser for Google login...[/bold]")
+    console.print(f"[dim]Server: {server_url}[/dim]")
+    console.print(f"[dim]Waiting for authentication (up to 2 minutes)...[/dim]\n")
+
+    result = run_oauth_flow(server_url)
+
+    if result is None:
+        console.print()
+        format_error(
+            "Browser login failed or timed out.\n"
+            "  Possible causes:\n"
+            "  - Browser didn't open (try copying the URL manually)\n"
+            "  - Google OAuth is not configured on the server\n"
+            "  - Login was cancelled or took too long\n\n"
+            "  You can also login with a token:\n"
+            "    ct auth login --token <your-api-token>\n"
+            "    ct auth login --no-browser"
+        )
+        raise typer.Exit(1)
+
+    api_token, org_slug = result
+
+    # Store the token
+    save_token(api_token)
+
+    # Auto-set the organization if returned
+    if org_slug:
+        config.set("defaults.organization", org_slug)
+
+    # Verify the token works
+    try:
+        client = CrowdTimeClient(require_auth=True, require_org=False)
+        data = client.get("/api/v1/auth/me/", org_scoped=False)
+        user = User(**data)
+
+        if output_json:
+            print_json(user)
+        else:
+            format_success(f"Logged in as {user.display_name} ({user.email})")
+            if org_slug:
+                console.print(f"  Organization set to [cyan]{org_slug}[/cyan]")
+            console.print()
+    except SystemExit:
+        clear_token()
+        format_error("Token verification failed after OAuth login.")
+        raise typer.Exit(1)
+
+
+@app.command()
+def logout() -> None:
+    """Log out and remove stored credentials."""
+    if not get_token():
+        console.print("[dim]Already logged out.[/dim]")
+        return
+
+    clear_token()
+    format_success("Logged out. Token removed.")
+
+
+@app.command()
+def whoami(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Show the currently authenticated user and organization."""
+    client = CrowdTimeClient(require_auth=True, require_org=False)
+    data = client.get("/api/v1/auth/me/", org_scoped=False)
+    user = User(**data)
+
+    if output_json:
+        print_json(user)
+        return
+
+    console.print(f"\n[bold]{user.display_name}[/bold]")
+    console.print(f"  Email:    {user.email}")
+    console.print(f"  Timezone: {user.timezone}")
+
+    org_slug = client.config.organization
+    if org_slug:
+        console.print(f"  Org:      [cyan]{org_slug}[/cyan]")
+    else:
+        console.print("  Org:      [dim]Not set (run ct org switch <slug>)[/dim]")
+    console.print()