crowdtime-cli 0.1.0__py3-none-any.whl

crowdtime_cli/commands/skill_cmd.py

@@ -0,0 +1,266 @@
+"""Skill commands: install agent skills for LLM coding tools."""
+
+from __future__ import annotations
+
+import shutil
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..formatters import format_error, format_success
+
+app = typer.Typer(name="skill", help="Manage CrowdTime agent skills for LLM coding tools.")
+console = Console()
+
+# Bundled skill files live next to this package
+SKILLS_SOURCE = Path(__file__).resolve().parent.parent / "skills" / "crowdtime"
+
+
+class Tool(str, Enum):
+    claude = "claude"
+    codex = "codex"
+    gemini = "gemini"
+    cursor = "cursor"
+
+
+# Maps tool name -> (global skills dir, project skills dir pattern)
+TOOL_PATHS: dict[str, tuple[Path, str]] = {
+    "claude": (
+        Path.home() / ".claude" / "skills",
+        ".claude/skills",
+    ),
+    "codex": (
+        Path.home() / ".codex" / "skills",
+        ".agents/skills",
+    ),
+    "gemini": (
+        Path.home() / ".gemini" / "skills",
+        ".gemini/skills",
+    ),
+    "cursor": (
+        # Cursor doesn't have a global skills dir; uses project-level only
+        Path.home() / ".cursor" / "skills",
+        ".cursor-plugin/skills",
+    ),
+}
+
+SKILL_NAME = "crowdtime"
+
+
+def _detect_installed_tools() -> list[str]:
+    """Detect which LLM coding tools are installed by checking config dirs."""
+    found = []
+    indicators = {
+        "claude": [Path.home() / ".claude"],
+        "codex": [Path.home() / ".codex"],
+        "gemini": [Path.home() / ".gemini"],
+        "cursor": [Path.home() / ".cursor"],
+    }
+    for tool, paths in indicators.items():
+        if any(p.exists() for p in paths):
+            found.append(tool)
+    return found
+
+
+def _get_project_dir() -> Path:
+    """Return the current working directory for project-level installs."""
+    return Path.cwd()
+
+
+def _install_skill(target_dir: Path) -> tuple[bool, str]:
+    """Copy bundled skill files to the target directory.
+
+    Returns (success, message).
+    """
+    if not SKILLS_SOURCE.exists():
+        return False, "Bundled skill files not found. Reinstall crowdtime-cli."
+
+    dest = target_dir / SKILL_NAME
+    already_exists = dest.exists()
+
+    # Copy skill tree
+    if dest.exists():
+        shutil.rmtree(dest)
+    shutil.copytree(SKILLS_SOURCE, dest)
+
+    verb = "Updated" if already_exists else "Installed"
+    return True, f"{verb} skill at {dest}"
+
+
+@app.command("install")
+def install(
+    tool: Optional[Tool] = typer.Option(
+        None, "--tool", "-t",
+        help="Target tool (claude, codex, gemini, cursor). Auto-detects if omitted.",
+    ),
+    global_install: bool = typer.Option(
+        False, "--global", "-g",
+        help="Install to user-wide skills directory (~/.claude/skills/, etc.).",
+    ),
+    all_tools: bool = typer.Option(
+        False, "--all", "-a",
+        help="Install for all detected tools.",
+    ),
+) -> None:
+    """Install the CrowdTime skill for your LLM coding tool.
+
+    By default installs to the current project. Use --global for user-wide install.
+
+    Examples:
+        ct skill install                    # auto-detect tool, project-level
+        ct skill install --global           # auto-detect tool, user-wide
+        ct skill install --tool claude      # explicit tool
+        ct skill install --all --global     # all detected tools, user-wide
+    """
+    if not SKILLS_SOURCE.exists():
+        format_error("Bundled skill files not found. Reinstall crowdtime-cli.")
+        raise typer.Exit(1)
+
+    # Determine which tools to install for
+    if tool:
+        tools = [tool.value]
+    elif all_tools:
+        tools = _detect_installed_tools()
+        if not tools:
+            format_error(
+                "No LLM coding tools detected. "
+                "Use --tool to specify one (claude, codex, gemini, cursor)."
+            )
+            raise typer.Exit(1)
+    else:
+        # Auto-detect: pick the first one found
+        tools = _detect_installed_tools()
+        if not tools:
+            format_error(
+                "No LLM coding tools detected.\n"
+                "  Looked for: ~/.claude, ~/.codex, ~/.gemini, ~/.cursor\n"
+                "  Use --tool to specify one explicitly."
+            )
+            raise typer.Exit(1)
+        # Default to first detected
+        tools = [tools[0]]
+
+    installed_count = 0
+
+    for t in tools:
+        global_dir, project_pattern = TOOL_PATHS[t]
+
+        if global_install:
+            target = global_dir
+        else:
+            target = _get_project_dir() / project_pattern
+
+        success, message = _install_skill(target)
+        if success:
+            console.print(f"[bold green]{t}:[/bold green] {message}")
+            installed_count += 1
+        else:
+            console.print(f"[bold red]{t}:[/bold red] {message}")
+
+    if installed_count == 0:
+        raise typer.Exit(1)
+
+    # Show usage hint
+    console.print()
+    if "claude" in tools:
+        console.print("[dim]Claude Code: skill auto-activates or use /crowdtime[/dim]")
+    if "codex" in tools:
+        console.print("[dim]Codex: skill auto-activates or use $crowdtime[/dim]")
+    if "gemini" in tools:
+        console.print("[dim]Gemini: skill auto-activates when time tracking is mentioned[/dim]")
+    if "cursor" in tools:
+        console.print("[dim]Cursor: skill auto-activates in agent mode[/dim]")
+
+
+@app.command("uninstall")
+def uninstall(
+    tool: Optional[Tool] = typer.Option(
+        None, "--tool", "-t",
+        help="Target tool. Auto-detects if omitted.",
+    ),
+    global_install: bool = typer.Option(
+        False, "--global", "-g",
+        help="Remove from user-wide skills directory.",
+    ),
+    all_tools: bool = typer.Option(
+        False, "--all", "-a",
+        help="Remove from all detected tools.",
+    ),
+) -> None:
+    """Remove the CrowdTime skill from your LLM coding tool."""
+    if tool:
+        tools = [tool.value]
+    elif all_tools:
+        tools = list(TOOL_PATHS.keys())
+    else:
+        tools = _detect_installed_tools() or list(TOOL_PATHS.keys())
+
+    removed = 0
+    for t in tools:
+        global_dir, project_pattern = TOOL_PATHS[t]
+
+        if global_install:
+            target = global_dir / SKILL_NAME
+        else:
+            target = _get_project_dir() / project_pattern / SKILL_NAME
+
+        if target.exists():
+            shutil.rmtree(target)
+            console.print(f"[bold green]{t}:[/bold green] Removed skill from {target}")
+            removed += 1
+
+    if removed == 0:
+        console.print("[dim]No installed skills found to remove.[/dim]")
+
+
+@app.command("status")
+def status() -> None:
+    """Show where the CrowdTime skill is installed."""
+    table = Table(title="CrowdTime Skill Status")
+    table.add_column("Tool", style="bold")
+    table.add_column("Scope")
+    table.add_column("Path")
+    table.add_column("Status")
+
+    project_dir = _get_project_dir()
+
+    for tool_name, (global_dir, project_pattern) in TOOL_PATHS.items():
+        # Check global
+        global_skill = global_dir / SKILL_NAME
+        if global_skill.exists():
+            table.add_row(
+                tool_name, "global", str(global_skill),
+                "[green]installed[/green]",
+            )
+        else:
+            table.add_row(
+                tool_name, "global", str(global_skill),
+                "[dim]not installed[/dim]",
+            )
+
+        # Check project
+        project_skill = project_dir / project_pattern / SKILL_NAME
+        if project_skill.exists():
+            table.add_row(
+                "", "project", str(project_skill),
+                "[green]installed[/green]",
+            )
+        else:
+            table.add_row(
+                "", "project", str(project_skill),
+                "[dim]not installed[/dim]",
+            )
+
+    console.print()
+    console.print(table)
+    console.print()
+
+    detected = _detect_installed_tools()
+    if detected:
+        console.print(f"[dim]Detected tools: {', '.join(detected)}[/dim]")
+    else:
+        console.print("[dim]No LLM coding tools detected on this machine.[/dim]")

crowdtime_cli/commands/tasks_cmd.py

@@ -0,0 +1,101 @@
+"""Task commands: list, create."""
+
+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
+from ..models import Task
+
+app = typer.Typer(name="tasks", help="Manage tasks.")
+console = Console()
+
+
+@app.command("list")
+def list_tasks(
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Filter by project."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """List available tasks."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    params: dict = {}
+    if project:
+        params["project"] = project
+
+    try:
+        data = client.get("/tasks/", params=params)
+        tasks_list = data if isinstance(data, list) else data.get("results", [])
+        tasks = [Task(**item) for item in tasks_list]
+
+        if output_json:
+            print_json(tasks)
+            return
+
+        if not tasks:
+            console.print("[dim]No tasks found.[/dim]")
+            return
+
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("ID", style="dim")
+        table.add_column("Name", width=25)
+        table.add_column("Project", style="cyan", width=15)
+        table.add_column("Billable", justify="center", width=8)
+
+        for t in tasks:
+            table.add_row(
+                str(t.id),
+                t.name,
+                t.project_name or "",
+                "[green]$[/green]" if t.is_billable else "",
+            )
+
+        console.print(table)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def create(
+    name: str = typer.Argument(..., help="Task name."),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Project to assign to."),
+    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 task. If --project is specified, also assigns it to that project."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    payload: dict = {"name": name, "is_billable": billable}
+
+    try:
+        data = client.post("/tasks/", data=payload)
+        task = Task(**data)
+
+        # If a project is specified, assign the task to it
+        if project:
+            try:
+                client.post(f"/projects/{project}/tasks/", data={"task": task.id})
+            except APIError as e:
+                # Task was created but assignment failed — warn, don't fail
+                console.print(
+                    f"[yellow]Warning:[/yellow] Task created but could not assign "
+                    f"to project '{project}': {e.message}"
+                )
+
+        if output_json:
+            print_json(task)
+        else:
+            msg = f"Task '{task.name}' created (ID: {task.id})"
+            if project:
+                msg += f" and assigned to project"
+            format_success(msg)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)

crowdtime_cli/commands/timer_cmd.py

@@ -0,0 +1,207 @@
+"""Timer commands: start, stop, status, switch, discard."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..client import APIError, CrowdTimeClient
+from ..formatters import format_entry_summary, format_error, format_success, format_timer, print_json
+from ..models import TimeEntry
+from ..resolvers import resolve_task
+
+app = typer.Typer(name="timer", help="Timer commands for tracking time.")
+console = Console()
+
+
+@app.command()
+def start(
+    description: str = typer.Argument("", help="What are you working on?"),
+    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."),
+    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:
+    """Start a new timer.
+
+    If a timer is already running, you'll be asked to stop it first.
+    Use 'ct timer switch' to stop and start in one step.
+    """
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    project_id = project or client.config.default_project
+    if not project_id:
+        format_error("Project is required. Use -p <project-id> or set a default with: ct projects switch <slug>")
+        raise typer.Exit(1)
+
+    payload: dict = {
+        "project_id": project_id,
+    }
+    if description:
+        payload["notes"] = description
+    if task:
+        try:
+            payload["task_id"] = 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 billable is not None:
+        payload["is_billable"] = billable
+
+    try:
+        data = client.post("/time/start/", data=payload)
+        entry = TimeEntry(**data)
+
+        if output_json:
+            print_json(entry)
+        else:
+            format_success("Timer started")
+            format_timer(entry)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def stop(
+    note: Optional[str] = typer.Option(None, "--note", "-n", help="Add a note to the entry."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Stop the currently running timer."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    payload: dict = {}
+    if note:
+        payload["note"] = note
+
+    try:
+        data = client.post("/time/stop/", data=payload if payload else None)
+        entry = TimeEntry(**data)
+
+        if output_json:
+            print_json(entry)
+        else:
+            format_success("Timer stopped")
+            format_entry_summary(entry)
+    except APIError as e:
+        if e.status_code == 404:
+            format_error("No timer is currently running.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def status(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Show the currently running timer."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = client.get("/time/running/")
+        entry = TimeEntry(**data)
+
+        if output_json:
+            print_json(entry)
+        else:
+            format_timer(entry)
+    except APIError as e:
+        if e.status_code == 404:
+            console.print("[dim]No timer is currently running.[/dim]")
+        else:
+            format_error(e.message)
+            raise typer.Exit(1)
+
+
+@app.command()
+def switch(
+    description: str = typer.Argument("", help="What are you switching to?"),
+    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."),
+    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:
+    """Stop the current timer and start a new one."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    # Stop current timer
+    try:
+        stop_data = client.post("/time/stop/")
+        stopped = TimeEntry(**stop_data)
+        if not output_json:
+            console.print(f"[dim]Stopped: {stopped.description or '(no description)'} "
+                          f"({stopped.project_name or ''})[/dim]")
+    except APIError as e:
+        if e.status_code != 404:
+            format_error(f"Could not stop current timer: {e.message}")
+            raise typer.Exit(1)
+
+    # Start new timer
+    project_id = project or client.config.default_project
+    if not project_id:
+        format_error("Project is required. Use -p <project-id> or set a default with: ct projects switch <slug>")
+        raise typer.Exit(1)
+
+    payload: dict = {
+        "project_id": project_id,
+    }
+    if description:
+        payload["notes"] = description
+    if task:
+        try:
+            payload["task_id"] = 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 billable is not None:
+        payload["is_billable"] = billable
+
+    try:
+        data = client.post("/time/start/", data=payload)
+        entry = TimeEntry(**data)
+
+        if output_json:
+            print_json(entry)
+        else:
+            format_success("Switched timer")
+            format_timer(entry)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def discard(
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation."),
+) -> None:
+    """Discard the running timer without saving."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    # Get the running entry
+    try:
+        data = client.get("/time/running/")
+        entry = TimeEntry(**data)
+    except APIError as e:
+        if e.status_code == 404:
+            console.print("[dim]No timer is currently running.[/dim]")
+            return
+        format_error(e.message)
+        raise typer.Exit(1)
+
+    if not force:
+        desc = entry.description or "(no description)"
+        if not typer.confirm(f"Discard timer '{desc}'?"):
+            console.print("[dim]Cancelled.[/dim]")
+            return
+
+    try:
+        client.delete(f"/time/{entry.id}/")
+        format_success("Timer discarded.")
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)

crowdtime_cli/config.py

@@ -0,0 +1,125 @@
+"""Configuration management for CrowdTime CLI.
+
+Config is stored at ~/.crowdtime/config.toml using platformdirs.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import tomlkit
+from platformdirs import user_config_dir
+
+CONFIG_DIR = Path(user_config_dir("crowdtime", ensure_exists=True))
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+DEFAULT_CONFIG = {
+    "server": {
+        "url": "https://api.crowdtime.lat",
+    },
+    "defaults": {
+        "organization": "",
+        "project": "",
+        "daily_target": "8h",
+        "weekly_target": "40h",
+        "date_format": "%Y-%m-%d",
+        "time_format": "24h",
+    },
+    "display": {
+        "theme": "auto",
+        "color": True,
+        "compact": False,
+    },
+}
+
+
+class CrowdTimeConfig:
+    """Manages CrowdTime CLI configuration."""
+
+    def __init__(self) -> None:
+        self._ensure_config_dir()
+        self._doc = self._load()
+
+    def _ensure_config_dir(self) -> None:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    def _load(self) -> tomlkit.TOMLDocument:
+        if CONFIG_FILE.exists():
+            return tomlkit.parse(CONFIG_FILE.read_text())
+        # Create default config
+        doc = tomlkit.document()
+        for section, values in DEFAULT_CONFIG.items():
+            table = tomlkit.table()
+            for key, value in values.items():
+                table.add(key, value)
+            doc.add(section, table)
+        CONFIG_FILE.write_text(tomlkit.dumps(doc))
+        return doc
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a config value using dot notation (e.g. 'server.url')."""
+        parts = key.split(".")
+        current: Any = self._doc
+        for part in parts:
+            if isinstance(current, dict) and part in current:
+                current = current[part]
+            else:
+                return default
+        return current
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a config value using dot notation."""
+        parts = key.split(".")
+        if len(parts) < 2:
+            raise ValueError("Config key must have at least section.key format (e.g. 'server.url')")
+
+        section = parts[0]
+        if section not in self._doc:
+            self._doc.add(section, tomlkit.table())
+
+        current: Any = self._doc[section]
+        for part in parts[1:-1]:
+            if part not in current:
+                current[part] = tomlkit.table()
+            current = current[part]
+
+        current[parts[-1]] = value
+        self.save()
+
+    def save(self) -> None:
+        """Write config to disk."""
+        CONFIG_FILE.write_text(tomlkit.dumps(self._doc))
+
+    def all(self) -> dict[str, Any]:
+        """Return the full config as a dict."""
+        return dict(self._doc)
+
+    @property
+    def server_url(self) -> str:
+        return str(self.get("server.url", "https://api.crowdtime.lat")).rstrip("/")
+
+    @property
+    def organization(self) -> str:
+        return str(self.get("defaults.organization", ""))
+
+    @property
+    def default_project(self) -> str:
+        return str(self.get("defaults.project", ""))
+
+    @property
+    def daily_target(self) -> str:
+        return str(self.get("defaults.daily_target", "8h"))
+
+    @property
+    def weekly_target(self) -> str:
+        return str(self.get("defaults.weekly_target", "40h"))
+
+    @property
+    def config_path(self) -> Path:
+        return CONFIG_FILE
+
+
+def get_config() -> CrowdTimeConfig:
+    """Get a CrowdTimeConfig instance."""
+    return CrowdTimeConfig()