fix(cli): normalize config data paths

Author: Scott Kostolni

limitless_tools/cli/main.py

@@ -6,10 +6,12 @@
 import sys
 from zoneinfo import ZoneInfo
 
+from pathlib import Path
+
 from limitless_tools.config.config import default_config_path, get_profile, load_config
 from limitless_tools.config.env import load_env
 from limitless_tools.config.logging import setup_logging
-from limitless_tools.config.paths import default_data_dir
+from limitless_tools.config.paths import default_data_dir, expand_path
 from limitless_tools.services.lifelog_service import LifelogService
 
 
@@ -93,6 +95,14 @@ def _build_parser() -> argparse.ArgumentParser:
     return parser
 
 
+def _normalize_data_dir(value: str | None, *, base_dir: str | None = None) -> str:
+    """Return a data_dir resolved relative to an optional base directory."""
+    normalized = expand_path(value, base_dir=base_dir)
+    if normalized:
+        return normalized
+    return default_data_dir()
+
+
 def main(argv: list[str] | None = None) -> int:
     # Ensure .env and related environment variables are loaded before parsing
     load_env()
@@ -108,11 +118,13 @@ def main(argv: list[str] | None = None) -> int:
 
     # Load config and resolve profile
     # Allow env var overrides for config path and profile
-    config_path = args.config or os.getenv("LIMITLESS_CONFIG")
+    config_path_arg = args.config or os.getenv("LIMITLESS_CONFIG")
+    resolved_config_path = expand_path(config_path_arg) or default_config_path()
     profile_name = args.profile or os.getenv("LIMITLESS_PROFILE") or "default"
 
-    cfg = load_config(config_path)
+    cfg = load_config(resolved_config_path)
     prof = get_profile(cfg, profile_name)
+    config_base_dir = str(Path(resolved_config_path).expanduser().parent)
 
     # Precedence: CLI flags > environment variables > config > defaults
     argv_list = argv or []
@@ -121,9 +133,11 @@ def _provided(opt: str) -> bool:
         return opt in argv_list
 
     # data_dir precedence
+    data_dir_from_config = False
     if not _provided("--data-dir") and not os.getenv("LIMITLESS_DATA_DIR"):
         if isinstance(prof.get("data_dir"), str):
             setattr(args, "data_dir", prof["data_dir"])
+            data_dir_from_config = True
 
     # batch_size precedence for fetch/sync
     if not _provided("--batch-size") and isinstance(prof.get("batch_size"), (int, float)):
@@ -139,6 +153,11 @@ def _provided(opt: str) -> bool:
     resolved_api_key = os.getenv("LIMITLESS_API_KEY") or (prof.get("api_key") if isinstance(prof.get("api_key"), str) else None)
     resolved_api_url = os.getenv("LIMITLESS_API_URL") or (prof.get("api_url") if isinstance(prof.get("api_url"), str) else None)
 
+    args.data_dir = _normalize_data_dir(
+        getattr(args, "data_dir", None),
+        base_dir=config_base_dir if data_dir_from_config else None,
+    )
+
     if args.command == "fetch":
         service = LifelogService(
             api_key=resolved_api_key,
@@ -257,7 +276,11 @@ def _provided(opt: str) -> bool:
         # Combined per-date export to a single file
         if args.combine:
             # Determine effective output directory: CLI --write-dir > config profile output_dir
-            cfg_output_dir = prof.get("output_dir") if isinstance(prof.get("output_dir"), str) else None
+            cfg_output_dir = (
+                expand_path(prof.get("output_dir"), base_dir=config_base_dir)
+                if isinstance(prof.get("output_dir"), str)
+                else None
+            )
             eff_write_dir = args.write_dir or cfg_output_dir
             if not args.date or not eff_write_dir:
                 sys.stderr.write("--combine requires --date and a write directory (provide --write-dir or set output_dir in config)\n")
@@ -283,7 +306,11 @@ def _provided(opt: str) -> bool:
         )
         csv_text = service.export_csv(date=args.date, include_markdown=bool(getattr(args, "include_markdown", False)))
         # Determine effective output file: CLI --output > config profile output_dir + default filename; else stdout
-        cfg_output_dir = prof.get("output_dir") if isinstance(prof.get("output_dir"), str) else None
+        cfg_output_dir = (
+            expand_path(prof.get("output_dir"), base_dir=config_base_dir)
+            if isinstance(prof.get("output_dir"), str)
+            else None
+        )
         eff_output = getattr(args, "output", None)
         if not eff_output and cfg_output_dir:
             import os as _os
@@ -327,7 +354,7 @@ def _provided(opt: str) -> bool:
     if args.command == "configure":
         # Compute target config path and profile
         from limitless_tools.config.config import load_config as _load_cfg, save_config as _save_cfg
-        target_path = config_path or default_config_path()
+        target_path = resolved_config_path
         target_profile = profile_name
         # Load existing config
         current = _load_cfg(target_path)

limitless_tools/config/paths.py

@@ -8,3 +8,29 @@ def default_data_dir() -> str:
     """Return the default data directory path for lifelogs."""
     return str(Path(os.path.expanduser("~")) / "limitless_tools" / "data" / "lifelogs")
 
+
+def expand_path(path: str | None, *, base_dir: str | None = None) -> str | None:
+    """Return the provided path expanded, optionally relative to a base directory."""
+    if not path:
+        return None
+    candidate = Path(path).expanduser()
+    if not candidate.is_absolute():
+        candidate = _restore_missing_root(candidate)
+    if not candidate.is_absolute() and base_dir:
+        base = Path(base_dir).expanduser()
+        candidate = base / candidate
+    return str(candidate)
+
+
+def _restore_missing_root(candidate: Path) -> Path:
+    """If the user omitted the leading '/', detect home-relative roots."""
+    parts = candidate.parts
+    if not parts:
+        return candidate
+    home = Path.home()
+    home_parts = home.parts
+    rel_home = home_parts[1:]
+    if rel_home and len(parts) >= len(rel_home) and tuple(parts[: len(rel_home)]) == tuple(rel_home):
+        root = home_parts[0] if home_parts else os.sep
+        return Path(root).joinpath(*parts)
+    return candidate

limitless_tools/storage/json_repo.py

@@ -7,7 +7,7 @@
 
 class JsonFileRepository:
     def __init__(self, base_dir: str) -> None:
-        self.base_dir = Path(base_dir)
+        self.base_dir = Path(base_dir).expanduser()
 
     def path_for_lifelog(self, lifelog: dict[str, Any]) -> str:
         start_time = lifelog.get("startTime", "0000-00-00T00:00:00Z")
@@ -21,4 +21,3 @@ def save_lifelog(self, lifelog: dict[str, Any]) -> str:
         path.parent.mkdir(parents=True, exist_ok=True)
         path.write_text(json.dumps(lifelog, ensure_ascii=False, indent=2))
         return str(path)
-

limitless_tools/storage/state_repo.py

@@ -12,7 +12,7 @@ class StateRepository:
 
     @property
     def _state_path(self) -> Path:
-        lifelogs_dir = Path(self.base_lifelogs_dir)
+        lifelogs_dir = Path(self.base_lifelogs_dir).expanduser()
         return lifelogs_dir.parent / "state" / "lifelogs_sync.json"
 
     def load(self) -> dict[str, Any]:
@@ -28,4 +28,3 @@ def save(self, state: dict[str, Any]) -> None:
         p = self._state_path
         p.parent.mkdir(parents=True, exist_ok=True)
         p.write_text(json.dumps(state, ensure_ascii=False, indent=2))
-

pyproject.toml

@@ -52,6 +52,9 @@ limitless = "limitless_tools.cli.main:main"
 [tool.setuptools.package-data]
 limitless_tools = ["py.typed"]
 
+[tool.setuptools]
+packages = ["limitless_tools"]
+
 [project.urls]
 Homepage = "https://github.com/ScottSucksAtProgramming/limitless_tools"
 Issues = "https://github.com/ScottSucksAtProgramming/limitless_tools/issues"

tests/conftest.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def isolate_config_path(tmp_path_factory, monkeypatch) -> None:
+    """Prevent pytest from loading the user config by pointing it to a temp path."""
+    cfg_dir = tmp_path_factory.mktemp("config")
+    cfg_path = cfg_dir / "config.toml"
+    monkeypatch.setenv("LIMITLESS_CONFIG", str(cfg_path))