kolega-code 0.1.0__py3-none-any.whl

kolega_code/cli/tests/test_main.py

@@ -0,0 +1,455 @@
+import asyncio
+import json
+from pathlib import Path
+
+import pytest
+
+from kolega_code import __version__
+from kolega_code.cli.main import CLI_AGENT_MODE, RESUME_LATEST, _resolve_tui_session, main, parse_args
+from kolega_code.cli.provider_registry import UI_DEFAULT_MODEL, UI_DEFAULT_PROVIDER
+from kolega_code.cli.session_store import SessionStore, SessionStoreError
+from kolega_code.cli.settings import CliSettings, SettingsStore
+from kolega_code.llm.models import Message
+
+
+def write_skill(root: Path, name: str = "demo-skill") -> None:
+    skill_dir = root / ".agents" / "skills" / name
+    skill_dir.mkdir(parents=True)
+    (skill_dir / "SKILL.md").write_text(
+        f"---\nname: {name}\ndescription: Use this demo skill.\n---\n\nFollow demo instructions.\n",
+        encoding="utf-8",
+    )
+
+
+def test_parse_default_command_as_tui() -> None:
+    args = parse_args(["/tmp/project", "--new"])
+
+    assert args.command == "tui"
+    assert args.project_path == Path("/tmp/project")
+    assert args.new is True
+    assert args.resume is None
+    assert args.mode == CLI_AGENT_MODE
+
+
+def test_version_flag_prints_package_version(capsys) -> None:
+    with pytest.raises(SystemExit) as exc_info:
+        parse_args(["--version"])
+
+    assert exc_info.value.code == 0
+    assert f"kolega-code {__version__}" in capsys.readouterr().out
+
+
+def test_parse_tui_resume_latest() -> None:
+    args = parse_args(["/tmp/project", "--resume"])
+
+    assert args.command == "tui"
+    assert args.resume == RESUME_LATEST
+
+
+def test_parse_tui_resume_specific_thread() -> None:
+    args = parse_args(["/tmp/project", "--resume", "thread-123"])
+
+    assert args.command == "tui"
+    assert args.resume == "thread-123"
+
+
+def test_parse_tui_legacy_session_alias() -> None:
+    args = parse_args(["/tmp/project", "--session", "session-123"])
+
+    assert args.command == "tui"
+    assert args.session == "session-123"
+
+
+def test_parse_ask_subcommand() -> None:
+    args = parse_args(["ask", "hello", "--project", "/tmp/project", "--save", "--json"])
+
+    assert args.command == "ask"
+    assert args.prompt == "hello"
+    assert args.project == Path("/tmp/project")
+    assert args.save is True
+    assert args.json is True
+    assert args.mode == CLI_AGENT_MODE
+
+
+def test_parse_sessions_list_subcommand() -> None:
+    args = parse_args(["sessions", "list", "--project", "/tmp/project"])
+
+    assert args.command == "sessions"
+    assert args.sessions_command == "list"
+    assert args.project == Path("/tmp/project")
+
+
+def test_ask_skills_lists_discovered_skills_without_api_key(
+    tmp_path: Path, capsys, isolated_cli_env: None
+) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    write_skill(project)
+
+    exit_code = main(["ask", "/skills", "--project", str(project)])
+
+    assert exit_code == 0
+    output = capsys.readouterr().out
+    assert "`/demo-skill`" in output
+    assert "Use this demo skill." in output
+
+
+def test_ask_skill_only_prints_activation_without_model_call(
+    tmp_path: Path, capsys, isolated_cli_env: None
+) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    write_skill(project)
+
+    exit_code = main(["ask", "/demo-skill", "--project", str(project)])
+
+    assert exit_code == 0
+    output = capsys.readouterr().out
+    assert '<skill_content name="demo-skill">' in output
+    assert "Follow demo instructions." in output
+
+
+def test_ask_skill_with_prompt_activates_before_dispatch(
+    tmp_path: Path, capsys, monkeypatch: pytest.MonkeyPatch, isolated_cli_env: None
+) -> None:
+    from kolega_code.cli import main as main_module
+
+    class FakeCoderAgent:
+        instances = []
+
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+            self.history = []
+            self.messages = []
+            self.cleaned = False
+            self.__class__.instances.append(self)
+
+        def append_user_message(self, content):
+            self.history.append(Message(role="user", content=content))
+
+        def restore_message_history(self, history):
+            self.history = [Message.from_dict(item) for item in history]
+
+        def dump_message_history(self):
+            return [message.to_dict() for message in self.history]
+
+        async def process_message_stream(self, message):
+            self.messages.append(message)
+            yield {"type": "response", "content": "ok", "complete": True, "uuid": "response-1"}
+
+        async def cleanup(self):
+            self.cleaned = True
+
+    project = tmp_path / "project"
+    project.mkdir()
+    write_skill(project)
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "test-key")
+    monkeypatch.setattr(main_module, "CoderAgent", FakeCoderAgent)
+
+    exit_code = main_module.main(["ask", "/demo-skill do the task", "--project", str(project)])
+
+    assert exit_code == 0
+    output = capsys.readouterr().out
+    assert "ok" in output
+    agent = FakeCoderAgent.instances[0]
+    assert agent.messages == ["do the task"]
+    assert '<skill_content name="demo-skill">' in agent.history[0].get_text_content()
+    assert any(extension.name == "cli-agent-skills" for extension in agent.kwargs["tool_extensions"])
+
+
+def test_doctor_uses_stored_kimi_settings(tmp_path: Path, capsys, isolated_cli_env: None) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    state_dir = tmp_path / "state"
+    settings = CliSettings(active_provider=UI_DEFAULT_PROVIDER, active_model=UI_DEFAULT_MODEL)
+    settings.set_api_key(UI_DEFAULT_PROVIDER, "moonshot-key")
+    SettingsStore(state_dir).save(settings)
+
+    exit_code = main(["doctor", "--project", str(project), "--state-dir", str(state_dir)])
+
+    assert exit_code == 0
+    output = capsys.readouterr().out
+    assert f"Stored active model: {UI_DEFAULT_PROVIDER}/{UI_DEFAULT_MODEL}" in output
+    assert "present in local settings" in output
+    assert "moonshot-key" not in output
+
+
+def test_tui_default_creates_new_session_even_when_latest_exists(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    store = SessionStore(tmp_path / "state")
+    existing = store.create(project, "code", {})
+
+    session = _resolve_tui_session(store, project, {}, resume=None, legacy_session_id=None)
+
+    assert session.session_id != existing.session_id
+    assert session.thread_id != existing.thread_id
+    assert session.mode == CLI_AGENT_MODE
+
+
+def test_tui_resume_without_id_loads_latest_project_session(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    store = SessionStore(tmp_path / "state")
+    store.create(project, "code", {}, title="older")
+    newer = store.create(project, "code", {}, title="newer")
+
+    session = _resolve_tui_session(store, project, {}, resume=RESUME_LATEST, legacy_session_id=None)
+
+    assert session.session_id == newer.session_id
+    assert session.mode == CLI_AGENT_MODE
+    assert store.load(newer.session_id).mode == CLI_AGENT_MODE
+
+
+def test_tui_resume_specific_session_id(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    store = SessionStore(tmp_path / "state")
+    existing = store.create(project, "code", {})
+
+    session = _resolve_tui_session(store, project, {}, resume=existing.session_id, legacy_session_id=None)
+
+    assert session.session_id == existing.session_id
+    assert session.mode == CLI_AGENT_MODE
+    assert store.load(existing.session_id).mode == CLI_AGENT_MODE
+
+
+def test_tui_resume_specific_thread_id(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    store = SessionStore(tmp_path / "state")
+    existing = store.create(project, "code", {})
+
+    session = _resolve_tui_session(store, project, {}, resume=existing.thread_id, legacy_session_id=None)
+
+    assert session.session_id == existing.session_id
+    assert session.mode == CLI_AGENT_MODE
+
+
+def test_tui_resume_missing_id_raises(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    store = SessionStore(tmp_path / "state")
+
+    with pytest.raises(SessionStoreError):
+        _resolve_tui_session(store, project, {}, resume="missing-thread", legacy_session_id=None)
+
+
+def test_tui_resume_project_mismatch_raises(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    other_project = tmp_path / "other"
+    project.mkdir()
+    other_project.mkdir()
+    store = SessionStore(tmp_path / "state")
+    existing = store.create(other_project, "code", {})
+
+    with pytest.raises(SessionStoreError, match="belongs to project"):
+        _resolve_tui_session(store, project, {}, resume=existing.thread_id, legacy_session_id=None)
+
+
+def test_tui_legacy_session_alias_loads_specific_session(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    store = SessionStore(tmp_path / "state")
+    existing = store.create(project, "code", {})
+
+    session = _resolve_tui_session(
+        store,
+        project,
+        {},
+        resume=None,
+        legacy_session_id=existing.session_id,
+    )
+
+    assert session.session_id == existing.session_id
+    assert session.mode == CLI_AGENT_MODE
+
+
+def _sub_agent_test_event():
+    from kolega_code.events import AgentEvent
+
+    return AgentEvent(
+        event_type="chat_message",
+        sender="general-agent",
+        content={"status": "GENERATING", "message": "Starting general-agent task"},
+        sub_agent_info={
+            "agent_id": "agent-1",
+            "agent_name": "general-agent",
+            "task": "do sub-task",
+            "parent_tool_call_id": "exec-1",
+            "conversation_id": None,
+            "depth": 1,
+        },
+    )
+
+
+class _SubAgentEventCoderAgent:
+    """Fake CoderAgent that broadcasts a sub-agent event mid-stream."""
+
+    instances = []
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        self.history = []
+        self.__class__.instances.append(self)
+
+    def append_user_message(self, content):
+        self.history.append(content)
+
+    def restore_message_history(self, history):
+        return None
+
+    def dump_message_history(self):
+        return []
+
+    async def process_message_stream(self, message):
+        yield {"type": "response", "content": "first ", "complete": False, "uuid": "response-1"}
+        manager = self.kwargs["connection_manager"]
+        await manager.broadcast_event(_sub_agent_test_event(), "ws", "thread")
+        # Give the event pump a chance to run before the final chunk
+        for _ in range(5):
+            await asyncio.sleep(0)
+        yield {"type": "response", "content": "second", "complete": True, "uuid": "response-1"}
+
+    async def cleanup(self):
+        return None
+
+
+def test_ask_json_interleaves_sub_agent_events(
+    tmp_path: Path, capsys, monkeypatch: pytest.MonkeyPatch, isolated_cli_env: None
+) -> None:
+    from kolega_code.cli import main as main_module
+
+    _SubAgentEventCoderAgent.instances = []
+    project = tmp_path / "project"
+    project.mkdir()
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "test-key")
+    monkeypatch.setattr(main_module, "CoderAgent", _SubAgentEventCoderAgent)
+
+    exit_code = main_module.main(["ask", "do the task", "--project", str(project), "--json"])
+
+    assert exit_code == 0
+    lines = [json.loads(line) for line in capsys.readouterr().out.splitlines() if line.strip()]
+    kinds = [line["kind"] for line in lines]
+    event_index = kinds.index("event")
+    final_chunk_index = max(i for i, line in enumerate(lines) if line["kind"] == "chunk")
+    assert event_index < final_chunk_index, "sub-agent event should interleave before the final chunk"
+    event_line = lines[event_index]
+    assert event_line["data"]["sub_agent_info"]["agent_name"] == "general-agent"
+
+
+def test_ask_plain_writes_sub_agent_lifecycle_to_stderr(
+    tmp_path: Path, capsys, monkeypatch: pytest.MonkeyPatch, isolated_cli_env: None
+) -> None:
+    from kolega_code.cli import main as main_module
+
+    _SubAgentEventCoderAgent.instances = []
+    project = tmp_path / "project"
+    project.mkdir()
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "test-key")
+    monkeypatch.setattr(main_module, "CoderAgent", _SubAgentEventCoderAgent)
+
+    exit_code = main_module.main(["ask", "do the task", "--project", str(project)])
+
+    assert exit_code == 0
+    captured = capsys.readouterr()
+    assert captured.out.strip() == "first second"
+    from kolega_code.cli import theme
+
+    sep = theme.g(theme.Glyph.BULLET_SEP)
+    glyph = theme.g(theme.Glyph.SUB_AGENT)
+    assert f"{glyph} general-agent {sep} generating {sep} Starting general-agent task" in captured.err
+
+
+def test_ask_prompt_with_file_mention_attaches_content(
+    tmp_path: Path, capsys, monkeypatch: pytest.MonkeyPatch, isolated_cli_env: None
+) -> None:
+    from kolega_code.cli import main as main_module
+
+    class FakeCoderAgent:
+        instances = []
+
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+            self.history = []
+            self.messages = []
+            self.attachments = []
+            self.__class__.instances.append(self)
+
+        def append_user_message(self, content):
+            self.history.append(Message(role="user", content=content))
+
+        def restore_message_history(self, history):
+            self.history = [Message.from_dict(item) for item in history]
+
+        def dump_message_history(self):
+            return [message.to_dict() for message in self.history]
+
+        async def process_message_stream(self, message, attachments=None):
+            self.messages.append(message)
+            self.attachments.append(attachments)
+            yield {"type": "response", "content": "ok", "complete": True, "uuid": "response-1"}
+
+        async def cleanup(self):
+            return None
+
+    project = tmp_path / "project"
+    project.mkdir()
+    (project / "notes.md").write_text("remember the milk\n", encoding="utf-8")
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "test-key")
+    monkeypatch.setattr(main_module, "CoderAgent", FakeCoderAgent)
+
+    exit_code = main_module.main(["ask", "summarize @notes.md", "--project", str(project)])
+
+    assert exit_code == 0
+    assert "ok" in capsys.readouterr().out
+    agent = FakeCoderAgent.instances[0]
+    assert agent.messages == ["summarize @notes.md"]
+    attachments = agent.attachments[0]
+    assert attachments is not None and len(attachments) == 1
+    assert attachments[0]["type"] == "file"
+    assert attachments[0]["path"] == "notes.md"
+    assert attachments[0]["content"] == "remember the milk\n"
+
+
+def test_ask_prompt_with_unresolved_mention_warns_on_stderr(
+    tmp_path: Path, capsys, monkeypatch: pytest.MonkeyPatch, isolated_cli_env: None
+) -> None:
+    from kolega_code.cli import main as main_module
+
+    class FakeCoderAgent:
+        instances = []
+
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+            self.history = []
+            self.attachments = []
+            self.__class__.instances.append(self)
+
+        def append_user_message(self, content):
+            self.history.append(Message(role="user", content=content))
+
+        def restore_message_history(self, history):
+            self.history = [Message.from_dict(item) for item in history]
+
+        def dump_message_history(self):
+            return [message.to_dict() for message in self.history]
+
+        async def process_message_stream(self, message, attachments=None):
+            self.attachments.append(attachments)
+            yield {"type": "response", "content": "ok", "complete": True, "uuid": "response-1"}
+
+        async def cleanup(self):
+            return None
+
+    project = tmp_path / "project"
+    project.mkdir()
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "test-key")
+    monkeypatch.setattr(main_module, "CoderAgent", FakeCoderAgent)
+
+    exit_code = main_module.main(["ask", "summarize @missing.md", "--project", str(project)])
+
+    assert exit_code == 0
+    captured = capsys.readouterr()
+    assert "@missing.md not found" in captured.err
+    assert FakeCoderAgent.instances[0].attachments == [None]

kolega_code/cli/tests/test_mentions.py

@@ -0,0 +1,108 @@
+"""Tests for @ mention parsing and file attachment expansion."""
+
+from pathlib import Path
+
+from kolega_code.cli.mentions import (
+    MAX_ATTACHMENT_LINES,
+    MAX_DIR_ENTRIES,
+    build_file_attachments,
+    parse_mentions,
+)
+
+
+def test_parse_mentions_requires_start_or_whitespace() -> None:
+    assert parse_mentions("email user@example.com please") == []
+    assert [m.path for m in parse_mentions("@a.py and @b.py")] == ["a.py", "b.py"]
+    assert [m.path for m in parse_mentions("look at @src/main.py")] == ["src/main.py"]
+
+
+def test_parse_mentions_strips_trailing_punctuation() -> None:
+    assert [m.path for m in parse_mentions("see @src/main.py, and @README.md.")] == ["src/main.py", "README.md"]
+    assert [m.path for m in parse_mentions("(@notes.txt)")] == []  # @ after ( is not a mention
+    assert [m.path for m in parse_mentions("read @notes.txt)")] == ["notes.txt"]
+
+
+def test_parse_mentions_supports_quoted_paths() -> None:
+    assert [m.path for m in parse_mentions('open @"my docs/plan.md" now')] == ["my docs/plan.md"]
+
+
+def test_build_file_attachments_reads_existing_file(tmp_path: Path) -> None:
+    (tmp_path / "hello.py").write_text("print('hi')\n", encoding="utf-8")
+    attachments, unresolved = build_file_attachments("check @hello.py", tmp_path)
+    assert unresolved == []
+    assert len(attachments) == 1
+    assert attachments[0]["type"] == "file"
+    assert attachments[0]["path"] == "hello.py"
+    assert attachments[0]["content"] == "print('hi')\n"
+    assert attachments[0]["truncated"] is False
+    assert attachments[0]["is_dir"] is False
+
+
+def test_build_file_attachments_nonexistent_path_is_unresolved(tmp_path: Path) -> None:
+    attachments, unresolved = build_file_attachments("check @missing.py", tmp_path)
+    assert attachments == []
+    assert unresolved == ["missing.py"]
+
+
+def test_build_file_attachments_dedupes_repeat_mentions(tmp_path: Path) -> None:
+    (tmp_path / "a.txt").write_text("x", encoding="utf-8")
+    attachments, _ = build_file_attachments("@a.txt and @a.txt again", tmp_path)
+    assert len(attachments) == 1
+
+
+def test_build_file_attachments_truncates_long_files(tmp_path: Path) -> None:
+    (tmp_path / "big.txt").write_text("line\n" * (MAX_ATTACHMENT_LINES + 50), encoding="utf-8")
+    attachments, _ = build_file_attachments("@big.txt", tmp_path)
+    assert attachments[0]["truncated"] is True
+    assert "[truncated: showing first" in attachments[0]["content"]
+
+
+def test_build_file_attachments_binary_file_gets_stub(tmp_path: Path) -> None:
+    (tmp_path / "blob.dat").write_bytes(b"\x00\x01\x02binary")
+    attachments, _ = build_file_attachments("@blob.dat", tmp_path)
+    assert attachments[0]["content"] == "[binary file - content not attached]"
+
+
+def test_build_file_attachments_allows_gitignored_files(tmp_path: Path) -> None:
+    (tmp_path / ".gitignore").write_text("secret.txt\n", encoding="utf-8")
+    (tmp_path / "secret.txt").write_text("hidden", encoding="utf-8")
+    attachments, unresolved = build_file_attachments("@secret.txt", tmp_path)
+    assert unresolved == []
+    assert attachments[0]["content"] == "hidden"
+
+
+def test_build_file_attachments_directory_shallow_listing(tmp_path: Path) -> None:
+    pkg = tmp_path / "pkg"
+    (pkg / "sub").mkdir(parents=True)
+    (pkg / "mod.py").write_text("", encoding="utf-8")
+    attachments, _ = build_file_attachments("@pkg/", tmp_path)
+    assert attachments[0]["is_dir"] is True
+    assert attachments[0]["path"] == "pkg"
+    assert "sub/" in attachments[0]["content"]
+    assert "mod.py" in attachments[0]["content"]
+
+
+def test_build_file_attachments_directory_listing_is_capped(tmp_path: Path) -> None:
+    crowd = tmp_path / "crowd"
+    crowd.mkdir()
+    for index in range(MAX_DIR_ENTRIES + 10):
+        (crowd / f"f{index:04}.txt").write_text("", encoding="utf-8")
+    attachments, _ = build_file_attachments("@crowd", tmp_path)
+    assert f"[truncated: showing first {MAX_DIR_ENTRIES} of {MAX_DIR_ENTRIES + 10} entries]" in attachments[0]["content"]
+
+
+def test_build_file_attachments_rejects_paths_outside_root(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    outside = tmp_path / "outside.txt"
+    outside.write_text("nope", encoding="utf-8")
+    attachments, unresolved = build_file_attachments(f"@{outside}", project)
+    assert attachments == []
+    assert unresolved == [str(outside)]
+
+
+def test_build_file_attachments_accepts_absolute_path_inside_root(tmp_path: Path) -> None:
+    (tmp_path / "inside.txt").write_text("yes", encoding="utf-8")
+    attachments, unresolved = build_file_attachments(f"@{tmp_path / 'inside.txt'}", tmp_path)
+    assert unresolved == []
+    assert attachments[0]["path"] == "inside.txt"

kolega_code/cli/tests/test_session_store.py

@@ -0,0 +1,67 @@
+from pathlib import Path
+import json
+
+import pytest
+
+from kolega_code.cli.session_store import SessionStore, SessionStoreError, default_state_dir
+
+
+def test_default_state_dir_honors_env() -> None:
+    assert default_state_dir({"KOLEGA_CODE_STATE_DIR": "/tmp/kolega-test"}) == Path("/tmp/kolega-test")
+
+
+def test_session_store_create_load_list_export_delete(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    store = SessionStore(tmp_path / "state")
+
+    record = store.create(project, "code", {"long_model": "claude-opus-4-7"}, title="Project")
+    record.history = [{"role": "user", "content": []}]
+    record.task_list_markdown = "- [ ] inspect\n- [x] plan"
+    record.latest_plan_markdown = "# Plan\n\nImplement it."
+    record.interaction_mode = "plan"
+    store.save(record)
+
+    loaded = store.load(record.session_id)
+    assert loaded.project_path == str(project.resolve())
+    assert loaded.history == [{"role": "user", "content": []}]
+    assert loaded.task_list_markdown == "- [ ] inspect\n- [x] plan"
+    assert loaded.latest_plan_markdown == "# Plan\n\nImplement it."
+    assert loaded.interaction_mode == "plan"
+    assert store.latest_for_project(project).session_id == record.session_id
+    exported = store.export(record.session_id)
+    assert record.session_id in exported
+    assert "task_list_markdown" in exported
+    assert "latest_plan_markdown" in exported
+    assert "interaction_mode" in exported
+
+    store.delete(record.session_id)
+    with pytest.raises(SessionStoreError):
+        store.load(record.session_id)
+
+
+def test_session_store_loads_old_sessions_without_planning_state(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    project.mkdir()
+    store = SessionStore(tmp_path / "state")
+
+    record = store.create(project, "code", {})
+    payload = record.to_dict()
+    payload.pop("task_list_markdown")
+    payload.pop("latest_plan_markdown")
+    payload.pop("interaction_mode")
+    store.path_for(record.session_id).write_text(json.dumps(payload), encoding="utf-8")
+
+    loaded = store.load(record.session_id)
+
+    assert loaded.task_list_markdown == ""
+    assert loaded.latest_plan_markdown == ""
+    assert loaded.interaction_mode == "build"
+
+
+def test_session_store_ignores_corrupt_files_when_listing(tmp_path: Path) -> None:
+    store = SessionStore(tmp_path / "state")
+    store.ensure_dirs()
+    (store.sessions_dir / "bad.json").write_text("{not json", encoding="utf-8")
+
+    assert store.list() == []

kolega_code/cli/tests/test_settings.py

@@ -0,0 +1,62 @@
+import os
+import stat
+from pathlib import Path
+
+import pytest
+
+from kolega_code.cli.provider_registry import (
+    DEEPSEEK_DEFAULT_MODEL,
+    UI_DEFAULT_MODEL,
+    UI_DEFAULT_PROVIDER,
+    get_ui_model,
+    ui_model_options,
+    ui_provider_options,
+)
+from kolega_code.cli.settings import CliSettings, SettingsStore, SettingsStoreError
+
+
+def test_settings_store_round_trip_and_file_permissions(tmp_path: Path) -> None:
+    store = SettingsStore(tmp_path)
+    settings = CliSettings(active_provider=UI_DEFAULT_PROVIDER, active_model=UI_DEFAULT_MODEL)
+    settings.set_api_key(UI_DEFAULT_PROVIDER, "secret-key")
+
+    store.save(settings)
+
+    loaded = store.load()
+    assert loaded.active_provider == UI_DEFAULT_PROVIDER
+    assert loaded.active_model == UI_DEFAULT_MODEL
+    assert loaded.get_api_key(UI_DEFAULT_PROVIDER) == "secret-key"
+
+    if os.name != "nt":
+        assert stat.S_IMODE(store.path.stat().st_mode) == 0o600
+
+
+def test_settings_store_missing_file_returns_empty_settings(tmp_path: Path) -> None:
+    settings = SettingsStore(tmp_path).load()
+
+    assert settings.active_provider is None
+    assert settings.active_model is None
+    assert settings.api_keys == {}
+
+
+def test_settings_store_rejects_corrupt_json(tmp_path: Path) -> None:
+    store = SettingsStore(tmp_path)
+    store.root.mkdir(parents=True, exist_ok=True)
+    store.path.write_text("{bad json", encoding="utf-8")
+
+    with pytest.raises(SettingsStoreError):
+        store.load()
+
+
+def test_ui_provider_registry_supports_kimi_and_deepseek() -> None:
+    assert ui_provider_options() == [("Moonshot AI", UI_DEFAULT_PROVIDER), ("DeepSeek AI", "deepseek")]
+    assert ui_model_options(UI_DEFAULT_PROVIDER) == [("Kimi K2.6", UI_DEFAULT_MODEL)]
+    assert ui_model_options("deepseek") == [("DeepSeek V4 Pro", DEEPSEEK_DEFAULT_MODEL)]
+
+    model = get_ui_model(UI_DEFAULT_PROVIDER, UI_DEFAULT_MODEL)
+    assert model is not None
+    assert model.api_key_env == "MOONSHOT_API_KEY"
+
+    deepseek_model = get_ui_model("deepseek", DEEPSEEK_DEFAULT_MODEL)
+    assert deepseek_model is not None
+    assert deepseek_model.api_key_env == "DEEPSEEK_API_KEY"