Fix: Update Session.load_by_id to use KaosPath and fix tests

This commit completes the merge resolution by:
1. Updating Session.load_by_id() to return KaosPath instead of Path for work_dir
2. Converting all test functions to async and properly setting up kaos context
3. Updating test fixtures to handle the new async Session.create() and Session.continue_() methods

Author: Anthonyeef

src/kimi_cli/session.py

@@ -108,7 +108,7 @@ def load_by_id(session_id: str) -> Session | None:
         # Try metadata lookup first (fast path)
         work_dir_str = metadata.session_to_workdir.get(session_id)
         if work_dir_str:
-            work_dir = Path(work_dir_str)
+            work_dir = KaosPath.unsafe_from_local_path(Path(work_dir_str))
             work_dir_meta = next(
                 (wd for wd in metadata.work_dirs if wd.path == work_dir_str), None
             )
@@ -145,7 +145,7 @@ def load_by_id(session_id: str) -> Session | None:
                     # We need to find which work_dir_meta has this sessions_dir
                     for work_dir_meta in metadata.work_dirs:
                         if work_dir_meta.sessions_dir == work_dir_hash_dir:
-                            work_dir = Path(work_dir_meta.path)
+                            work_dir = KaosPath.unsafe_from_local_path(Path(work_dir_meta.path))
                             logger.debug(
                                 "Found session in filesystem: {session_id} -> {work_dir}",
                                 session_id=session_id,

tests/test_session.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 import pytest
 
+from kaos import current_kaos
+from kaos.local import LocalKaos
+from kaos.path import KaosPath
 from kimi_cli.metadata import load_metadata
 from kimi_cli.session import Session
 
@@ -25,12 +29,25 @@ def _get_share_dir() -> Path:
     return share_dir
 
 
-def test_session_create(isolated_share_dir: Path, tmp_path: Path):
+@pytest.fixture
+def kaos_context(tmp_path: Path):
+    """Set up a Kaos context for async operations."""
+    token = current_kaos.set(LocalKaos())
+    old_cwd = Path.cwd()
+    os.chdir(tmp_path)
+    try:
+        yield
+    finally:
+        os.chdir(old_cwd)
+        current_kaos.reset(token)
+
+
+async def test_session_create(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test creating a new session."""
-    work_dir = tmp_path / "work"
-    work_dir.mkdir()
+    work_dir = KaosPath.unsafe_from_local_path(tmp_path / "work")
+    await work_dir.mkdir()
 
-    session = Session.create(work_dir)
+    session = await Session.create(work_dir)
 
     assert session.id is not None
     assert session.work_dir == work_dir
@@ -44,13 +61,13 @@ def test_session_create(isolated_share_dir: Path, tmp_path: Path):
     assert metadata.session_to_workdir[session.id] == str(work_dir)
 
 
-def test_session_create_multiple_sessions(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_create_multiple_sessions(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test creating multiple sessions for the same work directory."""
-    work_dir = tmp_path / "work"
-    work_dir.mkdir()
+    work_dir = KaosPath.unsafe_from_local_path(tmp_path / "work")
+    await work_dir.mkdir()
 
-    session1 = Session.create(work_dir)
-    session2 = Session.create(work_dir)
+    session1 = await Session.create(work_dir)
+    session2 = await Session.create(work_dir)
 
     assert session1.id != session2.id
     assert session1.work_dir == session2.work_dir
@@ -62,15 +79,15 @@ def test_session_create_multiple_sessions(isolated_share_dir: Path, tmp_path: Pa
     assert session2.id in metadata.session_to_workdir
 
 
-def test_session_create_different_work_dirs(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_create_different_work_dirs(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test creating sessions for different work directories."""
-    work_dir1 = tmp_path / "work1"
-    work_dir2 = tmp_path / "work2"
-    work_dir1.mkdir()
-    work_dir2.mkdir()
+    work_dir1 = KaosPath.unsafe_from_local_path(tmp_path / "work1")
+    work_dir2 = KaosPath.unsafe_from_local_path(tmp_path / "work2")
+    await work_dir1.mkdir()
+    await work_dir2.mkdir()
 
-    session1 = Session.create(work_dir1)
-    session2 = Session.create(work_dir2)
+    session1 = await Session.create(work_dir1)
+    session2 = await Session.create(work_dir2)
 
     assert session1.work_dir != session2.work_dir
     assert session1.id != session2.id
@@ -81,23 +98,23 @@ def test_session_create_different_work_dirs(isolated_share_dir: Path, tmp_path:
     assert metadata.session_to_workdir[session2.id] == str(work_dir2)
 
 
-def test_session_continue_no_previous_session(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_continue_no_previous_session(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test continuing when no previous session exists."""
-    work_dir = tmp_path / "work"
-    work_dir.mkdir()
+    work_dir = KaosPath.unsafe_from_local_path(tmp_path / "work")
+    await work_dir.mkdir()
 
-    session = Session.continue_(work_dir)
+    session = await Session.continue_(work_dir)
 
     assert session is None
 
 
-def test_session_continue_with_previous_session(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_continue_with_previous_session(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test continuing a previous session."""
-    work_dir = tmp_path / "work"
-    work_dir.mkdir()
+    work_dir = KaosPath.unsafe_from_local_path(tmp_path / "work")
+    await work_dir.mkdir()
 
     # Create a session first
-    created_session = Session.create(work_dir)
+    created_session = await Session.create(work_dir)
 
     # Update metadata to mark it as last session
     metadata = load_metadata()
@@ -109,20 +126,20 @@ def test_session_continue_with_previous_session(isolated_share_dir: Path, tmp_pa
     save_metadata(metadata)
 
     # Now continue
-    continued_session = Session.continue_(work_dir)
+    continued_session = await Session.continue_(work_dir)
 
     assert continued_session is not None
     assert continued_session.id == created_session.id
     assert continued_session.work_dir == created_session.work_dir
     assert continued_session.history_file == created_session.history_file
 
 
-def test_session_load_by_id_valid(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_load_by_id_valid(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test loading a session by valid ID."""
-    work_dir = tmp_path / "work"
-    work_dir.mkdir()
+    work_dir = KaosPath.unsafe_from_local_path(tmp_path / "work")
+    await work_dir.mkdir()
 
-    created_session = Session.create(work_dir)
+    created_session = await Session.create(work_dir)
     session_id = created_session.id
 
     # Create the history file (Session.create doesn't create it, only sets the path)
@@ -137,7 +154,7 @@ def test_session_load_by_id_valid(isolated_share_dir: Path, tmp_path: Path):
     assert loaded_session.history_file == created_session.history_file
 
 
-def test_session_load_by_id_nonexistent(isolated_share_dir: Path):
+def test_session_load_by_id_nonexistent(kaos_context, isolated_share_dir: Path):
     """Test loading a non-existent session ID."""
     import uuid
 
@@ -147,15 +164,15 @@ def test_session_load_by_id_nonexistent(isolated_share_dir: Path):
     assert loaded_session is None
 
 
-def test_session_load_by_id_different_work_dir(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_load_by_id_different_work_dir(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test loading a session from a different work directory."""
-    work_dir1 = tmp_path / "work1"
-    work_dir2 = tmp_path / "work2"
-    work_dir1.mkdir()
-    work_dir2.mkdir()
+    work_dir1 = KaosPath.unsafe_from_local_path(tmp_path / "work1")
+    work_dir2 = KaosPath.unsafe_from_local_path(tmp_path / "work2")
+    await work_dir1.mkdir()
+    await work_dir2.mkdir()
 
-    session1 = Session.create(work_dir1)
-    session2 = Session.create(work_dir2)
+    session1 = await Session.create(work_dir1)
+    session2 = await Session.create(work_dir2)
 
     # Create history files
     session1.history_file.parent.mkdir(parents=True, exist_ok=True)
@@ -171,13 +188,13 @@ def test_session_load_by_id_different_work_dir(isolated_share_dir: Path, tmp_pat
     assert loaded_session.work_dir == work_dir1  # Should use original work_dir
 
 
-def test_session_load_by_id_filesystem_fallback(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_load_by_id_filesystem_fallback(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test filesystem fallback when session not in metadata."""
-    work_dir = tmp_path / "work"
-    work_dir.mkdir()
+    work_dir = KaosPath.unsafe_from_local_path(tmp_path / "work")
+    await work_dir.mkdir()
 
     # Create a session
-    created_session = Session.create(work_dir)
+    created_session = await Session.create(work_dir)
     session_id = created_session.id
 
     # Create the history file
@@ -204,13 +221,13 @@ def test_session_load_by_id_filesystem_fallback(isolated_share_dir: Path, tmp_pa
     assert metadata.session_to_workdir[session_id] == str(work_dir)
 
 
-def test_session_load_by_id_history_file_missing(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_load_by_id_history_file_missing(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test loading a session when history file is missing."""
-    work_dir = tmp_path / "work"
-    work_dir.mkdir()
+    work_dir = KaosPath.unsafe_from_local_path(tmp_path / "work")
+    await work_dir.mkdir()
 
     # Create a session
-    created_session = Session.create(work_dir)
+    created_session = await Session.create(work_dir)
     session_id = created_session.id
 
     # Create and then remove history file
@@ -231,35 +248,35 @@ def test_session_load_by_id_history_file_missing(isolated_share_dir: Path, tmp_p
     assert loaded_session is None
 
 
-def test_session_create_truncates_existing_history(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_create_truncates_existing_history(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test that creating a session truncates existing history file when using same history file."""
-    work_dir = tmp_path / "work"
-    work_dir.mkdir()
+    work_dir = KaosPath.unsafe_from_local_path(tmp_path / "work")
+    await work_dir.mkdir()
 
     # Create first session
-    session1 = Session.create(work_dir)
+    session1 = await Session.create(work_dir)
     history_file = session1.history_file
 
     # Create the history file and write content
     history_file.parent.mkdir(parents=True, exist_ok=True)
     history_file.write_text("some history content\n")
 
     # Create second session with the same history file (using _history_file parameter)
-    session2 = Session.create(work_dir, _history_file=history_file)
+    session2 = await Session.create(work_dir, _history_file=history_file)
 
     # History file should be empty (truncated)
     assert history_file.exists()
     assert history_file.read_text() == ""
 
 
-def test_session_continue_updates_last_session_id(isolated_share_dir: Path, tmp_path: Path):
+async def test_session_continue_updates_last_session_id(kaos_context, isolated_share_dir: Path, tmp_path: Path):
     """Test that continuing a session updates last_session_id in metadata."""
-    work_dir = tmp_path / "work"
-    work_dir.mkdir()
+    work_dir = KaosPath.unsafe_from_local_path(tmp_path / "work")
+    await work_dir.mkdir()
 
     # Create multiple sessions
-    session1 = Session.create(work_dir)
-    session2 = Session.create(work_dir)
+    session1 = await Session.create(work_dir)
+    session2 = await Session.create(work_dir)
 
     # Manually set last_session_id to session1
     metadata = load_metadata()
@@ -271,6 +288,6 @@ def test_session_continue_updates_last_session_id(isolated_share_dir: Path, tmp_
     save_metadata(metadata)
 
     # Continue should return session1
-    continued = Session.continue_(work_dir)
+    continued = await Session.continue_(work_dir)
     assert continued is not None
     assert continued.id == session1.id