crowdtime-cli 0.1.0__py3-none-any.whl

crowdtime_cli/commands/clients_cmd.py

@@ -0,0 +1,150 @@
+"""Client commands: list, show, create, archive."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..client import APIError, CrowdTimeClient
+from ..formatters import format_error, format_success, print_json
+
+app = typer.Typer(name="clients", help="Manage clients.")
+console = Console()
+
+
+@app.command("list")
+def list_clients(
+    archived: bool = typer.Option(False, "--archived", "-a", help="Include archived clients."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """List all clients in the current organization."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    params: dict = {}
+    if archived:
+        params["is_archived"] = "true"
+
+    try:
+        data = client.get("/clients/", params=params)
+        clients_list = data if isinstance(data, list) else data.get("results", [])
+
+        if output_json:
+            print_json(clients_list)
+        else:
+            if not clients_list:
+                console.print("[dim]No clients found.[/dim]")
+                return
+
+            table = Table(show_header=True, header_style="bold")
+            table.add_column("ID", style="dim")
+            table.add_column("Name")
+            table.add_column("Contact")
+            table.add_column("Projects", justify="right")
+            table.add_column("Status")
+
+            for c in clients_list:
+                client_id = str(c.get("id", ""))
+                name = c.get("name", "")
+                contact = c.get("contact_name", "") or "-"
+                project_count = str(c.get("project_count", 0))
+                is_archived = c.get("is_archived", False)
+                status = "[red]Archived[/red]" if is_archived else "[green]Active[/green]"
+                table.add_row(client_id, name, contact, project_count, status)
+
+            console.print(table)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def show(
+    client_id: str = typer.Argument(..., help="Client ID."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Show details for a specific client."""
+    api_client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = api_client.get(f"/clients/{client_id}/")
+
+        if output_json:
+            print_json(data)
+        else:
+            console.print(f"\n[bold]{data.get('name')}[/bold]")
+            console.print(f"  ID:       {data.get('id')}")
+            console.print(f"  Currency: {data.get('currency', '-')}")
+            console.print(f"  Contact:  {data.get('contact_name', '-')}")
+            if data.get("contact_email"):
+                console.print(f"  Email:    {data['contact_email']}")
+            if data.get("contact_phone"):
+                console.print(f"  Phone:    {data['contact_phone']}")
+            if data.get("address"):
+                console.print(f"  Address:  {data['address']}")
+            status = "Archived" if data.get("is_archived") else "Active"
+            console.print(f"  Status:   {status}")
+            console.print()
+    except APIError as e:
+        if e.status_code == 404:
+            format_error(f"Client '{client_id}' not found.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def create(
+    name: str = typer.Argument(..., help="Client name."),
+    currency: Optional[str] = typer.Option(None, "--currency", help="Currency code (e.g. USD)."),
+    contact_name: Optional[str] = typer.Option(None, "--contact", help="Contact person name."),
+    contact_email: Optional[str] = typer.Option(None, "--email", help="Contact email."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Create a new client."""
+    api_client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    payload: dict = {"name": name}
+    if currency:
+        payload["currency"] = currency
+    if contact_name:
+        payload["contact_name"] = contact_name
+    if contact_email:
+        payload["contact_email"] = contact_email
+
+    try:
+        data = api_client.post("/clients/", data=payload)
+
+        if output_json:
+            print_json(data)
+        else:
+            format_success(f"Client '{data.get('name')}' created (ID: {data.get('id')})")
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def archive(
+    client_id: str = typer.Argument(..., help="Client ID to archive."),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation."),
+) -> None:
+    """Archive a client."""
+    if not force:
+        if not typer.confirm(f"Archive client '{client_id}'?"):
+            console.print("[dim]Cancelled.[/dim]")
+            return
+
+    api_client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        api_client.delete(f"/clients/{client_id}/")
+        format_success(f"Client '{client_id}' archived.")
+    except APIError as e:
+        if e.status_code == 404:
+            format_error(f"Client '{client_id}' not found.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)

crowdtime_cli/commands/config_cmd.py

@@ -0,0 +1,91 @@
+"""Config commands: set, get, list, edit."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+
+import typer
+from rich.console import Console
+
+from ..config import get_config
+from ..formatters import format_error, format_success, print_json
+
+app = typer.Typer(name="config", help="Manage CLI configuration.")
+console = Console()
+
+
+@app.command("set")
+def config_set(
+    key: str = typer.Argument(..., help="Config key (e.g. server.url, defaults.project)."),
+    value: str = typer.Argument(..., help="Value to set."),
+) -> None:
+    """Set a configuration value.
+
+    Examples:
+        ct config set server.url https://api.crowdtime.io
+        ct config set defaults.project myproject
+        ct config set defaults.daily_target 7h
+    """
+    config = get_config()
+    # Convert boolean strings
+    if value.lower() in ("true", "yes", "1"):
+        config.set(key, True)
+    elif value.lower() in ("false", "no", "0"):
+        config.set(key, False)
+    else:
+        config.set(key, value)
+    format_success(f"{key} = {value}")
+
+
+@app.command("get")
+def config_get(
+    key: str = typer.Argument(..., help="Config key to read."),
+) -> None:
+    """Get a configuration value."""
+    config = get_config()
+    value = config.get(key)
+    if value is None:
+        format_error(f"Key '{key}' not found.")
+        raise typer.Exit(1)
+    console.print(f"{key} = {value}")
+
+
+@app.command("list")
+def config_list(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Show all configuration values."""
+    config = get_config()
+    all_config = config.all()
+
+    if output_json:
+        print_json(dict(all_config))
+        return
+
+    console.print(f"\n[dim]Config file: {config.config_path}[/dim]\n")
+    for section, values in all_config.items():
+        console.print(f"[bold][{section}][/bold]")
+        if isinstance(values, dict):
+            for key, value in values.items():
+                console.print(f"  {key} = {value}")
+        else:
+            console.print(f"  {values}")
+    console.print()
+
+
+@app.command("edit")
+def config_edit() -> None:
+    """Open the config file in your default editor."""
+    config = get_config()
+    editor = os.environ.get("EDITOR", os.environ.get("VISUAL", "nano"))
+
+    try:
+        subprocess.run([editor, str(config.config_path)], check=True)
+        format_success(f"Config saved at {config.config_path}")
+    except FileNotFoundError:
+        format_error(f"Editor '{editor}' not found. Set $EDITOR to your preferred editor.")
+        raise typer.Exit(1)
+    except subprocess.CalledProcessError:
+        format_error("Editor exited with an error.")
+        raise typer.Exit(1)

crowdtime_cli/commands/favorites_cmd.py

@@ -0,0 +1,128 @@
+"""Favorites commands: list, create, delete, start."""
+
+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_favorites_table,
+    format_success,
+    format_timer,
+    print_json,
+)
+from ..models import FavoriteEntry, TimeEntry
+
+app = typer.Typer(name="favorites", help="Manage favorite time entry templates.")
+console = Console()
+
+
+@app.command("list")
+def list_favorites(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """List all saved favorites."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = client.get("/favorites/")
+        favs_list = data if isinstance(data, list) else data.get("results", [])
+        favorites = [FavoriteEntry(**item) for item in favs_list]
+
+        if output_json:
+            print_json(favorites)
+        else:
+            format_favorites_table(favorites)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def create(
+    description: str = typer.Argument("", help="Description for the favorite."),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Project name or ID."),
+    task: Optional[str] = typer.Option(None, "--task", "-t", help="Task name or ID."),
+    notes: Optional[str] = typer.Option(None, "--notes", "-n", help="Additional notes."),
+    billable: bool = typer.Option(True, "--billable/--no-billable", "-b/-B",
+                                  help="Mark as billable."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Create a new favorite entry template."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    payload: dict = {
+        "description": description,
+        "is_billable": billable,
+    }
+    if project:
+        payload["project"] = project
+    if task:
+        payload["task"] = task
+    if notes:
+        payload["notes"] = notes
+
+    try:
+        data = client.post("/favorites/", data=payload)
+        fav = FavoriteEntry(**data)
+
+        if output_json:
+            print_json(fav)
+        else:
+            format_success(f"Favorite created (ID: {fav.id})")
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def delete(
+    favorite_id: str = typer.Argument(..., help="Favorite ID to delete."),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation."),
+) -> None:
+    """Delete a favorite."""
+    if not force:
+        if not typer.confirm(f"Delete favorite {favorite_id}?"):
+            console.print("[dim]Cancelled.[/dim]")
+            return
+
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        client.delete(f"/favorites/{favorite_id}/")
+        format_success(f"Favorite {favorite_id} deleted.")
+    except APIError as e:
+        if e.status_code == 404:
+            format_error(f"Favorite {favorite_id} not found.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def start(
+    favorite_id: str = typer.Argument(..., help="Favorite ID to start timer from."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Start a timer from a favorite template."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = client.post(f"/favorites/{favorite_id}/start/")
+        entry = TimeEntry(**data)
+
+        if output_json:
+            print_json(entry)
+        else:
+            format_success("Timer started from favorite")
+            format_timer(entry)
+    except APIError as e:
+        if e.status_code == 404:
+            format_error(f"Favorite {favorite_id} not found.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)

crowdtime_cli/commands/log_cmd.py

@@ -0,0 +1,298 @@
+"""Log commands: create, edit, delete, list."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..client import APIError, CrowdTimeClient
+from ..formatters import (
+    format_entries_table,
+    format_entry_summary,
+    format_error,
+    format_success,
+    print_json,
+)
+from ..models import TimeEntry
+from ..resolvers import resolve_task
+from ..utils import format_date, parse_date, parse_duration
+
+app = typer.Typer(name="log", help="Log and manage time entries.")
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def log_default(
+    ctx: typer.Context,
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Log and manage time entries. Run without arguments to list today's entries."""
+    if ctx.invoked_subcommand is None:
+        _list_entries(date_str="today", output_json=output_json)
+
+
+@app.command()
+def create(
+    duration: str = typer.Argument(..., help="Duration (e.g. 2h, 2h30m, 2:30, 150m)."),
+    description: Optional[str] = typer.Argument(None, help="What did you work on?"),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Project slug or ID."),
+    task: Optional[str] = typer.Option(None, "--task", "-t", help="Task name or ID."),
+    date: Optional[str] = typer.Option(None, "--date", "-d", help="Date (default: today)."),
+    billable: Optional[bool] = typer.Option(None, "--billable/--no-billable", "-b/-B",
+                                            help="Mark as billable/non-billable."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Log a completed time entry.
+
+    Examples:
+        ct log create 2h "Code review"
+        ct log create -p myproject 2h30m "Feature work"
+        ct l -p myproject -d yesterday 1:30 "Standup"
+    """
+    try:
+        hours = parse_duration(duration)
+    except ValueError as e:
+        format_error(str(e))
+        raise typer.Exit(1)
+
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    payload: dict = {
+        "hours": str(hours),
+    }
+    if description:
+        payload["notes"] = description
+
+    project_id = project or client.config.default_project
+    if project_id:
+        payload["project"] = project_id
+    if task:
+        try:
+            payload["task"] = resolve_task(client, task, project_id=project_id)
+        except APIError as e:
+            format_error(f"Failed to resolve task '{task}': {e.message}")
+            raise typer.Exit(1)
+    if date:
+        try:
+            parsed = parse_date(date)
+            payload["date"] = format_date(parsed)
+        except ValueError as e:
+            format_error(str(e))
+            raise typer.Exit(1)
+    if billable is not None:
+        payload["is_billable"] = billable
+
+    try:
+        data = client.post("/time/", data=payload)
+        entry = TimeEntry(**data)
+
+        if output_json:
+            print_json(entry)
+        else:
+            format_success("Time entry logged")
+            format_entry_summary(entry)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def edit(
+    entry_id: str = typer.Argument(..., help="Time entry ID to edit."),
+    duration: Optional[str] = typer.Option(None, "--duration", help="New duration."),
+    description: Optional[str] = typer.Option(None, "--description", help="New description."),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="New project."),
+    task: Optional[str] = typer.Option(None, "--task", "-t", help="New task."),
+    date: Optional[str] = typer.Option(None, "--date", "-d", help="New date."),
+    billable: Optional[bool] = typer.Option(None, "--billable/--no-billable", "-b/-B",
+                                            help="Mark as billable/non-billable."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Edit an existing time entry."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    payload: dict = {}
+    if duration:
+        try:
+            payload["hours"] = str(parse_duration(duration))
+        except ValueError as e:
+            format_error(str(e))
+            raise typer.Exit(1)
+    if description is not None:
+        payload["notes"] = description
+    if project:
+        payload["project"] = project
+    if task:
+        try:
+            payload["task"] = resolve_task(client, task, project_id=project)
+        except APIError as e:
+            format_error(f"Failed to resolve task '{task}': {e.message}")
+            raise typer.Exit(1)
+    if date:
+        try:
+            payload["date"] = format_date(parse_date(date))
+        except ValueError as e:
+            format_error(str(e))
+            raise typer.Exit(1)
+    if billable is not None:
+        payload["is_billable"] = billable
+
+    if not payload:
+        format_error("No changes specified. Use --duration, --description, --project, etc.")
+        raise typer.Exit(1)
+
+    try:
+        data = client.patch(f"/time/{entry_id}/", data=payload)
+        entry = TimeEntry(**data)
+
+        if output_json:
+            print_json(entry)
+        else:
+            format_success(f"Entry {entry_id} updated")
+            format_entry_summary(entry)
+    except APIError as e:
+        if e.status_code == 404:
+            format_error(f"Entry {entry_id} not found.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def delete(
+    entry_id: str = typer.Argument(..., help="Time entry ID to delete."),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation."),
+) -> None:
+    """Delete a time entry."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    if not force:
+        # Fetch entry details for confirmation
+        try:
+            data = client.get(f"/time/{entry_id}/")
+            entry = TimeEntry(**data)
+            desc = entry.description or "(no description)"
+            if not typer.confirm(f"Delete entry '{desc}'?"):
+                console.print("[dim]Cancelled.[/dim]")
+                return
+        except APIError as e:
+            if e.status_code == 404:
+                format_error(f"Entry {entry_id} not found.")
+            else:
+                format_error(e.message)
+            raise typer.Exit(1)
+
+    try:
+        client.delete(f"/time/{entry_id}/")
+        format_success(f"Entry {entry_id} deleted.")
+    except APIError as e:
+        if e.status_code == 404:
+            format_error(f"Entry {entry_id} not found.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_entries(
+    date: Optional[str] = typer.Option(None, "--date", "-d", help="Filter by date."),
+    week: bool = typer.Option(False, "--week", "-w", help="Show this week's entries."),
+    month: bool = typer.Option(False, "--month", "-m", help="Show this month's entries."),
+    from_date: Optional[str] = typer.Option(None, "--from", help="Start date for range filter."),
+    to_date: Optional[str] = typer.Option(None, "--to", help="End date for range filter."),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Filter by project."),
+    format_output: str = typer.Option("table", "--format", help="Output format: table, json, csv."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """List time entries with optional filters."""
+    _list_entries(
+        date_str=date,
+        week=week,
+        month=month,
+        from_date=from_date,
+        to_date=to_date,
+        project=project,
+        format_output=format_output,
+        output_json=output_json,
+    )
+
+
+def _list_entries(
+    date_str: str | None = None,
+    week: bool = False,
+    month: bool = False,
+    from_date: str | None = None,
+    to_date: str | None = None,
+    project: str | None = None,
+    format_output: str = "table",
+    output_json: bool = False,
+) -> None:
+    """Internal function to list entries."""
+    from datetime import date as date_type, timedelta
+
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    params: dict = {}
+
+    if date_str:
+        try:
+            parsed = parse_date(date_str)
+            params["date"] = format_date(parsed)
+        except ValueError as e:
+            format_error(str(e))
+            raise typer.Exit(1)
+    elif week:
+        today = date_type.today()
+        start = today - timedelta(days=today.weekday())
+        params["from"] = format_date(start)
+        params["to"] = format_date(today)
+    elif month:
+        today = date_type.today()
+        start = today.replace(day=1)
+        params["from"] = format_date(start)
+        params["to"] = format_date(today)
+
+    if from_date:
+        try:
+            params["from"] = format_date(parse_date(from_date))
+        except ValueError as e:
+            format_error(str(e))
+            raise typer.Exit(1)
+    if to_date:
+        try:
+            params["to"] = format_date(parse_date(to_date))
+        except ValueError as e:
+            format_error(str(e))
+            raise typer.Exit(1)
+
+    if project:
+        params["project"] = project
+
+    try:
+        data = client.get("/time/", params=params)
+        entries = [TimeEntry(**item) for item in (data if isinstance(data, list) else data.get("results", []))]
+
+        if format_output == "json" or output_json:
+            print_json(entries)
+        elif format_output == "csv":
+            _print_csv(entries)
+        else:
+            format_entries_table(entries, show_date=True)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+def _print_csv(entries: list[TimeEntry]) -> None:
+    """Print entries as CSV."""
+    console.print("id,date,project,task,description,duration,billable")
+    for e in entries:
+        desc = (e.description or "").replace('"', '""')
+        console.print(
+            f'{e.id},{e.date or ""},'
+            f'{e.project_name or ""},{e.task_name or ""},'
+            f'"{desc}",{e.duration or 0},'
+            f'{"yes" if e.is_billable else "no"}'
+        )