clockify-export 0.2.0__tar.gz → 0.3.1__tar.gz

clockify_export-0.3.1/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "chat.tools.terminal.autoApprove": {
+        "uv": true
+    }
+}

{clockify_export-0.2.0 → clockify_export-0.3.1}/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.1]
+
+### Fixed
+- `--install-systemd` now uses the path of the running executable when writing the systemd service.
+
+## [0.2.0]
+
+### Added
+- CLI config help now documents supported config entries and example values (`--config-help`).
+- Workspace subset exports can be configured via `workspaces = [...]` in config or repeated `-w/--workspace` flags.
+- `clockify-export --install-systemd` and `mise install-systemd` installs the user-level systemd service and timer for daily exports.
+- `--status` now shows workspace names with IDs and marks stale state entries that are missing from the API.
+
+### Changed
+- Export state now stores each workspace name alongside the last exported timestamp so deleted or renamed workspaces remain identifiable.
+- Updated project plan status: workspace subset workflow, config help, and user systemd installation are complete and documented.
+
 ## [0.2.0]
 
 ### Added

{clockify_export-0.2.0 → clockify_export-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: clockify-export
-Version: 0.2.0
+Version: 0.3.1
 Summary: Export Clockify time entries to CSV with incremental support
 Project-URL: Homepage, https://github.com/ptandler/clockify-export
 Project-URL: Repository, https://github.com/ptandler/clockify-export
@@ -47,9 +47,19 @@ and writes one CSV per calendar month.
 
 ## Installation
 
-Requires [uv](https://docs.astral.sh/uv/) (or any Python 3.11+ + pip).
+Requires Python 3.11+ and either [mise](https://mise.jdx.dev/) or [uv](https://docs.astral.sh/uv/) for tool installation.
 
-### Global install (recommended, adds `clockify-export` to your PATH)
+### Install with mise
+
+If you already use `mise`, it supports pipx as backend and can use uv if installed.
+The simplest install path is:
+
+```bash
+mise use -g uv
+mise use -g pipx:clockify-export
+```
+
+### Install directly with uv
 
 ```bash
 uv tool install clockify-export      # from PyPI
@@ -67,33 +77,40 @@ uv sync
 
 ## Setup
 
-### 1. API key
+### 1. Create and edit the config file
 
 Generate an API key in Clockify: **Profile → Preferences → API → Manage API Keys → Generate**.
-
-Provide it via one of (highest priority first):
+Then create the config file and set your key and any defaults you want to use:
 
 ```bash
-# a) Config file (recommended)
 clockify-export --init-config
 # then edit ~/.config/clockify-export/config.toml:
 #
-#   # Clockify export configuration
 #   api_key = "YOUR_KEY"
 #   export_dir = "export"
+#   refetch = 1
+#   workspaces = ["Primary Workspace", "Client Projects"]
+```
+
+You can also print the supported keys anytime:
+
+```bash
+clockify-export --config-help
+```
+
+Alternatively, provide the key via one of the other supported sources (highest priority first):
 
-# b) Environment variable
+```bash
+# Environment variable
 export CLOCKIFY_API_KEY=YOUR_KEY
 
-# c) .env file in the project directory
+# .env file in the project directory
 echo "CLOCKIFY_API_KEY=YOUR_KEY" > .env
 
-# d) Command line flag
+# Command line flag
 clockify-export --api-key YOUR_KEY
 ```
 
-> Note: TOML is parsed with Python's stdlib `tomllib` — no extra dependency.
-
 ### 2. Export directory
 
 Defaults to `./export`. Override via config file or `-o` flag:
@@ -102,7 +119,72 @@ Defaults to `./export`. Override via config file or `-o` flag:
 clockify-export -o /data/clockify
 ```
 
-## Usage
+### 3. Check the setup and workspace status
+
+Before enabling the daily timer, confirm that the config and workspace discovery look correct:
+
+```bash
+clockify-export --status
+```
+
+This shows the known workspaces and any saved export state, which helps catch missing or renamed workspaces early.
+
+### 4. Install daily systemd timer
+
+If you installed via PyPI, you can install the user-level systemd service and timer without needing the repo checkout:
+
+```bash
+clockify-export --install-systemd
+```
+
+This copies the bundled service/timer into `~/.config/systemd/user/` and enables the timer.
+The installed service writes the currently resolved `clockify-export` executable path, so installs in a different directory still work correctly.
+
+See below for other options.
+
+## Command-line options
+
+```bash
+clockify-export --help
+```
+
+The CLI supports the following options:
+
+- `-o, --output-dir` — output directory for CSV files; defaults to `./export` or the config value
+- `--api-key` — override the Clockify API key for this run
+- `--full` — export everything from the beginning and ignore incremental state
+- `--from YYYY-MM[,YYYY-MM-DD]` — export from a specific month/day; always starts at the beginning of the month
+- `--last N` — export the last N complete months
+- `--refetch N` — re-fetch N months back from the last exported timestamp
+- `-w, --workspace NAME` — export only matching workspace names; repeat to select multiple workspaces
+- `--status` — show workspace information plus stored export state; includes missing workspaces by ID if the API no longer returns them
+- `--config-help` — print supported config keys and example values
+- `--init-config` — create a default config file in `~/.config/clockify-export/config.toml`
+- `--install-systemd` — install the user-level systemd service and timer for daily exports
+- `--no-cache` — skip cached projects/clients/tags and fetch fresh data
+- `--version` — print the installed version
+
+## Config file
+
+The config file is read from `~/.config/clockify-export/config.toml`.
+
+Supported keys:
+
+```toml
+api_key = "YOUR_KEY"
+export_dir = "export"
+refetch = 1
+workspaces = ["Primary Workspace", "Client Projects"]
+```
+
+Priority order is:
+
+1. CLI flags
+2. environment variables (`CLOCKIFY_API_KEY`, `CLOCKIFY_EXPORT_DIR`)
+3. config file
+4. defaults
+
+### Example usage
 
 ```bash
 # Full export of all workspaces (everything since the beginning)
@@ -111,13 +193,17 @@ clockify-export --full
 # Incremental export (default — only fetches entries after last run)
 clockify-export
 
-# Export only specific workspace(s)
-clockify-export -w "Peter's workspace"
+# Export only specific workspace(s) by name
+clockify-export -w "Primary Workspace"
+clockify-export -w "Primary Workspace" -w "Client Projects"
+
+# Or in config.toml:
+# workspaces = ["Primary Workspace", "Client Projects"]
 
 # Export since a specific date (ignores incremental state)
 clockify-export --from 2026-01-01
 
-# Show export state
+# Show workspace status and saved export state
 clockify-export --status
 ```
 
@@ -134,7 +220,7 @@ Each filename carries the workspace and year, so files stay identifiable even
 if you copy or move them out of the directory tree:
 
 ```
-export/etalytics workspace/2026/etalytics workspace_2026-09.csv
+export/Example Workspace/2026/Example Workspace_2026-09.csv
 ```
 
 ### CSV columns
@@ -246,3 +332,7 @@ systemctl --user disable --now clockify-export.timer
 
 > Note: The service uses `Type=oneshot` so it completes and exits each day.
 > Logs can be viewed with `journalctl --user -u clockify-export.service`.
+
+## Thanks
+
+This whole project was generated via opencode and I tried several free models. 🙏

{clockify_export-0.2.0 → clockify_export-0.3.1}/PLAN.md

@@ -19,6 +19,12 @@
 
 - [ ] Auto-refresh cache when unknown project/client/tag ID encountered during entry processing
 
+## Next
+
+- [x] show config help, i.e. supported config entries
+- [x] add command to install systemd unit & timer as user
+- [x] Workspace subset workflow: use workspace names in config and CLI, and `--status` now lists available workspaces alongside saved state, including missing workspaces by ID.
+
 ---
 
 ## 📋 Backlog

{clockify_export-0.2.0 → clockify_export-0.3.1}/README.md

@@ -21,9 +21,19 @@ and writes one CSV per calendar month.
 
 ## Installation
 
-Requires [uv](https://docs.astral.sh/uv/) (or any Python 3.11+ + pip).
+Requires Python 3.11+ and either [mise](https://mise.jdx.dev/) or [uv](https://docs.astral.sh/uv/) for tool installation.
 
-### Global install (recommended, adds `clockify-export` to your PATH)
+### Install with mise
+
+If you already use `mise`, it supports pipx as backend and can use uv if installed.
+The simplest install path is:
+
+```bash
+mise use -g uv
+mise use -g pipx:clockify-export
+```
+
+### Install directly with uv
 
 ```bash
 uv tool install clockify-export      # from PyPI
@@ -41,33 +51,40 @@ uv sync
 
 ## Setup
 
-### 1. API key
+### 1. Create and edit the config file
 
 Generate an API key in Clockify: **Profile → Preferences → API → Manage API Keys → Generate**.
-
-Provide it via one of (highest priority first):
+Then create the config file and set your key and any defaults you want to use:
 
 ```bash
-# a) Config file (recommended)
 clockify-export --init-config
 # then edit ~/.config/clockify-export/config.toml:
 #
-#   # Clockify export configuration
 #   api_key = "YOUR_KEY"
 #   export_dir = "export"
+#   refetch = 1
+#   workspaces = ["Primary Workspace", "Client Projects"]
+```
+
+You can also print the supported keys anytime:
+
+```bash
+clockify-export --config-help
+```
+
+Alternatively, provide the key via one of the other supported sources (highest priority first):
 
-# b) Environment variable
+```bash
+# Environment variable
 export CLOCKIFY_API_KEY=YOUR_KEY
 
-# c) .env file in the project directory
+# .env file in the project directory
 echo "CLOCKIFY_API_KEY=YOUR_KEY" > .env
 
-# d) Command line flag
+# Command line flag
 clockify-export --api-key YOUR_KEY
 ```
 
-> Note: TOML is parsed with Python's stdlib `tomllib` — no extra dependency.
-
 ### 2. Export directory
 
 Defaults to `./export`. Override via config file or `-o` flag:
@@ -76,7 +93,72 @@ Defaults to `./export`. Override via config file or `-o` flag:
 clockify-export -o /data/clockify
 ```
 
-## Usage
+### 3. Check the setup and workspace status
+
+Before enabling the daily timer, confirm that the config and workspace discovery look correct:
+
+```bash
+clockify-export --status
+```
+
+This shows the known workspaces and any saved export state, which helps catch missing or renamed workspaces early.
+
+### 4. Install daily systemd timer
+
+If you installed via PyPI, you can install the user-level systemd service and timer without needing the repo checkout:
+
+```bash
+clockify-export --install-systemd
+```
+
+This copies the bundled service/timer into `~/.config/systemd/user/` and enables the timer.
+The installed service writes the currently resolved `clockify-export` executable path, so installs in a different directory still work correctly.
+
+See below for other options.
+
+## Command-line options
+
+```bash
+clockify-export --help
+```
+
+The CLI supports the following options:
+
+- `-o, --output-dir` — output directory for CSV files; defaults to `./export` or the config value
+- `--api-key` — override the Clockify API key for this run
+- `--full` — export everything from the beginning and ignore incremental state
+- `--from YYYY-MM[,YYYY-MM-DD]` — export from a specific month/day; always starts at the beginning of the month
+- `--last N` — export the last N complete months
+- `--refetch N` — re-fetch N months back from the last exported timestamp
+- `-w, --workspace NAME` — export only matching workspace names; repeat to select multiple workspaces
+- `--status` — show workspace information plus stored export state; includes missing workspaces by ID if the API no longer returns them
+- `--config-help` — print supported config keys and example values
+- `--init-config` — create a default config file in `~/.config/clockify-export/config.toml`
+- `--install-systemd` — install the user-level systemd service and timer for daily exports
+- `--no-cache` — skip cached projects/clients/tags and fetch fresh data
+- `--version` — print the installed version
+
+## Config file
+
+The config file is read from `~/.config/clockify-export/config.toml`.
+
+Supported keys:
+
+```toml
+api_key = "YOUR_KEY"
+export_dir = "export"
+refetch = 1
+workspaces = ["Primary Workspace", "Client Projects"]
+```
+
+Priority order is:
+
+1. CLI flags
+2. environment variables (`CLOCKIFY_API_KEY`, `CLOCKIFY_EXPORT_DIR`)
+3. config file
+4. defaults
+
+### Example usage
 
 ```bash
 # Full export of all workspaces (everything since the beginning)
@@ -85,13 +167,17 @@ clockify-export --full
 # Incremental export (default — only fetches entries after last run)
 clockify-export
 
-# Export only specific workspace(s)
-clockify-export -w "Peter's workspace"
+# Export only specific workspace(s) by name
+clockify-export -w "Primary Workspace"
+clockify-export -w "Primary Workspace" -w "Client Projects"
+
+# Or in config.toml:
+# workspaces = ["Primary Workspace", "Client Projects"]
 
 # Export since a specific date (ignores incremental state)
 clockify-export --from 2026-01-01
 
-# Show export state
+# Show workspace status and saved export state
 clockify-export --status
 ```
 
@@ -108,7 +194,7 @@ Each filename carries the workspace and year, so files stay identifiable even
 if you copy or move them out of the directory tree:
 
 ```
-export/etalytics workspace/2026/etalytics workspace_2026-09.csv
+export/Example Workspace/2026/Example Workspace_2026-09.csv
 ```
 
 ### CSV columns
@@ -220,3 +306,7 @@ systemctl --user disable --now clockify-export.timer
 
 > Note: The service uses `Type=oneshot` so it completes and exits each day.
 > Logs can be viewed with `journalctl --user -u clockify-export.service`.
+
+## Thanks
+
+This whole project was generated via opencode and I tried several free models. 🙏

{clockify_export-0.2.0 → clockify_export-0.3.1}/mise.toml

@@ -12,4 +12,4 @@ export-full = "uv run clockify-export --full --output-dir ./export"
 status = "uv run clockify-export --status"
 init-config = "uv run clockify-export --init-config"
 test = "uv run python -c \"from clockify_export.api import ClockifyAPI; print('import ok')\""
-install-systemd = "cp systemd/clockify-export.service \"$HOME/.config/systemd/user/\" && cp systemd/clockify-export.timer \"$HOME/.config/systemd/user/\" && systemctl --user daemon-reload && systemctl --user enable --now clockify-export.timer"
+install-systemd = "cp systemd/clockify-export/clockify-export.service \"$HOME/.config/systemd/user/\" && cp systemd/clockify-export.timer \"$HOME/.config/systemd/user/\" && systemctl --user daemon-reload && systemctl --user enable --now clockify-export.timer"

{clockify_export-0.2.0 → clockify_export-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "clockify-export"
-version = "0.2.0"
+version = "0.3.1"
 description = "Export Clockify time entries to CSV with incremental support"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -40,6 +40,10 @@ build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/clockify_export"]
+include = [
+    "src/clockify_export/systemd/*.service",
+    "src/clockify_export/systemd/*.timer",
+]
 
 [tool.uv]
 package = true

{clockify_export-0.2.0 → clockify_export-0.3.1}/src/clockify_export/cli.py

@@ -9,6 +9,7 @@ from datetime import datetime, timedelta, timezone
 from .api import ClockifyAPI, ClockifyError
 from .config import CONFIG_FILE, Config, CONFIG_HELP, create_config_file, get_last_exported, set_last_exported, parse_from_date, calculate_last_months, calculate_refetch_date
 from .export import export_workspace
+from .systemd_install import install_systemd_user_units
 from . import __version__
 
 
@@ -74,11 +75,21 @@ def main() -> None:
         action="store_true",
         help="Show export state and exit",
     )
+    parser.add_argument(
+        "--config-help",
+        action="store_true",
+        help="Print supported configuration entries and exit",
+    )
     parser.add_argument(
         "--init-config",
         action="store_true",
         help="Create ~/.config/clockify-export/config.toml and exit",
     )
+    parser.add_argument(
+        "--install-systemd",
+        action="store_true",
+        help="Install the user-level systemd service and timer for daily exports",
+    )
     parser.add_argument(
         "--no-cache",
         action="store_true",
@@ -86,12 +97,20 @@ def main() -> None:
     )
     args = parser.parse_args()
 
+    if args.config_help:
+        print(CONFIG_HELP)
+        raise SystemExit(0)
+
     if args.init_config:
         path = create_config_file()
         print(f"Created config file: {path}")
         print("Edit it to set your API key and export directory.")
         return
 
+    if args.install_systemd:
+        install_systemd_user_units()
+        return
+
     # Load configuration
     cfg = Config.load(args)
 
@@ -112,17 +131,41 @@ def main() -> None:
 
     # Status mode
     if args.status:
-        import json
         from .config import get_state
         state = get_state()
         print(f"Export directory: {cfg.export_dir}")
         print(f"Config file: {CONFIG_FILE}")
-        if not state:
-            print("No export state found.")
+        try:
+            workspaces = api.get_workspaces()
+        except ClockifyError as e:
+            print(f"Error fetching workspaces: {e}", file=sys.stderr)
+            workspaces = []
+
+        available_by_id = {str(ws.get("id")): ws for ws in workspaces if ws.get("id")}
+        workspace_ids = sorted(set(available_by_id) | set(state), key=lambda ws_id: (
+            (available_by_id.get(ws_id, {}).get("name") or state.get(ws_id, {}).get("name") or "").lower(),
+            ws_id,
+        ))
+
+        print("Workspace status:")
+        if not workspace_ids:
+            print("  No workspaces found.")
             return
-        print("Export state:")
-        for ws_id, info in state.items():
-            print(f"  {ws_id}: last_exported={info.get('last_exported', 'never')}")
+
+        for ws_id in workspace_ids:
+            info = state.get(ws_id, {})
+            api_ws = available_by_id.get(ws_id, {})
+            name = api_ws.get("name") or info.get("name") or "(unknown workspace)"
+            if ws_id in available_by_id:
+                status = ""
+            else:
+                status = " - missing from API"
+            last_exported = info.get("last_exported")
+            if last_exported:
+                detail = f" - last_exported={last_exported}"
+            else:
+                detail = " - no export state"
+            print(f"  {name} ({ws_id}){status}{detail}")
         return
 
     # Discover workspaces
@@ -193,7 +236,7 @@ def main() -> None:
             if counts:
                 # Update state to the actual latest entry date (not end of month)
                 if latest_entry_dt:
-                    set_last_exported(ws_id, latest_entry_dt.isoformat())
+                    set_last_exported(ws_id, latest_entry_dt.isoformat(), ws_name)
                 total = sum(counts.values())
                 print(f"  Total: {total} entries across {len(counts)} month(s)")
             else:

{clockify_export-0.2.0 → clockify_export-0.3.1}/src/clockify_export/config.py

@@ -26,6 +26,7 @@ DEFAULTS = {
     "api_key": None,
     "export_dir": "export",
     "refetch": 1,
+    "workspaces": [],
 }
 
 CONFIG_HELP = """
@@ -33,12 +34,14 @@ Supported configuration options (config.toml):
   api_key       - Clockify API key (required)
   export_dir    - Output directory for CSV files (default: "export")
   refetch       - Number of months to re-fetch from last exported date (default: 1)
+  workspaces    - Optional list of workspace names to export (e.g. ["Workspace One", "Workspace Two"])
 
 Example config.toml:
   # Clockify export configuration
   api_key = "YOUR_API_KEY"
   export_dir = "export"
   refetch = 1
+  workspaces = ["Workspace One", "Workspace Two"]
 """
 
 
@@ -74,9 +77,20 @@ class Config:
         )
 
         full = getattr(args, "full", False) if args else False
-        workspaces = getattr(args, "workspace", []) if args else []
+        cli_workspaces = getattr(args, "workspace", None) if args else None
+        if cli_workspaces is None:
+            cli_workspaces = []
+        if isinstance(cli_workspaces, str):
+            workspaces = [cli_workspaces]
+        else:
+            workspaces = list(cli_workspaces)
+        if not workspaces:
+            file_workspaces = file_cfg.get("workspaces", DEFAULTS["workspaces"])
+            if isinstance(file_workspaces, str):
+                file_workspaces = [file_workspaces]
+            workspaces = list(file_workspaces)
         from_date = getattr(args, "from_date", None) if args else None
-        
+
         # For refetch: CLI arg wins, then config file, then default
         if args and getattr(args, "refetch", None) is not None:
             refetch = args.refetch
@@ -135,6 +149,8 @@ def create_config_file(api_key: str = "", export_dir: str = "export") -> Path:
         f'export_dir = "{export_dir}"\n'
         "# Number of months to re-fetch from last exported date (default: 1)\n"
         "refetch = 1\n"
+        "# Optional: export only specific workspace names\n"
+        "# workspaces = [\"Workspace One\", \"Workspace Two\"]\n"
     )
     return CONFIG_FILE
 
@@ -194,9 +210,16 @@ def get_last_exported(workspace_id: str) -> str | None:
     return state.get(workspace_id, {}).get("last_exported")
 
 
-def set_last_exported(workspace_id: str, timestamp: str) -> None:
+def set_last_exported(workspace_id: str, timestamp: str, workspace_name: str | None = None) -> None:
     state = get_state()
     ws = state.setdefault(workspace_id, {})
     ws["last_exported"] = timestamp
+    if workspace_name is not None:
+        ws["name"] = workspace_name
     ws["updated_at"] = datetime.now(timezone.utc).isoformat()
-    save_state(state)
+    save_state(state)
+
+
+def get_workspace_name(workspace_id: str) -> str | None:
+    state = get_state()
+    return state.get(workspace_id, {}).get("name")

clockify_export-0.3.1/src/clockify_export/systemd/clockify-export.timer

@@ -0,0 +1,10 @@
+[Unit]
+Description=Run Clockify Export daily
+
+[Timer]
+OnBootSec=15min
+OnUnitActiveSec=24h
+Persistent=true
+
+[Install]
+WantedBy=timers.target

clockify_export-0.3.1/src/clockify_export/systemd_install.py

@@ -0,0 +1,55 @@
+"""Helpers for installing the daily systemd timer for clockify-export."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _resolve_clockify_export_binary() -> str:
+    """Return the executable path for the installed clockify-export command."""
+    executable = shutil.which("clockify-export")
+    if executable:
+        return executable
+
+    # If the tool was installed in a managed environment without a PATH entry
+    # available to systemd, try common pipx locations as a fallback.
+    for candidate in (
+        Path.home() / ".local" / "bin" / "clockify-export",
+        Path.home() / ".local" / "share" / "mise" / "installs" / "pipx-clockify-export" / "latest" / "bin" / "clockify-export",
+        Path.home() / ".local" / "share" / "pipx" / "venvs" / "clockify-export" / "bin" / "clockify-export",
+        Path.home() / ".local" / "share" / "uv" / "tools" / "clockify-export" / "bin" / "clockify-export",
+    ):
+        if candidate.exists():
+            return str(candidate)
+
+    return "clockify-export"
+
+
+def install_systemd_user_units() -> None:
+    """Install the user systemd timer and service for daily exports."""
+    target_dir = Path.home() / ".config" / "systemd" / "user"
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    bundled_dir = Path(__file__).resolve().parent / "systemd"
+    service_source = (bundled_dir / "clockify-export.service").read_text(encoding="utf-8")
+    service_source = service_source.replace("ExecStart=%h/.local/bin/clockify-export", f"ExecStart={_resolve_clockify_export_binary()}")
+    (target_dir / "clockify-export.service").write_text(service_source, encoding="utf-8")
+    (target_dir / "clockify-export.timer").write_text(
+        (bundled_dir / "clockify-export.timer").read_text(encoding="utf-8"),
+        encoding="utf-8",
+    )
+
+    for command in (
+        ["systemctl", "--user", "daemon-reload"],
+        ["systemctl", "--user", "enable", "--now", "clockify-export.timer"],
+    ):
+        try:
+            subprocess.run(command, check=True, capture_output=True, text=True)
+        except (FileNotFoundError, subprocess.CalledProcessError) as exc:
+            print(f"Warning: unable to run {' '.join(command)}: {exc}", file=sys.stderr)
+
+    print(f"Installed systemd user units in {target_dir}")
+    print("Use: systemctl --user status clockify-export.timer")

clockify_export-0.3.1/systemd/clockify-export.service

@@ -0,0 +1,8 @@
+[Unit]
+Description=Clockify Export - Daily export of time entries to CSV
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=%h/.local/bin/clockify-export
+WorkingDirectory=%h

{clockify_export-0.2.0 → clockify_export-0.3.1}/tests/test_cli.py

@@ -64,6 +64,38 @@ class TestCLI:
                     assert "api_key" in content
                     assert "export_dir" in content
 
+    def test_config_help_flag(self, capsys):
+        with pytest.raises(SystemExit) as exc:
+            run_main(["--config-help"])
+        assert exc.value.code == 0
+        captured = capsys.readouterr()
+        assert "api_key" in captured.out
+        assert "refetch" in captured.out
+
+    def test_install_systemd_flag(self, tmp_path):
+        with isolated_env(tmp_path):
+            expected_dir = tmp_path / ".config" / "systemd" / "user"
+            with patch("clockify_export.systemd_install.subprocess.run") as mock_run:
+                run_main(["--install-systemd"])
+                assert mock_run.call_count >= 2
+                assert any(call.args[0][:3] == ["systemctl", "--user", "daemon-reload"] for call in mock_run.call_args_list)
+                installed_files = list(expected_dir.glob("*"))
+                assert any(f.name == "clockify-export.service" for f in installed_files)
+                assert any(f.name == "clockify-export.timer" for f in installed_files)
+
+    def test_install_systemd_uses_resolved_cli_path(self, tmp_path):
+        with isolated_env(tmp_path):
+            expected_dir = tmp_path / ".config" / "systemd" / "user"
+            resolved = tmp_path / "custom-bin" / "clockify-export"
+            resolved.parent.mkdir(parents=True)
+            with patch("clockify_export.systemd_install.shutil.which", return_value=str(resolved)):
+                with patch("clockify_export.systemd_install.subprocess.run"):
+                    run_main(["--install-systemd"])
+
+            service_file = expected_dir / "clockify-export.service"
+            content = service_file.read_text(encoding="utf-8")
+            assert f"ExecStart={resolved}" in content
+
     def test_missing_api_key_exits(self, capsys, tmp_path):
         with isolated_env(tmp_path) as config_dir:
             with patch("clockify_export.config.CONFIG_DIR", config_dir):
@@ -92,20 +124,25 @@ class TestCLI:
     def test_status_flag_shows_state(self, capsys, tmp_path, sample_state):
         with isolated_env(tmp_path) as config_dir:
             (config_dir / "config.toml").write_text('api_key = "test_key"\nexport_dir = "export"\n')
-            (config_dir / "state.json").write_text('{"ws123": {"last_exported": "2026-01-15T17:00:00+00:00"}}')
+            (config_dir / "state.json").write_text('{"ws123": {"last_exported": "2026-01-15T17:00:00+00:00", "name": "Old Workspace"}}')
             with patch("clockify_export.config.CONFIG_DIR", config_dir):
                 with patch("clockify_export.config.CONFIG_FILE", config_dir / "config.toml"):
                     with patch("clockify_export.config.STATE_FILE", config_dir / "state.json"):
                         with patch("clockify_export.cli.ClockifyAPI") as mock_api_class:
                             mock_api = MagicMock()
-                            mock_api.get_workspaces.return_value = [{"id": "ws1", "name": "WS"}]
+                            mock_api.get_workspaces.return_value = [{"id": "ws1", "name": "WS"}, {"id": "ws2", "name": "Other Workspace"}]
                             mock_api_class.return_value = mock_api
 
                             run_main(["--status"])
                             captured = capsys.readouterr()
                             assert "Export directory:" in captured.out
-                            assert "Export state:" in captured.out
-                            assert "ws123" in captured.out
+                            assert "Workspace status:" in captured.out
+                            assert "WS (ws1)" in captured.out
+                            assert "Other Workspace (ws2)" in captured.out
+                            assert "Old Workspace (ws123)" in captured.out
+                            assert "available" not in captured.out.lower()
+                            assert "missing from API" in captured.out
+                            assert "last_exported" in captured.out
 
     def test_workspace_filtering(self, tmp_path):
         with isolated_env(tmp_path) as config_dir:

{clockify_export-0.2.0 → clockify_export-0.3.1}/tests/test_config.py

@@ -11,7 +11,9 @@ from clockify_export.config import (
     Config,
     calculate_last_months,
     calculate_refetch_date,
+    get_state,
     parse_from_date,
+    set_last_exported,
 )
 
 
@@ -172,6 +174,15 @@ class TestConfigLoad:
         cfg = Config.load(args)
         assert cfg.workspaces == ["WS1", "WS2"]
 
+    def test_config_file_workspaces(self, monkeypatch, temp_config_dir):
+        import clockify_export.config as config_module
+        config_module.CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        config_module.CONFIG_FILE.write_text('api_key = "file_key"\nworkspaces = ["WS1", "WS2"]\n')
+        monkeypatch.delenv("CLOCKIFY_API_KEY", raising=False)
+        args = type("Args", (), {"api_key": None, "output_dir": None, "full": False, "workspace": None, "from_date": None, "refetch": None})()
+        cfg = Config.load(args)
+        assert cfg.workspaces == ["WS1", "WS2"]
+
     def test_cli_full(self, monkeypatch, temp_config_dir):
         monkeypatch.setenv("CLOCKIFY_API_KEY", "test_key")
         args = type("Args", (), {"api_key": None, "output_dir": None, "full": True, "workspace": [], "from_date": None, "refetch": None})()
@@ -190,6 +201,15 @@ class TestConfigLoad:
         cfg = Config.load(args)
         assert cfg.refetch == 5
 
+    def test_set_last_exported_keeps_workspace_name(self, monkeypatch, tmp_path):
+        import clockify_export.config as config_module
+        config_module.CONFIG_DIR = tmp_path / ".config" / "clockify-export"
+        config_module.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        config_module.STATE_FILE = config_module.CONFIG_DIR / "state.json"
+        set_last_exported("ws123", "2026-01-15T17:00:00+00:00", "Old Workspace")
+        state = get_state()
+        assert state["ws123"]["name"] == "Old Workspace"
+
     def test_dotenv_fallback(self, monkeypatch, tmp_path):
         import clockify_export.config as config_module
         env_file = tmp_path / ".env"

{clockify_export-0.2.0 → clockify_export-0.3.1}/uv.lock

@@ -1,10 +1,10 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.11"
 
 [[package]]
 name = "clockify-export"
-version = "0.2.0"
+version = "0.3.1"
 source = { editable = "." }
 
 [package.optional-dependencies]