kiwi-code 0.0.42__tar.gz → 0.0.431__tar.gz

{kiwi_code-0.0.42 → kiwi_code-0.0.431}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.42
+Version: 0.0.431
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code

{kiwi_code-0.0.42 → kiwi_code-0.0.431}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.42"
+version = "0.0.431"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

{kiwi_code-0.0.42 → kiwi_code-0.0.431}/src/kiwi_tui/main.py

@@ -1109,6 +1109,20 @@ def main() -> int:
         action="store_true",
         help="Run Kiwi in plain terminal mode instead of launching the full-screen TUI.",
     )
+    parser.add_argument(
+        "-w",
+        "--worktree",
+        "-worktree",
+        nargs="?",
+        const="",
+        default=None,
+        metavar="NAME",
+        help=(
+            "Create (or reuse) an isolated git worktree under .kiwi/worktrees/NAME "
+            "and run Kiwi inside it. If NAME is omitted, Kiwi generates one."
+        ),
+    )
+
     parser.add_argument("--action-id", default=None, help="Start a fresh conversation for a specific action.")
     parser.add_argument("--run-id", default=None, help="Continue an existing run.")
     parser.add_argument(
@@ -1126,6 +1140,29 @@ def main() -> int:
 
     args = parser.parse_args(argv)
 
+    if getattr(args, "worktree", None) is not None:
+        try:
+            from kiwi_tui.worktrees import WorktreeError, ensure_worktree
+
+            worktree_name = str(getattr(args, "worktree", "") or "").strip() or None
+            worktree_path, _branch = ensure_worktree(worktree_name)
+            if not worktree_path.exists():
+                raise WorktreeError(
+                    f"Worktree directory does not exist after creation: {worktree_path}",
+                    hint="Run `git worktree prune` and retry, or choose a different worktree name.",
+                )
+            os.chdir(str(worktree_path))
+        except WorktreeError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            return 1
+        except Exception as e:
+            print(
+                f"Error: Unexpected error while creating/entering the worktree: {e}",
+                file=sys.stderr,
+            )
+            return 1
+
+
     runtime_args = _build_runtime_args(args)
     if args.terminal:
         return run_terminal_mode(

{kiwi_code-0.0.42 → kiwi_code-0.0.431}/src/kiwi_tui/screens/dashboard.py

@@ -138,6 +138,7 @@ class DashboardScreen(Screen):
         "69c2180355a89324a9926bc6",
         "6a0625b8ab5f80ba8ac5d012",
         "69e4be0d70c2d7a89197e66e",
+        "6a1c0773c519da8a0fa9b8a4",
     ]
 
     BINDINGS = [

kiwi_code-0.0.431/src/kiwi_tui/worktrees.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import re
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Sequence
+
+from wonderwords import RandomWord
+
+
+class WorktreeError(RuntimeError):
+    """User-facing error for `kiwi --worktree` failures.
+
+    Note: do NOT use a frozen dataclass here — Python sets exception traceback
+    attributes during propagation, and frozen dataclasses can break that.
+    """
+
+    def __init__(self, message: str, *, details: str | None = None, hint: str | None = None):
+        super().__init__(message)
+        self.message = message
+        self.details = details
+        self.hint = hint
+
+    def __str__(self) -> str:  # pragma: no cover (formatting is stable)
+        parts: list[str] = [str(self.message or "").strip()]
+        if self.details:
+            parts.append(str(self.details).strip())
+        if self.hint:
+            parts.append(f"Hint: {str(self.hint).strip()}")
+        return "\n".join(part for part in parts if part)
+
+def generate_worktree_name() -> str:
+    """Generate a worktree name similar to Claude Code (adj-verb-noun)."""
+
+    try:
+        r = RandomWord()
+        adjective = r.word(include_parts_of_speech=["adjectives"]) or "bright"
+        verb = r.word(include_parts_of_speech=["verbs"]) or "running"
+        noun = r.word(include_parts_of_speech=["nouns"]) or "fox"
+        return f"{adjective}-{verb}-{noun}".lower().replace(" ", "-")
+    except Exception:
+        # Safety fallback: no external data / unexpected packaging issues.
+        return "bright-running-fox"
+
+
+def ensure_worktree(name: str | None, *, cwd: Path | None = None) -> tuple[Path, str]:
+    """Ensure a worktree exists under <repo>/.kiwi/worktrees/<name>.
+
+    Returns (worktree_path, branch_name).
+
+    Behavior mirrors Claude Code's `--worktree` defaults as closely as possible,
+    except we use the provided NAME as the branch name directly:
+    - Worktree directory: .kiwi/worktrees/<name>/ at repo root
+    - Branch name: <name>
+    - Base ref: origin/HEAD if `git fetch origin` succeeds, else local HEAD
+    """
+
+    if not shutil.which("git"):
+        raise WorktreeError(
+            "Unable to create worktree because `git` was not found on PATH.",
+            hint="Install Git and ensure the `git` command is available.",
+        )
+
+    start_cwd = Path(cwd or os.getcwd())
+    root_proc = _run_git(["rev-parse", "--show-toplevel"], cwd=start_cwd, check=False)
+    if root_proc.returncode != 0:
+        stderr = (root_proc.stderr or "").strip()
+        raise WorktreeError(
+            "Worktree mode requires running inside a git repository.",
+            details=stderr or None,
+            hint="Run `kiwi -w <name>` from within a git checkout.",
+        )
+    repo_root = (root_proc.stdout or "").strip()
+    if not repo_root:
+        raise WorktreeError("Unable to locate the git repository root.")
+
+    repo_root_path = Path(repo_root)
+    worktrees_root = repo_root_path / ".kiwi" / "worktrees"
+    try:
+        worktrees_root.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        raise WorktreeError(
+            f"Unable to create worktree root directory at {worktrees_root}.",
+            details=str(e),
+        )
+
+    if not name:
+        name = generate_worktree_name()
+
+    worktree_path = (worktrees_root / name).resolve()
+    _assert_within_dir(worktree_path, worktrees_root.resolve())
+
+    # If already registered as a git worktree, re-use.
+    # (Guard against stale worktree metadata: the path can exist in `git worktree list`
+    # even if the directory was deleted manually.)
+    existing = _list_worktree_paths(repo_root_path)
+    existing = _list_worktree_paths(repo_root_path)
+    if any(p.resolve() == worktree_path for p in existing):
+        if worktree_path.exists():
+            if not worktree_path.is_dir():
+                raise WorktreeError(
+                    f"Worktree path exists but is not a directory: {worktree_path}",
+                )
+            current_branch = _current_branch(worktree_path)
+            if current_branch != name:
+                pretty_current = current_branch if current_branch != "HEAD" else "(detached HEAD)"
+                raise WorktreeError(
+                    f"Worktree folder {worktree_path} is currently on branch {pretty_current}, expected {name}.",
+                    hint="Switch the worktree back to the expected branch, or choose a different -w name.",
+                )
+            return worktree_path, name
+        # Worktree is registered but missing on disk. Prune and retry once.
+        _run_git(["worktree", "prune"], cwd=repo_root_path, check=False)
+        existing = _list_worktree_paths(repo_root_path)
+        if any(p.resolve() == worktree_path for p in existing):
+            raise WorktreeError(
+                f"Worktree is registered with git but missing on disk: {worktree_path}",
+                hint="Run `git worktree prune` (or `git worktree remove <path>`) then re-run kiwi -w.",
+            )
+    if worktree_path.exists():
+        raise WorktreeError(
+            f"Worktree directory already exists but is not registered with git: {worktree_path}",
+            hint="Remove the directory or choose a different worktree name.",
+        )
+
+    # Claude Code branches from origin/HEAD if fetch succeeds.
+    base_ref = "HEAD"
+    fetch = _run_git(["fetch", "origin"], cwd=repo_root_path, check=False)
+    if fetch.returncode == 0:
+        verify = _run_git(["rev-parse", "--verify", "origin/HEAD"], cwd=repo_root_path, check=False)
+        if verify.returncode == 0:
+            base_ref = "origin/HEAD"
+
+    # Ensure we have at least one commit.
+    head_verify = _run_git(["rev-parse", "--verify", "HEAD"], cwd=repo_root_path, check=False)
+    if head_verify.returncode != 0:
+        raise WorktreeError(
+            "This repository has no commits yet, so a worktree cannot be created.",
+            hint="Create an initial commit (e.g. add a README and commit) and try again.",
+        )
+
+    branch = name
+    branch_exists = (
+        _run_git(["show-ref", "--verify", f"refs/heads/{branch}"], cwd=repo_root_path, check=False).returncode
+        == 0
+    )
+
+    add_cmd: list[str]
+    if branch_exists:
+        add_cmd = ["worktree", "add", str(worktree_path), branch]
+    else:
+        # If a remote branch exists (common case), create a local tracking branch from it.
+        remote_ref = f"refs/remotes/origin/{branch}"
+        remote_exists = (
+            _run_git(["show-ref", "--verify", remote_ref], cwd=repo_root_path, check=False).returncode == 0
+        )
+        if remote_exists:
+            add_cmd = [
+                "worktree",
+                "add",
+                "--track",
+                "-b",
+                branch,
+                str(worktree_path),
+                f"origin/{branch}",
+            ]
+        else:
+            add_cmd = ["worktree", "add", str(worktree_path), "-b", branch, base_ref]
+
+    add_proc = _run_git(add_cmd, cwd=repo_root_path, check=False)
+
+    if add_proc.returncode != 0:
+        stderr = (add_proc.stderr or "").strip()
+        stdout = (add_proc.stdout or "").strip()
+
+        # Auto-heal stale worktree metadata if git claims the branch is checked out
+        # at a missing Kiwi-managed worktree path.
+        stale_path = _extract_stale_checked_out_path(stderr) if stderr else None
+        if stale_path:
+            stale = Path(stale_path)
+            kiwi_root = (repo_root_path / ".kiwi" / "worktrees").resolve()
+            if not stale.exists():
+                try:
+                    stale_resolved = stale.resolve()
+                except Exception:
+                    stale_resolved = stale
+                try:
+                    stale_resolved.relative_to(kiwi_root)
+                    is_kiwi_managed = True
+                except Exception:
+                    is_kiwi_managed = False
+                if is_kiwi_managed:
+                    _run_git(["worktree", "prune"], cwd=repo_root_path, check=False)
+                    add_proc = _run_git(add_cmd, cwd=repo_root_path, check=False)
+                    if add_proc.returncode == 0:
+                        return worktree_path, branch
+                    stderr = (add_proc.stderr or "").strip()
+                    stdout = (add_proc.stdout or "").strip()
+
+        details = "\n".join(part for part in [stderr, stdout] if part) or None
+        hint = None
+        if stderr and ("is already checked out at" in stderr or "used by worktree at" in stderr):
+            hint = (
+                "That branch is already checked out in another worktree. "
+                "Choose a different branch name, or remove the other worktree (git worktree list/remove)."
+            )
+        raise WorktreeError(
+            f"Unable to create the git worktree at {worktree_path}.",
+            details=details,
+            hint=hint,
+        )
+
+    return worktree_path, branch
+
+
+def _assert_within_dir(path: Path, root: Path) -> None:
+    try:
+        path.relative_to(root)
+    except Exception:
+        raise WorktreeError(
+            f"Invalid worktree name/path resolved outside {root}: {path}",
+            hint="Avoid using '..' or absolute paths in the worktree name.",
+        )
+
+
+
+def _extract_stale_checked_out_path(stderr: str) -> str | None:
+    """Extract the worktree path from common git "already checked out" errors."""
+    if not stderr:
+        return None
+    patterns = (
+        r"checked out at '([^']+)'",
+        r"checked out at \"([^\"]+)\"",
+        r"used by worktree at '([^']+)'",
+        r"used by worktree at \"([^\"]+)\"",
+        r"worktree at '([^']+)'",
+        r"worktree at \"([^\"]+)\"",
+    )
+    for pat in patterns:
+        m = re.search(pat, stderr)
+        if m:
+            return m.group(1)
+    return None
+
+
+def _current_branch(worktree_path: Path) -> str:
+    """Return the current branch name for a worktree path.
+
+    Returns "HEAD" when the worktree is detached.
+    """
+    proc = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd=worktree_path, check=False)
+    if proc.returncode != 0:
+        stderr = (proc.stderr or "").strip()
+        raise WorktreeError(
+            f"Unable to determine the current branch for worktree at {worktree_path}.",
+            details=stderr or None,
+            hint="The worktree may be corrupted. Try `git worktree prune` and retry.",
+        )
+    branch = (proc.stdout or "").strip()
+    if not branch:
+        raise WorktreeError(
+            f"Unable to determine the current branch for worktree at {worktree_path}.",
+            hint="The worktree may be corrupted. Try `git worktree prune` and retry.",
+        )
+    return branch
+
+def _list_worktree_paths(repo_root: Path) -> list[Path]:
+    proc = _run_git(["worktree", "list", "--porcelain"], cwd=repo_root, check=True)
+    paths: list[Path] = []
+    for line in (proc.stdout or "").splitlines():
+        line = line.strip()
+        if line.startswith("worktree "):
+            p = line[len("worktree ") :].strip()
+            if p:
+                paths.append(Path(p))
+    return paths
+
+
+def _git_stdout(args: Sequence[str], *, cwd: Path) -> str:
+    proc = _run_git(list(args), cwd=cwd, check=True)
+    return proc.stdout or ""
+
+
+def _run_git(args: Sequence[str], *, cwd: Path, check: bool) -> subprocess.CompletedProcess[str]:
+    cmd = ["git", *args]
+    try:
+        proc = subprocess.run(
+            cmd,
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError:
+        raise WorktreeError(
+            "Unable to run git commands because `git` was not found on PATH.",
+            hint="Install Git and ensure the `git` command is available.",
+        )
+    except Exception as e:
+        raise WorktreeError(
+            f"Unable to run git command: {' '.join(cmd)}",
+            details=str(e),
+        )
+
+    if check and proc.returncode != 0:
+        stderr = (proc.stderr or "").strip()
+        stdout = (proc.stdout or "").strip()
+        details = "\n".join(part for part in [stderr, stdout] if part)
+        raise WorktreeError(
+            f"Git command failed (exit {proc.returncode}): {' '.join(cmd)}",
+            details=details or None,
+        )
+
+    return proc

{kiwi_code-0.0.42 → kiwi_code-0.0.431}/tests/test_cli_help.py

@@ -51,6 +51,9 @@ def test_kiwi_tui_help_exits_zero(isolated_home: Path) -> None:
     r = _run("kiwi_tui.main", "--help")
     assert r.returncode == 0, r.stderr
     assert "kiwi" in (r.stdout + r.stderr).lower()
+    combined = (r.stdout + r.stderr).lower()
+    assert "--worktree" in combined
+    assert "-w" in combined
 
 
 def test_kiwi_terminal_help_exits_zero(isolated_home: Path) -> None:

{kiwi_code-0.0.42 → kiwi_code-0.0.431}/tests/test_tui_headless.py

@@ -701,7 +701,7 @@ async def test_tui_continue_run_updates_action_name_from_run(
 async def test_tui_autocode_select_shows_only_special_action_names(
     isolated_home: Path, monkeypatch: pytest.MonkeyPatch
  ) -> None:
-    """/autocode-select should open the picker with only the 3 special actions."""
+    """/autocode-select should open the picker with only the 4 special actions."""
     tokens_path = isolated_home / ".kiwi" / "tokens.json"
     tokens_path.parent.mkdir(parents=True, exist_ok=True)
     tokens_path.write_text(
@@ -720,6 +720,7 @@ async def test_tui_autocode_select_shows_only_special_action_names(
         "69c2180355a89324a9926bc6": "AutoCode Alpha",
         "6a0625b8ab5f80ba8ac5d012": "AutoCode Beta",
         "69e4be0d70c2d7a89197e66e": "AutoCode Gamma",
+        "6a1c0773c519da8a0fa9b8a4": "AutoCode Delta",
     }
 
     from kiwi_tui.screens.dashboard import DashboardScreen
@@ -753,10 +754,11 @@ async def test_tui_autocode_select_shows_only_special_action_names(
 
         assert type(app.screen).__name__ == "IdPickerScreen"
         table = app.screen.query_one("#idpicker-table", DataTable)
-        assert table.row_count == 3
+        assert table.row_count == 4
         assert list(table.get_row_at(0)) == ["1", "AutoCode Alpha"]
         assert list(table.get_row_at(1)) == ["2", "AutoCode Beta"]
         assert list(table.get_row_at(2)) == ["3", "AutoCode Gamma"]
+        assert list(table.get_row_at(3)) == ["4", "AutoCode Delta"]
 
 
 
@@ -853,8 +855,6 @@ async def test_tui_streaming_requests_autofollow_when_viewport_is_near_bottom(
         )
         await pilot.pause()
         assert calls == [{"after_refresh": True}]
-
-
 @pytest.mark.asyncio
 async def test_tui_streaming_does_not_force_scroll_when_user_reads_older_messages(
     isolated_home: Path,
@@ -881,45 +881,271 @@ async def test_tui_streaming_does_not_force_scroll_when_user_reads_older_message
         await pilot.pause()
         assert type(app.screen).__name__ == "DashboardScreen"
         screen = app.screen
-        messages = screen.query_one("#messages")
 
-        for i in range(30):
-            screen.add_message(
-                "\n".join(f"history {i} line {j}" for j in range(4)),
-                "assistant",
+        calls: list[dict] = []
+        monkeypatch = pytest.MonkeyPatch()
+        monkeypatch.setattr(screen, "_messages_is_near_bottom", lambda *args, **kwargs: False)
+        monkeypatch.setattr(
+            screen,
+            "_scroll_messages_to_end",
+            lambda *args, **kwargs: calls.append(dict(kwargs)),
+        )
+        try:
+            widget = screen.update_streaming_message({"blocks": [{"text": "stream start"}]})
+            await pilot.pause()
+            assert widget is not None
+            assert calls == []
+
+            screen.update_streaming_message(
+                {"blocks": [{"text": "\n".join(f"stream line {i}" for i in range(60))}]},
+                widget,
             )
+            await pilot.pause()
+            assert calls == []
+        finally:
+            monkeypatch.undo()
+
+@pytest.mark.asyncio
+async def test_tui_quits_cleanly(isolated_home: Path) -> None:
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
         await pilot.pause()
-        assert messages.max_scroll_y > 0
+        await pilot.press("ctrl+c")
+        await pilot.pause()
+    # Reaching here without an exception is the assertion.
 
-        widget = screen.update_streaming_message({"blocks": [{"text": "stream start"}]})
+
+@pytest.mark.asyncio
+async def test_tui_redirects_to_login_when_auth_expires(isolated_home: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
         await pilot.pause()
-        assert widget is not None
+        assert type(app.screen).__name__ == "DashboardScreen"
 
-        target_y = max(0, int(messages.max_scroll_y) - 5)
-        messages.scroll_to(y=target_y, animate=False, immediate=True)
+        app._handle_auth_expired("Session expired during test.")
         await pilot.pause()
-        y_before = int(messages.scroll_offset.y)
-        target_before = int(messages.scroll_target_y)
-        assert y_before == target_before
-        assert y_before < int(messages.max_scroll_y)
 
-        screen.update_streaming_message(
-            {"blocks": [{"text": "\n".join(f"stream line {i}" for i in range(60))}]},
-            widget,
+        assert type(app.screen).__name__ == "LoginScreen"
+        assert not tokens_path.exists()
+
+
+@pytest.mark.asyncio
+async def test_tui_run_action_403_redirects_to_login_when_refresh_cannot_run(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        screen = app.screen
+
+        monkeypatch.setattr(app, "_refresh_token_if_needed", lambda force=False: False)
+        monkeypatch.setattr(
+            app.autobots_client,
+            "run_action_async",
+            lambda *args, **kwargs: (False, None, "Failed to start action: status 403"),
         )
+
+        screen.run_action_with_polling("hello")
+        await pilot.pause(0.3)
+        await pilot.pause(0.3)
+
+        assert type(app.screen).__name__ == "LoginScreen"
+        assert not tokens_path.exists()
+
+
+@pytest.mark.asyncio
+async def test_tui_run_action_403_redirects_to_login_on_second_failure(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+    async with app.run_test() as pilot:
         await pilot.pause()
+        assert type(app.screen).__name__ == "DashboardScreen"
+        screen = app.screen
+
+        monkeypatch.setattr(app, "_refresh_token_if_needed", lambda force=False: True)
+        monkeypatch.setattr(
+            app.autobots_client,
+            "run_action_async",
+            lambda *args, **kwargs: (False, None, "Failed to start action: status 403"),
+        )
+
+        screen.run_action_with_polling("hello")
+        await pilot.pause(0.3)
+        await pilot.pause(0.3)
+
+        assert type(app.screen).__name__ == "LoginScreen"
+        assert not tokens_path.exists()
+
+
+def test_tui_force_refresh_uses_refresh_token_even_when_access_token_not_expired(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": "2999-01-01T00:00:00",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from kiwi_cli.models import AuthTokens
+    from kiwi_tui.main import AutobotsTUI
+
+    app = AutobotsTUI()
+
+    calls: list[str] = []
+
+    def _fake_refresh(refresh_token: str):
+        calls.append(refresh_token)
+        return True, AuthTokens(
+            access_token="new-access-token",
+            refresh_token="new-refresh-token",
+            token_type="Bearer",
+            expires_at=None,
+        ), "ok"
+
+    monkeypatch.setattr(app.autobots_client, "refresh_token", _fake_refresh)
+
+    assert app._refresh_token_if_needed(force=True) is True
+    assert calls == ["test-refresh-token"]
 
-        assert int(messages.scroll_offset.y) == y_before
-        assert int(messages.scroll_target_y) == target_before
-        assert int(messages.scroll_offset.y) < int(messages.max_scroll_y)
 
 @pytest.mark.asyncio
-async def test_tui_quits_cleanly(isolated_home: Path) -> None:
+async def test_tui_auth_expired_clears_dashboard_draft_and_messages(
+    isolated_home: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    tokens_path = isolated_home / ".kiwi" / "tokens.json"
+    tokens_path.parent.mkdir(parents=True, exist_ok=True)
+    tokens_path.write_text(
+        json.dumps(
+            {
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token",
+                "token_type": "Bearer",
+                "expires_at": None,
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    from autobots_client.api.actions import get_action_v1_actions_id_get
+    monkeypatch.setattr(
+        get_action_v1_actions_id_get,
+        "sync_detailed",
+        lambda *, id, client: SimpleNamespace(
+            status_code=200,
+            parsed=SimpleNamespace(field_id=id, name="AutoCode Default"),
+        ),
+    )
+
+    from textual.containers import VerticalScroll
     from kiwi_tui.main import AutobotsTUI
+    from kiwi_tui.widgets import ChatInput
 
     app = AutobotsTUI()
     async with app.run_test() as pilot:
         await pilot.pause()
-        await pilot.press("ctrl+c")
+        assert type(app.screen).__name__ == "DashboardScreen"
+        dashboard = app.screen
+        chat_input = dashboard.query_one("#chat-input", ChatInput)
+        messages = dashboard.query_one("#messages", VerticalScroll)
+
+        chat_input.value = "hi"
+        dashboard.add_message("hi", "user")
         await pilot.pause()
-    # Reaching here without an exception is the assertion.
+        assert len(list(messages.children)) > 0
+
+        app._handle_auth_expired("Session expired during test.")
+        await pilot.pause()
+
+        assert chat_input.value == ""
+        assert len(list(messages.children)) == 0
+        assert type(app.screen).__name__ == "LoginScreen"

kiwi_code-0.0.431/tests/test_worktrees.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from kiwi_tui.worktrees import WorktreeError, ensure_worktree
+
+
+def _git(cwd: Path, *args: str) -> subprocess.CompletedProcess[str]:
+    env = os.environ.copy()
+    env.setdefault("GIT_AUTHOR_NAME", "Kiwi Test")
+    env.setdefault("GIT_AUTHOR_EMAIL", "kiwi-test@example.com")
+    env.setdefault("GIT_COMMITTER_NAME", "Kiwi Test")
+    env.setdefault("GIT_COMMITTER_EMAIL", "kiwi-test@example.com")
+    return subprocess.run(
+        ["git", *args],
+        cwd=str(cwd),
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_creates_under_dot_kiwi(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    r = _git(repo, "add", "README.md")
+    assert r.returncode == 0, r.stderr
+    r = _git(repo, "commit", "-m", "init")
+    assert r.returncode == 0, r.stderr
+
+    worktree_path, branch = ensure_worktree("feature-x", cwd=repo)
+    assert branch == "feature-x"
+
+    expected = (repo / ".kiwi" / "worktrees" / "feature-x").resolve()
+    assert worktree_path.resolve() == expected
+    assert worktree_path.exists()
+
+    head = subprocess.check_output(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=str(worktree_path),
+        text=True,
+    ).strip()
+    assert head == "feature-x"
+
+    # Should be registered with git.
+    wt_list = subprocess.check_output(
+        ["git", "worktree", "list", "--porcelain"],
+        cwd=str(repo),
+        text=True,
+    )
+    assert str(expected) in wt_list
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_reuses_existing(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    p1, _b1 = ensure_worktree("reuse-me", cwd=repo)
+    p2, _b2 = ensure_worktree("reuse-me", cwd=repo)
+    assert p1.resolve() == p2.resolve()
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_generates_name(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    monkeypatch.setattr("kiwi_tui.worktrees.generate_worktree_name", lambda: "bright-running-fox")
+    worktree_path, branch = ensure_worktree(None, cwd=repo)
+
+    assert branch == "bright-running-fox"
+    expected = (repo / ".kiwi" / "worktrees" / "bright-running-fox").resolve()
+    assert worktree_path.resolve() == expected
+
+
+def test_ensure_worktree_requires_git_repo(tmp_path: Path) -> None:
+    # Not a git repo.
+    with pytest.raises(WorktreeError) as exc:
+        ensure_worktree("x", cwd=tmp_path)
+
+    # Message should be user-facing.
+    assert "git" in str(exc.value).lower() or "repository" in str(exc.value).lower()
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_uses_remote_branch_when_local_missing(tmp_path: Path) -> None:
+    """If origin/<branch> exists but no local branch, create a tracking branch."""
+    remote = tmp_path / "remote.git"
+    remote.mkdir()
+    r = _git(remote, "init", "--bare")
+    assert r.returncode == 0, r.stderr
+
+    seed = tmp_path / "seed"
+    seed.mkdir()
+    r = _git(seed, "init", "-b", "main")
+    assert r.returncode == 0, r.stderr
+    (seed / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(seed, "add", "README.md").returncode == 0
+    assert _git(seed, "commit", "-m", "init").returncode == 0
+    assert _git(seed, "remote", "add", "origin", str(remote)).returncode == 0
+    assert _git(seed, "push", "-u", "origin", "main").returncode == 0
+    # Ensure the bare remote's HEAD points at main so clones have a valid HEAD.
+    assert _git(remote, "symbolic-ref", "HEAD", "refs/heads/main").returncode == 0
+
+
+    # Create and push a feature branch, then leave it as remote-only in the clone.
+    assert _git(seed, "checkout", "-b", "feature-remote").returncode == 0
+    (seed / "feature.txt").write_text("feature\n", encoding="utf-8")
+    assert _git(seed, "add", "feature.txt").returncode == 0
+    assert _git(seed, "commit", "-m", "feature").returncode == 0
+    assert _git(seed, "push", "-u", "origin", "feature-remote").returncode == 0
+
+    repo = tmp_path / "repo"
+    clone = subprocess.run(
+        ["git", "clone", str(remote), str(repo)],
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    assert clone.returncode == 0, clone.stderr
+
+    # Sanity: local branch should not exist yet.
+    assert _git(repo, "show-ref", "--verify", "refs/heads/feature-remote").returncode != 0
+    assert _git(repo, "show-ref", "--verify", "refs/remotes/origin/feature-remote").returncode == 0
+
+    worktree_path, branch = ensure_worktree("feature-remote", cwd=repo)
+    assert branch == "feature-remote"
+
+    head = subprocess.check_output(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=str(worktree_path),
+        text=True,
+    ).strip()
+    assert head == "feature-remote"
+
+    upstream = subprocess.check_output(
+        ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        cwd=str(worktree_path),
+        text=True,
+    ).strip()
+    assert upstream == "origin/feature-remote"
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_recovers_from_missing_dir(tmp_path: Path) -> None:
+    """If a worktree is registered but its directory was deleted, recover via prune."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    worktree_path, _branch = ensure_worktree("stale-branch", cwd=repo)
+    assert worktree_path.exists()
+
+    # Simulate user manually deleting the directory (leaving git's worktree metadata stale).
+    shutil.rmtree(worktree_path)
+    assert not worktree_path.exists()
+
+    worktree_path2, _branch2 = ensure_worktree("stale-branch", cwd=repo)
+    assert worktree_path2.resolve() == worktree_path.resolve()
+    assert worktree_path2.exists()
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_errors_if_existing_folder_on_wrong_branch(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    # Create both branches without checking them out in the main worktree.
+    assert _git(repo, "branch", "branch-a").returncode == 0
+    assert _git(repo, "branch", "branch-b").returncode == 0
+
+    # Create the worktree for branch-a.
+    worktree_path, _branch = ensure_worktree("branch-a", cwd=repo)
+    assert worktree_path.exists()
+
+    # Switch the worktree folder to branch-b.
+    switched = subprocess.run(
+        ["git", "switch", "branch-b"],
+        cwd=str(worktree_path),
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert switched.returncode == 0, switched.stderr
+
+    with pytest.raises(WorktreeError):
+        ensure_worktree("branch-a", cwd=repo)
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_prunes_stale_checked_out_branch(tmp_path: Path) -> None:
+    """If git thinks a branch is checked out in a deleted Kiwi worktree, prune + retry."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    # Create both branches without checking them out in the main worktree.
+    assert _git(repo, "branch", "branch-a").returncode == 0
+    assert _git(repo, "branch", "branch-b").returncode == 0
+
+    # Create the worktree at .kiwi/worktrees/branch-a and then switch it to branch-b.
+    worktree_a, _ = ensure_worktree("branch-a", cwd=repo)
+    switched = subprocess.run(
+        ["git", "switch", "branch-b"],
+        cwd=str(worktree_a),
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert switched.returncode == 0, switched.stderr
+
+    # Delete the worktree directory without unregistering it (stale git metadata).
+    shutil.rmtree(worktree_a)
+    assert not worktree_a.exists()
+
+    worktree_b, branch = ensure_worktree("branch-b", cwd=repo)
+    assert branch == "branch-b"
+    assert worktree_b.exists()
+
+    head = subprocess.check_output(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=str(worktree_b),
+        text=True,
+    ).strip()
+    assert head == "branch-b"

{kiwi_code-0.0.42 → kiwi_code-0.0.431}/uv.lock

@@ -397,7 +397,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.42"
+version = "0.0.431"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },