claude-opencode-sessions 0.1.0__py3-none-any.whl

claude_opencode_sessions/tests/test_parse.py

@@ -0,0 +1,120 @@
+from claude_opencode_sessions.models import format_model
+from claude_opencode_sessions.parse import (
+    loads,
+    parse_v1_message,
+    parse_v1_part,
+    parse_v2_row,
+)
+from claude_opencode_sessions.tests.conftest import text_of
+
+
+def test_format_model_variants():
+    assert format_model('{"id": "m", "providerID": "p"}') == "p/m"
+    assert format_model({"modelID": "m"}) == "m"
+    assert format_model("plain-model") == "plain-model"
+    assert format_model("{broken") == "{broken"
+    assert format_model(None) is None
+    assert format_model({"x": 1}) is None
+
+
+def test_loads_is_forgiving():
+    assert loads('{"a": 1}') == {"a": 1}
+    assert loads("not json") is None
+    assert loads(None) is None
+    assert loads({"a": 1}) == {"a": 1}
+
+
+def test_v1_parts():
+    assert parse_v1_part({"type": "step-start"}) is None
+    assert parse_v1_part({"type": "step-finish"}) is None
+    text = parse_v1_part({"type": "text", "text": "hi", "synthetic": True})
+    assert text is not None
+    assert (text.kind, text.text, text.synthetic) == ("text", "hi", True)
+    tool = parse_v1_part(
+        {
+            "type": "tool",
+            "tool": "bash",
+            "state": {"status": "error", "input": {"command": "ls"}, "error": "boom"},
+        }
+    )
+    assert tool is not None
+    assert (tool.tool, tool.status, tool.tool_output) == ("bash", "error", "boom")
+    assert tool.tool_input == {"command": "ls"}
+    patch = parse_v1_part({"type": "patch", "files": ["a.py", "b.py"]})
+    assert patch is not None and patch.files == ["a.py", "b.py"]
+    file_part = parse_v1_part({"type": "file", "filename": "x.png"})
+    assert file_part is not None and file_part.text == "x.png"
+    compaction = parse_v1_part({"type": "compaction"})
+    assert compaction is not None and compaction.kind == "compaction"
+    other = parse_v1_part({"type": "weird", "text": "?"})
+    assert other is not None and other.kind == "weird"
+    assert parse_v1_part("raw").kind == "other"  # type: ignore[union-attr]
+
+
+def test_v1_message_model_and_error():
+    message = parse_v1_message(
+        {
+            "id": "m1",
+            "role": "assistant",
+            "modelID": "gpt",
+            "providerID": "openai",
+            "error": {"name": "APIError", "data": {"message": "rate limited"}},
+            "time": {"created": 5},
+            "cost": 0.5,
+        },
+        [{"type": "text", "text": "a"}, {"type": "step-finish"}],
+        seq=3,
+    )
+    assert message.model == "openai/gpt"
+    assert message.error == "APIError: rate limited"
+    assert message.seq == 3
+    assert message.time_created == 5
+    assert message.cost == 0.5
+    assert [p.kind for p in message.parts] == ["text"]
+
+
+def test_v1_message_user_model_object():
+    message = parse_v1_message(
+        {"role": "user", "model": {"providerID": "p", "modelID": "m"}}, []
+    )
+    assert message.model == "p/m"
+    assert message.role == "user"
+
+
+def test_v2_user_row():
+    message, ok = parse_v2_row("r1", "user", '{"text": "hello"}', 1, 10)
+    assert ok
+    assert message.role == "user"
+    assert text_of(message) == "hello"
+
+
+def test_v2_assistant_row_with_content_list():
+    data = {
+        "model": {"id": "m", "providerID": "p"},
+        "tokens": {"input": 1, "output": 2},
+        "cost": 0.1,
+        "content": [
+            {"type": "text", "text": "answer"},
+            {"type": "reasoning", "text": "hmm"},
+            {"type": "tool", "tool": "read", "state": {"input": {"filePath": "a"}}},
+            {"type": "tool-call", "name": "bash", "args": {"command": "ls"}},
+            "loose string",
+        ],
+    }
+    message, ok = parse_v2_row("r2", "assistant", data, 2, 11)
+    assert ok
+    assert message.model == "p/m"
+    kinds = [p.kind for p in message.parts]
+    assert kinds == ["text", "reasoning", "tool", "tool", "text"]
+    assert message.parts[3].tool == "bash"
+    assert message.parts[3].tool_input == {"command": "ls"}
+
+
+def test_v2_tool_row_and_bad_json():
+    message, ok = parse_v2_row("r3", "tool", {"tool": "grep", "input": {}}, 3, 12)
+    assert ok and message.parts[0].tool == "grep"
+    broken, ok = parse_v2_row("r4", "assistant", "{nope", 4, 13)
+    assert not ok
+    assert broken.parts[-1].text == "[unparseable message payload]"
+    idle, ok = parse_v2_row("r5", "idle", "{}", 5, 14)
+    assert ok and idle.role == "idle" and idle.parts == []

claude_opencode_sessions/tests/test_render.py

@@ -0,0 +1,107 @@
+from claude_opencode_sessions.models import Part, Session
+from claude_opencode_sessions.render import (
+    absolute_time,
+    cell,
+    relative_time,
+    render_list,
+    tilde,
+    tool_summary,
+    truncate,
+)
+from claude_opencode_sessions.scope import Scope
+from claude_opencode_sessions.tests.conftest import HOUR, NOW
+
+SCOPE = Scope("worktree", "/repo", ["/repo"], in_git=True)
+
+
+def session(**kw) -> Session:
+    base = {
+        "id": "ses_1",
+        "title": "Fix | the bug",
+        "directory": "/repo/sub",
+        "time_created": NOW - 2 * HOUR,
+        "time_updated": NOW - HOUR,
+        "agent": "build",
+        "model": "openai/gpt",
+        "message_count": 4,
+    }
+    base.update(kw)
+    return Session(**base)
+
+
+def test_relative_and_absolute_time():
+    assert relative_time(None) == "?"
+    assert relative_time(NOW - 10_000, NOW) == "just now"
+    assert relative_time(NOW - 5 * 60_000, NOW) == "5m ago"
+    assert relative_time(NOW - 3 * HOUR, NOW) == "3h ago"
+    assert relative_time(NOW - 50 * HOUR, NOW) == "2d ago"
+    assert relative_time(NOW - 40 * 24 * HOUR, NOW).count("-") == 2
+    assert absolute_time(None) == "?"
+    assert len(absolute_time(NOW)) == len("2026-09-21 20:51")
+
+
+def test_truncate_cell_and_tilde(monkeypatch):
+    assert truncate("abc", 10) == "abc"
+    assert truncate("abcdef", 3).startswith("abc\n… [3 more chars]")
+    assert truncate("abcdef", 0) == "abcdef"
+    assert cell("a |  b\nc") == "a \\| b c"
+    assert cell("x" * 100, 10) == "x" * 9 + "…"
+    monkeypatch.setenv("HOME", "/home/me")
+    assert tilde("/home/me/repo") == "~/repo"
+    assert tilde("/other") == "/other"
+
+
+def test_tool_summary():
+    assert tool_summary(
+        Part("tool", tool="read", tool_input={"filePath": "/a.py"})
+    ) == ("→ read: `/a.py`")
+    multi = tool_summary(Part("tool", tool="bash", tool_input={"command": "a\nb"}))
+    assert multi == "→ bash: `a …`"
+    failed = Part("tool", tool="bash", tool_input={"command": "x"}, status="error")
+    assert tool_summary(failed).endswith("(error)")
+    assert tool_summary(Part("tool", tool="todo", tool_input={"k": 1})).startswith(
+        '→ todo: `{"k": 1}'
+    )
+    assert tool_summary(Part("tool", tool="noargs", title="T")) == "→ noargs: `T`"
+    assert tool_summary(Part("tool", tool="bare")) == "→ bare"
+    assert tool_summary(Part("tool", tool="s", tool_input="raw\nmore")) == "→ s: `raw`"
+
+
+def test_render_list_table_and_footer():
+    out = render_list(
+        [
+            session(),
+            session(id="ses_2", directory="/repo", parent_id="x", time_archived=1),
+        ],
+        SCOPE,
+        hidden_archived=2,
+        hidden_subagents=1,
+        total=5,
+        backend="sqlite",
+        notes=["hello"],
+        now_ms=NOW,
+    )
+    assert (
+        "| 1 | Fix \\| the bug | 1h ago | 4 | build · openai/gpt | sub | `ses_1` |"
+        in out
+    )
+    assert "_(archived, sub-agent)_" in out
+    assert "| . |" in out
+    assert "showing 2 of 5" in out
+    assert "2 archived (--include-archived)" in out
+    assert "1 sub-agent (--include-subagents)" in out
+    assert "_note: hello_" in out
+
+
+def test_render_list_empty_suggests_wider_scope():
+    out = render_list([], SCOPE)
+    assert "No opencode sessions found" in out
+    assert "--worktrees" in out
+
+
+def test_render_list_other_worktree_and_all_scope():
+    repo_scope = Scope("repo", "/repo", ["/repo", "/repo-feature"], in_git=True)
+    out = render_list([session(directory="/repo-feature/x")], repo_scope, now_ms=NOW)
+    assert "/repo-feature/x" in out
+    out = render_list([session()], Scope("all", "/repo", ["/repo"]), now_ms=NOW)
+    assert "/repo/sub" in out

claude_opencode_sessions/tests/test_scope.py

@@ -0,0 +1,121 @@
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+from claude_opencode_sessions.models import Session
+from claude_opencode_sessions.scope import (
+    Scope,
+    git_toplevel,
+    git_worktrees,
+    is_within,
+    normalize,
+    path_key,
+    resolve_scope,
+)
+
+
+def s(sid: str, directory: str, project: str = "p") -> Session:
+    return Session(id=sid, title=sid, directory=directory, project_id=project)
+
+
+def test_normalize_repairs_missing_leading_slash(tmp_path: Path):
+    assert normalize("Users/me/repo/") == os.path.realpath("/Users/me/repo")
+    assert normalize("") == ""
+    assert normalize(str(tmp_path) + "/") == str(tmp_path.resolve())
+    assert normalize("/") == "/"
+
+
+def test_normalize_resolves_symlinks(tmp_path: Path):
+    target = tmp_path / "target"
+    target.mkdir()
+    link = tmp_path / "link"
+    link.symlink_to(target)
+    assert normalize(str(link)) == str(target.resolve())
+
+
+def test_is_within():
+    assert is_within("/a/b", "/a/b")
+    assert is_within("/a/b/c", "/a/b")
+    assert not is_within("/a/bc", "/a/b")
+    assert is_within("/anything", "/")
+
+
+@pytest.mark.skipif(sys.platform != "darwin", reason="macOS is case-insensitive")
+def test_path_key_casefolds_on_macos():  # pragma: no cover - platform specific
+    assert path_key("/Users/Me") == path_key("/users/me")
+
+
+def test_invalid_mode():
+    with pytest.raises(ValueError):
+        resolve_scope("/", "nope")
+
+
+def test_non_git_directory_scope(git_repo):
+    plain = git_repo["plain"]
+    scope = resolve_scope(str(plain / "inner"))
+    assert not scope.in_git
+    assert scope.roots == [str(plain / "inner")]
+    sessions = [
+        s("in", str(plain / "inner")),
+        s("below", str(plain / "inner" / "x")),
+        s("parent", str(plain)),
+    ]
+    assert [x.id for x in scope.filter(sessions)] == ["in", "below"]
+    assert "directory" in scope.describe()
+
+
+def test_worktree_scope_uses_git_toplevel(git_repo):
+    repo, feature = git_repo["repo"], git_repo["feature"]
+    scope = resolve_scope(str(repo / "sub" / "deep"))
+    assert scope.in_git
+    assert scope.root == str(repo)
+    sessions = [
+        s("root", str(repo)),
+        s("sub", str(repo / "sub")),
+        s("feature", str(feature)),
+        s("other", "/somewhere/else"),
+    ]
+    assert [x.id for x in scope.filter(sessions)] == ["root", "sub"]
+    assert "git worktree" in scope.describe()
+
+
+def test_repo_scope_includes_all_worktrees(git_repo):
+    repo, feature = git_repo["repo"], git_repo["feature"]
+    assert git_toplevel(str(feature)) == str(feature)
+    assert set(git_worktrees(str(repo))) == {str(repo), str(feature)}
+    scope = resolve_scope(str(feature), "repo")
+    assert scope.root == str(feature)  # current worktree first
+    assert set(scope.roots) == {str(repo), str(feature)}
+    sessions = [
+        s("root", str(repo)),
+        s("feature", str(feature / "x")),
+        s("gone", str(repo.parent / "deleted-worktree")),  # same project, missing
+        s("gone-other-project", str(repo.parent / "deleted2"), project="q"),
+        s("global", str(repo.parent / "deleted3"), project="global"),
+    ]
+    assert [x.id for x in scope.filter(sessions)] == ["root", "feature", "gone"]
+    assert "worktree(s)" in scope.describe()
+
+
+def test_repo_scope_outside_git_behaves_like_worktree(git_repo):
+    scope = resolve_scope(str(git_repo["plain"]), "repo")
+    assert scope.roots == [str(git_repo["plain"])]
+
+
+def test_all_scope_matches_everything(git_repo):
+    scope = resolve_scope(str(git_repo["repo"]), "all")
+    assert scope.matches("/whatever")
+    assert len(scope.filter([s("a", "/x"), s("b", "/y")])) == 2
+    assert scope.describe() == "all sessions on this machine"
+
+
+def test_git_helpers_outside_repo(tmp_path: Path):
+    assert git_toplevel(str(tmp_path / "missing")) is None
+    assert git_worktrees(str(tmp_path / "missing")) == []
+
+
+def test_scope_root_defaults_to_cwd():
+    scope = Scope("worktree", "/x")
+    assert scope.root == "/x"

claude_opencode_sessions/tests/test_sqlite_backend.py

@@ -0,0 +1,157 @@
+import sqlite3
+from pathlib import Path
+
+import pytest
+
+from claude_opencode_sessions.errors import SchemaError
+from claude_opencode_sessions.sqlite_backend import SqliteBackend
+from claude_opencode_sessions.tests.conftest import (
+    NOW,
+    DbBuilder,
+    assistant,
+    text,
+    text_of,
+    tool,
+    user,
+)
+
+
+def test_lists_1x_sessions(db_1x: DbBuilder):
+    db_1x.session_1x(
+        "ses_a",
+        "/work/repo",
+        title="First",
+        messages=[user("hi"), assistant(text("hello"))],
+    )
+    db_1x.session_1x("ses_b", "/work/repo/sub", updated=NOW - 10, parent_id="ses_a")
+    db_1x.close()
+    backend = SqliteBackend(db_1x.path)
+    sessions = {s.id: s for s in backend.list_sessions()}
+    assert set(sessions) == {"ses_a", "ses_b"}
+    first = sessions["ses_a"]
+    assert first.title == "First"
+    assert first.message_count == 2
+    assert first.model == "openai/gpt-x"
+    assert first.agent == "build"
+    assert first.version == "1.18.32"
+    assert first.origin == "session"
+    assert sessions["ses_b"].is_subagent
+    assert "1.x message/part" in backend.describe()
+    assert backend.table_report()["message"] == 2
+
+
+def test_loads_1x_messages_in_order(db_1x: DbBuilder):
+    db_1x.session_1x(
+        "ses_a",
+        "/w",
+        messages=[
+            user("question"),
+            assistant(text("thinking out loud"), tool("bash", {"command": "ls"})),
+            assistant(text("done")),
+        ],
+    )
+    db_1x.close()
+    messages, errors = SqliteBackend(db_1x.path).load_messages("ses_a")
+    assert errors == 0
+    assert [m.role for m in messages] == ["user", "assistant", "assistant"]
+    assert [m.seq for m in messages] == [1, 2, 3]
+    assert text_of(messages[0]) == "question"
+    assert [p.kind for p in messages[1].parts] == ["text", "tool"]
+    assert messages[1].model == "openai/gpt-x"
+
+
+def test_counts_parse_errors(db_1x: DbBuilder):
+    db_1x.session_1x("ses_a", "/w", messages=[({"role": "user"}, ["{broken"])])
+    db_1x.close()
+    messages, errors = SqliteBackend(db_1x.path).load_messages("ses_a")
+    assert errors == 1
+    assert len(messages) == 1
+
+
+def test_2x_sessions_and_messages(db_2x: DbBuilder):
+    db_2x.session_2x(
+        "ses_v2",
+        "/w",
+        rows=[
+            ("user", {"text": "hi"}),
+            ("assistant", {"content": [{"type": "text", "text": "yo"}]}),
+            ("idle", {}),
+        ],
+    )
+    db_2x.close()
+    backend = SqliteBackend(db_2x.path)
+    [session] = backend.list_sessions()
+    assert session.origin == "session_v2"
+    assert session.message_count == 2  # only user/assistant rows count
+    assert session.version is None  # column missing in 2.x fixture
+    messages, errors = backend.load_messages("ses_v2")
+    assert errors == 0
+    assert [m.role for m in messages] == ["user", "assistant", "idle"]
+    assert "2.x session_message" in backend.describe()
+
+
+def test_mixed_database_prefers_2x_and_falls_back_per_session(tmp_path: Path):
+    builder = DbBuilder(tmp_path / "mixed.db", "schema_1x.sql")
+    builder.conn.executescript(
+        (Path(__file__).parent / "fixtures" / "schema_2x.sql")
+        .read_text()
+        .replace("CREATE TABLE `project`", "CREATE TABLE `project_unused`")
+        .replace(
+            "CREATE TABLE `session_message`", "CREATE TABLE `session_message_unused`"
+        )
+        .replace("ON `session_message`", "ON `session_message_unused`")
+        .replace("session_message_session_seq_idx", "unused_idx")
+    )
+    # Migrated session: exists in both tables, 2.x metadata wins.
+    builder.session_1x("ses_same", "/w", title="old title", messages=[user("legacy")])
+    builder.session_2x("ses_same", "/w", title="new title")
+    # Session only in the frozen 1.x table.
+    builder.session_1x("ses_old", "/w", title="only legacy")
+    # Session with 2.x messages.
+    builder.session_2x("ses_new", "/w", rows=[("user", {"text": "fresh"})])
+    builder.close()
+    backend = SqliteBackend(builder.path)
+    sessions = {s.id: s for s in backend.list_sessions()}
+    assert set(sessions) == {"ses_same", "ses_old", "ses_new"}
+    assert sessions["ses_same"].title == "new title"
+    assert sessions["ses_same"].origin == "session_v2"
+    assert sessions["ses_old"].origin == "session"
+    # No 2.x rows for ses_same -> falls back to 1.x messages.
+    messages, _ = backend.load_messages("ses_same")
+    assert text_of(messages[0]) == "legacy"
+    messages, _ = backend.load_messages("ses_new")
+    assert text_of(messages[0]) == "fresh"
+
+
+def test_rejects_unrelated_database(tmp_path: Path):
+    path = tmp_path / "other.db"
+    conn = sqlite3.connect(path)
+    conn.execute("CREATE TABLE foo (id)")
+    conn.close()
+    with pytest.raises(SchemaError, match="no opencode session table"):
+        SqliteBackend(path)
+
+
+def test_rejects_session_table_without_messages(tmp_path: Path):
+    path = tmp_path / "half.db"
+    conn = sqlite3.connect(path)
+    conn.execute("CREATE TABLE session (id, directory, time_updated)")
+    conn.close()
+    with pytest.raises(SchemaError, match="no opencode message tables"):
+        SqliteBackend(path)
+
+
+def test_rejects_non_sqlite_file(tmp_path: Path):
+    path = tmp_path / "garbage.db"
+    path.write_bytes(b"this is not a database" * 100)
+    with pytest.raises(SchemaError):
+        SqliteBackend(path)
+
+
+def test_never_writes(db_1x: DbBuilder):
+    db_1x.session_1x("ses_a", "/w")
+    db_1x.close()
+    backend = SqliteBackend(db_1x.path)
+    with pytest.raises(sqlite3.OperationalError):
+        backend.conn.execute("DELETE FROM session")
+    backend.close()