feat(config): co-locate state directory inside mirror base path

Store state.db and blobs/ inside the mirror base path as .androidmigrate/
instead of the current working directory. A pointer file at
~/.config/androidmigrate/home remembers the base path for subsequent
launches. Priority: ANDROIDMIGRATE_HOME env > --state-dir > pointer file > CWD.

Author: MachineLearning-Nerd

src/androidmigrate/cli.py

@@ -1,14 +1,20 @@
 from __future__ import annotations
 
 import argparse
+import os
+import sys
 from pathlib import Path
 
-from .config import derive_label, get_state_dir, unique_label
+from .config import ENV_STATE_DIR, derive_label, get_state_dir, relocate_state, state_dir_for_base, unique_label, write_pointer_file
 from .storage import BlobStore, Repository
 from .sync_engine import SyncEngine, summary_to_text
 from .transport import ADBTransport, TransportError
 
 
+def _has_explicit_state_dir(argv: list[str]) -> bool:
+    return bool(os.environ.get(ENV_STATE_DIR)) or any(a.startswith("--state-dir") for a in argv)
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="androidmigrate")
     parser.add_argument("--state-dir", default=str(get_state_dir()), help="State directory for SQLite and blobs")
@@ -78,7 +84,22 @@ def build_parser() -> argparse.ArgumentParser:
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)
-    state_dir = Path(args.state_dir).expanduser()
+    explicit = _has_explicit_state_dir(argv or sys.argv[1:])
+
+    if not explicit and args.command == "profile" and args.profile_command == "create":
+        mirror_base = Path(args.mirror_dir).expanduser().resolve()
+        state_dir = state_dir_for_base(mirror_base)
+        old_state_dir = Path(args.state_dir).expanduser()
+        if old_state_dir != state_dir and (old_state_dir / "state.db").exists():
+            relocate_state(old_state_dir, state_dir)
+        write_pointer_file(mirror_base)
+    elif not explicit and args.command == "clone-restore":
+        mirror_base = Path(args.mirror_dir).expanduser().resolve()
+        state_dir = state_dir_for_base(mirror_base)
+        write_pointer_file(mirror_base)
+    else:
+        state_dir = Path(args.state_dir).expanduser()
+
     repository = Repository(state_dir)
     blob_store = BlobStore(state_dir)
     transport = ADBTransport()
@@ -126,7 +147,7 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "tui":
             from .tui import run_tui
 
-            return run_tui(repository, blob_store, transport)
+            return run_tui(repository, blob_store, transport, state_dir_explicit=explicit)
     except (ValueError, TransportError) as exc:
         parser.exit(status=2, message=f"error: {exc}\n")
     finally:

src/androidmigrate/config.py

@@ -2,18 +2,69 @@
 
 import os
 import re
+import shutil
 from pathlib import Path, PurePosixPath
 
 from .models import Profile, SyncRoot
 
 
 ENV_STATE_DIR = "ANDROIDMIGRATE_HOME"
+POINTER_DIR = Path.home() / ".config" / "androidmigrate"
+POINTER_FILE = POINTER_DIR / "home"
+STATE_SUBDIR = ".androidmigrate"
+
+
+def read_pointer_file() -> Path | None:
+    try:
+        text = POINTER_FILE.read_text().strip()
+        if text:
+            return Path(text)
+    except (OSError, ValueError):
+        pass
+    return None
+
+
+def write_pointer_file(base_path: Path) -> None:
+    POINTER_DIR.mkdir(parents=True, exist_ok=True)
+    POINTER_FILE.write_text(str(base_path.resolve()) + "\n")
+
+
+def state_dir_for_base(base_path: Path) -> Path:
+    return base_path / STATE_SUBDIR
+
+
+def relocate_state(old_state_dir: Path, new_state_dir: Path) -> None:
+    old_state_dir = old_state_dir.resolve()
+    new_state_dir = new_state_dir.resolve()
+    if old_state_dir == new_state_dir:
+        return
+    old_db = old_state_dir / "state.db"
+    if not old_db.exists():
+        return
+    new_db = new_state_dir / "state.db"
+    if new_db.exists():
+        raise FileExistsError(f"State database already exists at {new_db}")
+    new_state_dir.mkdir(parents=True, exist_ok=True)
+    for suffix in ("", "-wal", "-shm", "-journal"):
+        src = old_state_dir / f"state.db{suffix}"
+        if src.exists():
+            shutil.move(str(src), str(new_state_dir / src.name))
+    old_blobs = old_state_dir / "blobs"
+    if old_blobs.exists():
+        shutil.move(str(old_blobs), str(new_state_dir / "blobs"))
+    try:
+        old_state_dir.rmdir()
+    except OSError:
+        pass
 
 
 def get_state_dir() -> Path:
     raw = os.environ.get(ENV_STATE_DIR)
     if raw:
         return Path(raw).expanduser()
+    pointer = read_pointer_file()
+    if pointer:
+        return state_dir_for_base(pointer)
     return Path.cwd() / ".androidmigrate"
 
 

src/androidmigrate/tui.py

@@ -7,6 +7,7 @@
 from datetime import datetime
 from pathlib import Path
 
+from .config import relocate_state, state_dir_for_base, write_pointer_file
 from .mirror_path import autocomplete_directory_input, validate_target_mirror_path
 from .models import PROFILE_ACTIVE, PROFILE_PENDING_CLONE
 from .root_manager import ROOT_BROWSER, RootManagerController
@@ -460,6 +461,7 @@ def __init__(self, stdscr, repository, transport, theme) -> None:
         self.repository = repository
         self.transport = transport
         self.theme = theme
+        self.created_mirror_base: Path | None = None
         self.state = CreateProfileState()
         self.state.existing_names = {p.name for p in repository.list_profiles()}
         self._refresh_devices()
@@ -712,6 +714,7 @@ def _submit(self) -> str | None:
             self.state.status_message = f"Unable to create mirror directory: {exc}"
             return None
 
+        self.created_mirror_base = Path(self.state.mirror_text.strip()).expanduser().resolve()
         return f"Saved new profile {name}"
 
     def _show_confirmation(self, title: str, lines: list[str]) -> bool:
@@ -838,12 +841,14 @@ def _draw_banner(self, banner: Banner) -> None:
 
 
 class DashboardApp:
-    def __init__(self, stdscr, repository: Repository, blob_store: BlobStore, transport: ADBTransport) -> None:
+    def __init__(self, stdscr, repository: Repository, blob_store: BlobStore, transport: ADBTransport, state_dir_explicit: bool = False) -> None:
         self.stdscr = stdscr
         self.repository = repository
+        self.blob_store = blob_store
         self.transport = transport
         self.engine = SyncEngine(repository, blob_store, transport)
         self.state = DashboardState()
+        self.state_dir_explicit = state_dir_explicit
         self.devices = []
         self.profiles = []
         self.theme = None
@@ -858,6 +863,22 @@ def refresh(self) -> None:
         else:
             self.state.selected_profile = 0
 
+    def _maybe_relocate_state(self, mirror_base: Path) -> None:
+        if self.state_dir_explicit:
+            return
+        new_state_dir = state_dir_for_base(mirror_base)
+        old_state_dir = self.repository.state_dir
+        if old_state_dir.resolve() == new_state_dir.resolve():
+            write_pointer_file(mirror_base)
+            return
+        self.repository.close()
+        relocate_state(old_state_dir, new_state_dir)
+        write_pointer_file(mirror_base)
+        self.repository = Repository(new_state_dir)
+        new_blob_store = BlobStore(new_state_dir)
+        self.blob_store = new_blob_store
+        self.engine = SyncEngine(self.repository, new_blob_store, self.transport)
+
     def run(self) -> int:
         curses.curs_set(0)
         self.stdscr.keypad(True)
@@ -1141,7 +1162,10 @@ def open_root_manager(self) -> None:
         self.state.status_message = status
 
     def create_profile(self) -> None:
-        status = CreateProfileScreen(self.stdscr, self.repository, self.transport, self.theme).run()
+        screen = CreateProfileScreen(self.stdscr, self.repository, self.transport, self.theme)
+        status = screen.run()
+        if status and screen.created_mirror_base is not None:
+            self._maybe_relocate_state(screen.created_mirror_base)
         self.refresh()
         if status:
             self.state.status_message = status
@@ -1309,9 +1333,13 @@ def show_popup(self, title: str, lines: list[str]) -> None:
         del win
 
 
-def run_tui(repository: Repository, blob_store: BlobStore, transport: ADBTransport) -> int:
+def run_tui(repository: Repository, blob_store: BlobStore, transport: ADBTransport, state_dir_explicit: bool = False) -> int:
     def _wrapped(stdscr) -> int:
-        app = DashboardApp(stdscr, repository, blob_store, transport)
-        return app.run()
+        app = DashboardApp(stdscr, repository, blob_store, transport, state_dir_explicit)
+        try:
+            return app.run()
+        finally:
+            if app.repository is not repository:
+                app.repository.close()
 
     return curses.wrapper(_wrapped)

tests/test_config.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from androidmigrate import config
+
+
+@pytest.fixture(autouse=True)
+def _isolate_pointer(tmp_path, monkeypatch):
+    pointer_dir = tmp_path / "config" / "androidmigrate"
+    monkeypatch.setattr(config, "POINTER_DIR", pointer_dir)
+    monkeypatch.setattr(config, "POINTER_FILE", pointer_dir / "home")
+
+
+def test_read_pointer_file_returns_none_when_missing():
+    assert config.read_pointer_file() is None
+
+
+def test_write_and_read_pointer_file_roundtrip(tmp_path):
+    base = tmp_path / "backups"
+    base.mkdir()
+    config.write_pointer_file(base)
+    result = config.read_pointer_file()
+    assert result == base.resolve()
+
+
+def test_get_state_dir_prefers_env_over_pointer(tmp_path, monkeypatch):
+    env_dir = tmp_path / "env_state"
+    pointer_base = tmp_path / "pointer_base"
+    pointer_base.mkdir()
+    config.write_pointer_file(pointer_base)
+    monkeypatch.setenv("ANDROIDMIGRATE_HOME", str(env_dir))
+    assert config.get_state_dir() == env_dir
+
+
+def test_get_state_dir_uses_pointer_when_no_env(tmp_path, monkeypatch):
+    monkeypatch.delenv("ANDROIDMIGRATE_HOME", raising=False)
+    base = tmp_path / "backups"
+    base.mkdir()
+    config.write_pointer_file(base)
+    assert config.get_state_dir() == base / ".androidmigrate"
+
+
+def test_get_state_dir_falls_back_to_cwd(monkeypatch):
+    monkeypatch.delenv("ANDROIDMIGRATE_HOME", raising=False)
+    cwd = Path.cwd()
+    assert config.get_state_dir() == cwd / ".androidmigrate"
+
+
+def test_state_dir_for_base(tmp_path):
+    assert config.state_dir_for_base(tmp_path / "backups") == tmp_path / "backups" / ".androidmigrate"
+
+
+def test_relocate_state_moves_db_and_blobs(tmp_path):
+    old = tmp_path / "old_state"
+    old.mkdir()
+    (old / "state.db").write_text("db content")
+    (old / "state.db-wal").write_text("wal content")
+    blobs = old / "blobs" / "ab"
+    blobs.mkdir(parents=True)
+    (blobs / "abcdef").write_text("blob data")
+
+    new = tmp_path / "new_state"
+    config.relocate_state(old, new)
+
+    assert (new / "state.db").read_text() == "db content"
+    assert (new / "state.db-wal").read_text() == "wal content"
+    assert (new / "blobs" / "ab" / "abcdef").read_text() == "blob data"
+    assert not (old / "state.db").exists()
+    assert not (old / "blobs").exists()
+
+
+def test_relocate_state_noop_same_dir(tmp_path):
+    state = tmp_path / "state"
+    state.mkdir()
+    (state / "state.db").write_text("db content")
+    config.relocate_state(state, state)
+    assert (state / "state.db").read_text() == "db content"
+
+
+def test_relocate_state_noop_no_db(tmp_path):
+    old = tmp_path / "old"
+    old.mkdir()
+    new = tmp_path / "new"
+    config.relocate_state(old, new)
+    assert not new.exists()
+
+
+def test_relocate_state_raises_when_dest_has_db(tmp_path):
+    old = tmp_path / "old"
+    old.mkdir()
+    (old / "state.db").write_text("old db")
+    new = tmp_path / "new"
+    new.mkdir()
+    (new / "state.db").write_text("existing db")
+    with pytest.raises(FileExistsError):
+        config.relocate_state(old, new)