kiwi-code 0.0.505__tar.gz → 0.0.507__tar.gz

{kiwi_code-0.0.505 → kiwi_code-0.0.507}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kiwi-code
-Version: 0.0.505
+Version: 0.0.507
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://kiwicode.ai
 Author-email: Anurag <anurag@meetkiwi.co>

{kiwi_code-0.0.505 → kiwi_code-0.0.507}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.505"
+version = "0.0.507"
 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.505 → kiwi_code-0.0.507}/src/kiwi_cli/edition.py

@@ -27,6 +27,10 @@ EDITIONS: dict[str, dict[str, str]] = {
     },
 }
 
+#: The package this build was published as: kiwi-ai or kiwi-code (see the module's
+#: docstring). Unlike EDITION, KIWI_EDITION does not change it: it names what is
+#: installed, which is what an update must ask PyPI for and install.
+BUILD_EDITION = _BUILD_EDITION
 EDITION = os.environ.get("KIWI_EDITION") or _BUILD_EDITION
 if EDITION not in EDITIONS:
     raise ValueError(f"Unknown KIWI_EDITION {EDITION!r}; expected one of {sorted(EDITIONS)}")
@@ -38,10 +42,10 @@ DEFAULT_ACCOUNT = EDITIONS[EDITION]["default_account"]
 
 
 def _installed_version() -> str:
-    # Ask whichever distribution ships kiwi_cli (kiwi-ai or kiwi-code), so the
-    # version is right regardless of KIWI_EDITION. Editable installs don't map
-    # kiwi_cli to a distribution, so also try each edition's package name.
-    for dist in [*metadata.packages_distributions().get("kiwi_cli", []), *EDITIONS]:
+    # The package this build was published as comes first: when kiwi-ai and kiwi-code
+    # are both installed in one environment, both ship kiwi_cli. Then whichever
+    # distribution ships kiwi_cli, and each edition's name (a local checkout).
+    for dist in [BUILD_EDITION, *metadata.packages_distributions().get("kiwi_cli", []), *EDITIONS]:
         try:
             return metadata.version(dist)
         except metadata.PackageNotFoundError:

kiwi_code-0.0.507/src/kiwi_tui/attention.py

@@ -0,0 +1,107 @@
+"""Calling the user back when the agent needs them: a question waiting for an answer, or a
+run that has finished.
+
+While kiwi's window has focus the user is there, and the screen itself shows it. When they
+are elsewhere (the terminal tells kiwi when its window loses focus), kiwi:
+
+- shows a desktop notification, through the terminal (OSC 777 / 9 / 99), so it also works
+  over ssh; a terminal with none of them gets `notify-send` / `osascript` instead, when
+  kiwi runs on the user's own machine;
+- rings the terminal bell (a sound, and a mark on the tab or dock icon in most terminals);
+- puts a mark in the tab title, until the window has focus again.
+
+`/notify on | quiet | off` chooses: quiet leaves out the bell; off does none of it.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from collections.abc import Mapping
+
+MODES = ("on", "quiet", "off")
+DEFAULT_MODE = "on"
+#: The tab title kiwi starts with; set by main once it knows the folder.
+BASE_TITLE = "kiwi"
+
+_CONTROL = re.compile(r"[\x00-\x1f\x7f]+")
+
+
+def mode_from(settings: Mapping) -> str:
+    mode = str(settings.get("notify") or DEFAULT_MODE).lower()
+    return mode if mode in MODES else DEFAULT_MODE
+
+
+def _clean(text: str, limit: int = 160) -> str:
+    """One line, no control characters (they could end the sequence), and short."""
+    text = " ".join(_CONTROL.sub(" ", str(text or "")).split())
+    return text if len(text) <= limit else text[: limit - 1] + "…"
+
+
+def notification_sequence(title: str, body: str, env: Mapping[str, str] = os.environ) -> str:
+    """The escape sequence that makes this terminal show a desktop notification; "" for a
+    terminal not known to have one (an unknown one would print it, or ignore it)."""
+    title, body = _clean(title, 60), _clean(body)
+    program = env.get("TERM_PROGRAM", "").lower()
+    term = env.get("TERM", "").lower()
+    if env.get("TMUX") or term.startswith(("screen", "tmux")):
+        return ""  # tmux keeps these to itself unless told to pass them on
+    if env.get("KITTY_WINDOW_ID") or "kitty" in term:
+        return f"\x1b]99;;{title}: {body}\x1b\\"
+    if program in ("ghostty", "wezterm") or "ghostty" in term:
+        # `;` separates the fields of OSC 777.
+        return f"\x1b]777;notify;{title.replace(';', ',')};{body.replace(';', ',')}\x07"
+    if program == "iterm.app":
+        return f"\x1b]9;{title}: {body}\x07"
+    return ""
+
+
+def local_notification_command(
+    title: str, body: str, env: Mapping[str, str] = os.environ, platform: str | None = None
+) -> list[str] | None:
+    """A command that shows the notification on this machine, for a terminal that cannot;
+    None over ssh (it would show on the wrong machine) or when there is none."""
+    if env.get("SSH_CONNECTION") or env.get("SSH_TTY"):
+        return None
+    platform = platform or sys.platform
+    title, body = _clean(title, 60), _clean(body)
+    if platform == "darwin":
+        def quoted(s: str) -> str:
+            return '"' + s.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+        return ["osascript", "-e", f"display notification {quoted(body)} with title {quoted(title)}"]
+    if platform.startswith("linux") and shutil.which("notify-send"):
+        return ["notify-send", "--app-name=Kiwi", title, body]
+    return None
+
+
+def title_sequence(title: str) -> str:
+    return f"\x1b]2;{_clean(title, 120)}\x07"
+
+
+def call_out(write, *, mode: str, title: str, body: str, tab: str, env: Mapping[str, str] = os.environ) -> None:
+    """Notify, ring and mark the tab, as `mode` allows. `write` sends text to the terminal."""
+    if mode == "off":
+        return
+    out = title_sequence(tab)
+    if mode == "on":
+        out += "\a"
+    sequence = notification_sequence(title, body, env)
+    write(out + sequence)
+    if not sequence:
+        command = local_notification_command(title, body, env)
+        if command:
+            launch(command)
+
+
+def launch(command: list[str]) -> None:
+    """Start `command` and leave it: kiwi does not wait for the notification."""
+    try:
+        subprocess.Popen(
+            command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL, start_new_session=True,
+        )
+    except OSError:
+        pass

kiwi_code-0.0.507/src/kiwi_tui/autoupdate.py

@@ -0,0 +1,216 @@
+"""Keeping kiwi up to date on its own.
+
+While kiwi runs, the dashboard asks PyPI for the latest release (see
+`TermDashboardScreen._check_latest_version`) and remembers it here, in
+`~/.kiwi/update.json`. At the next start, before the TUI opens, a newer release is
+installed with the tool kiwi was installed with, and the new version is started instead.
+Installing at start rather than under a running session matters: kiwi imports parts of
+itself as they are needed, and those must not come from another version.
+
+Never updated on its own: an editable or local checkout, kiwi outside a virtual
+environment (a system Python is the user's to manage), Windows (the running `kiwi.exe`
+cannot be replaced), a start that is not interactive, or when turned off with
+`/autoupdate off` or `KIWI_NO_AUTO_UPDATE=1`. Those get the command to run instead.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from importlib import metadata
+from pathlib import Path
+
+#: How long an update may take before kiwi gives up and starts the version it has.
+INSTALL_TIMEOUT = 180
+#: A release that would not install is tried again after this long.
+RETRY_AFTER = 24 * 3600
+#: Set in the new version's environment, so it can say what it was updated from (and so a
+#: failed update cannot loop).
+UPDATED_FROM_ENV = "KIWI_UPDATED_FROM"
+
+
+@dataclass(frozen=True)
+class Installer:
+    name: str  # uv / pipx / pip
+    command: tuple[str, ...]  # what updates kiwi
+    manual: str  # the same, for the user to type
+
+
+def package_name() -> str:
+    """The PyPI package kiwi was installed as: kiwi-ai or kiwi-code. Both are built from
+    this one codebase; the build bakes in which one it is (scripts/set_edition.py), and
+    KIWI_EDITION, which only points kiwi at the other backend, does not change it."""
+    from kiwi_cli.edition import BUILD_EDITION
+
+    return BUILD_EDITION
+
+
+def _state_path() -> Path:
+    from kiwi_cli.checkpoints import kiwi_home_dir
+
+    return kiwi_home_dir() / "update.json"
+
+
+def _read_all() -> dict:
+    try:
+        data = json.loads(_state_path().read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _read_state() -> dict:
+    """This package's part: kiwi-ai and kiwi-code share ~/.kiwi, each with its own
+    releases and versions."""
+    state = _read_all().get(package_name())
+    return state if isinstance(state, dict) else {}
+
+
+def _write_state(**patch) -> None:
+    try:
+        path = _state_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        everything = _read_all()
+        everything[package_name()] = {**_read_state(), **patch}
+        tmp = path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(everything), encoding="utf-8")
+        os.replace(tmp, path)
+    except OSError:
+        pass
+
+
+def record_latest(version: str) -> None:
+    """The latest release PyPI has, for the next start to install."""
+    _write_state(latest=str(version), checked_at=time.time())
+
+
+def newer(latest: str, current: str) -> bool:
+    try:
+        from packaging.version import Version
+
+        return Version(latest) > Version(current)
+    except Exception:
+        return False
+
+
+def pending(current: str, *, now: float | None = None) -> str | None:
+    """A newer release found earlier and not given up on: the version to install."""
+    state = _read_state()
+    latest = str(state.get("latest") or "")
+    if not latest or not newer(latest, current):
+        return None
+    now = time.time() if now is None else now
+    if state.get("failed") == latest and now - float(state.get("failed_at") or 0) < RETRY_AFTER:
+        return None
+    return latest
+
+
+def enabled(env=os.environ) -> bool:
+    if env.get("KIWI_NO_AUTO_UPDATE", "").strip().lower() in ("1", "true", "yes"):
+        return False
+    try:
+        from kiwi_tui.ui_settings import load_settings
+
+        return load_settings().get("auto_update", True) is not False
+    except Exception:
+        return True
+
+
+def _editable(package: str) -> bool:
+    """A checkout installed in place (`pip install -e`, `uv run`): never updated from PyPI."""
+    try:
+        raw = metadata.distribution(package).read_text("direct_url.json")
+    except Exception:
+        return False
+    if not raw:
+        return False
+    try:
+        info = json.loads(raw)
+    except ValueError:
+        return False
+    return bool(info.get("dir_info", {}).get("editable")) or str(info.get("url", "")).startswith("file:")
+
+
+def installer(package: str, *, prefix: str | None = None, base_prefix: str | None = None,
+              platform: str | None = None) -> Installer | None:
+    """How kiwi was installed, and so how to update it; None when kiwi must not update
+    itself (see the module's docstring)."""
+    prefix = sys.prefix if prefix is None else prefix
+    base_prefix = sys.base_prefix if base_prefix is None else base_prefix
+    platform = platform or sys.platform
+    if platform == "win32" or prefix == base_prefix or _editable(package):
+        return None
+    # Each tool leaves a file of its own in the environments it makes; the path is the
+    # fallback (a tool folder can be moved with UV_TOOL_DIR / PIPX_HOME).
+    env, parts = Path(prefix), Path(prefix).parts
+    if (env / "uv-receipt.toml").exists() or ("uv" in parts and "tools" in parts):
+        return Installer("uv", ("uv", "tool", "upgrade", package), f"uv tool upgrade {package}")
+    if (env / "pipx_metadata.json").exists() or ("pipx" in parts and "venvs" in parts):
+        return Installer("pipx", ("pipx", "upgrade", package), f"pipx upgrade {package}")
+    return Installer(
+        "pip", (sys.executable, "-m", "pip", "install", "--upgrade", "--quiet", package),
+        f"pip install --upgrade {package}",
+    )
+
+
+def manual_command(package: str) -> str:
+    """What the user should type to update, for the notice when kiwi will not do it."""
+    found = None
+    try:
+        found = installer(package, platform="linux")  # the right tool even on Windows
+    except Exception:
+        pass
+    return found.manual if found else f"pip install --upgrade {package}"
+
+
+def _version_on_disk(package: str) -> str | None:
+    """The installed version as a new process sees it (this one has the old one cached)."""
+    try:
+        out = subprocess.run(
+            [sys.executable, "-c", f"import importlib.metadata as m; print(m.version({package!r}))"],
+            capture_output=True, text=True, timeout=30,
+        )
+        return out.stdout.strip() or None
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+
+def update_before_start(current: str, *, interactive: bool) -> bool:
+    """At start, before the TUI: install a newer release found earlier. Whether it was
+    installed (the caller then starts the new version)."""
+    if not interactive or os.environ.get(UPDATED_FROM_ENV) or not enabled():
+        return False
+    latest = pending(current)
+    if latest is None:
+        return False
+    package = package_name()
+    tool = installer(package)
+    if tool is None:
+        return False
+
+    print(f"Updating {package} v{current} → v{latest}…", flush=True)
+    try:
+        done = subprocess.run(
+            list(tool.command), stdin=subprocess.DEVNULL, capture_output=True, text=True,
+            timeout=INSTALL_TIMEOUT,
+        )
+        ok = done.returncode == 0
+        why = (done.stderr or done.stdout or "").strip().splitlines()[-1:] or [""]
+    except (OSError, subprocess.SubprocessError) as e:
+        ok, why = False, [str(e)]
+    if ok and not newer(_version_on_disk(package) or current, current):
+        ok, why = False, ["the new release did not install"]
+    if not ok:
+        _write_state(failed=latest, failed_at=time.time())
+        print(f"Could not update ({why[0]}). Starting v{current}; update with: {tool.manual}", flush=True)
+        return False
+    return True
+
+
+def restart_updated(current: str) -> None:
+    """Start the version just installed in place of this process."""
+    env = {**os.environ, UPDATED_FROM_ENV: current}
+    os.execve(sys.executable, [sys.executable, "-m", "kiwi_tui.main", *sys.argv[1:]], env)

{kiwi_code-0.0.505 → kiwi_code-0.0.507}/src/kiwi_tui/main.py

@@ -43,6 +43,7 @@ from kiwi_tui.runtime_agent import (
 )
 
 from kiwi_tui.ui_settings import load_settings as load_ui_settings, update_settings as update_ui_settings
+from kiwi_tui import attention
 
 
 
@@ -902,6 +903,32 @@ class AutobotsTUI(App):
     #: The most toasts shown at once; older ones give way.
     MAX_TOASTS = 3
 
+    def call_for_attention(self, *, title: str, body: str, tab: str) -> bool:
+        """Call the user back (notification, bell, tab title) when kiwi's window is not
+        in focus: when it is, they are here. Whether it did."""
+        if self.app_focus:
+            return False
+        try:
+            mode = attention.mode_from(load_ui_settings())
+            attention.call_out(self._write_to_terminal, mode=mode, title=title, body=body, tab=tab)
+        except Exception as e:
+            logger.debug(f"Calling for attention failed: {e}")
+            return False
+        self._tab_marked = mode != "off"
+        return True
+
+    def _write_to_terminal(self, text: str) -> None:
+        driver = self._driver
+        if driver is not None and text:
+            driver.write(text)
+            driver.flush()
+
+    def on_app_focus(self, _event) -> None:
+        # Back at kiwi: the mark on the tab has done its job.
+        if getattr(self, "_tab_marked", False):
+            self._tab_marked = False
+            self._write_to_terminal(attention.title_sequence(attention.BASE_TITLE))
+
     def _on_notify(self, event) -> None:
         make_room_for_toast(self._notifications, event.notification, self.MAX_TOASTS)
         super()._on_notify(event)
@@ -1297,7 +1324,8 @@ def main() -> int:
     if sys.stdout.isatty():
         # Strip C0 control chars and DEL to prevent terminal injection via crafted dir names.
         safe_dir = "".join(ch for ch in display_dir if ch >= " " and ch != "\x7f")
-        sys.stdout.write(f"\033]0;kiwi ({safe_dir})\007")
+        attention.BASE_TITLE = f"kiwi ({safe_dir})"
+        sys.stdout.write(f"\033]0;{attention.BASE_TITLE}\007")
         sys.stdout.flush()
 
     runtime_args = _build_runtime_args(args)
@@ -1340,6 +1368,14 @@ def main() -> int:
             )
         )
 
+    # A newer release found by an earlier session is installed now, before the TUI opens,
+    # and started in place of this one.
+    from kiwi_tui import autoupdate
+
+    interactive = sys.stdin.isatty() and sys.stdout.isatty()
+    if autoupdate.update_before_start(KIWI_CODE_VERSION, interactive=interactive):
+        autoupdate.restart_updated(KIWI_CODE_VERSION)
+
     _run_term_tui(runtime_args=runtime_args)
     return 0
 

{kiwi_code-0.0.505 → kiwi_code-0.0.507}/src/kiwi_tui/screens/term_activity_view.py

@@ -313,17 +313,17 @@ def _spaced(parts: list) -> list:
 def trace_renderable(
     lines: list[TraceLine], start: int | None, *, cyan: str, total: int, shown: int = SHOWN_TRACE
 ) -> Text:
-    """The latest `shown` trace lines: number, time since the first event, type, what it says."""
+    """The latest `shown` trace lines: time since the first event, type, what it says.
+    Kept narrow: the trace is a column beside the conversation."""
     families = {"turn": cyan, "step": "dim", "tool": "yellow", "subagent": "magenta", "question": "blue"}
     out = Text()
-    out.append(f"Trace · latest {min(len(lines), shown)} of {total} kept · esc or ctrl+t to hide", style="dim")
+    out.append(f"Trace · {min(len(lines), shown)} of {total} · esc to close", style="dim")
     for line in lines[-shown:]:
         family = line.type.split(".", 1)[0]
         secs = ((line.at - (start or line.at)) / 1000) if line.at else 0
         out.append("\n")
-        out.append(f"{line.seq:>5} ", style="dim")
-        out.append(f"+{secs:.2f}s".ljust(10), style="dim")
-        out.append(f"{line.type:<18}", style=families.get(family, ""))
+        out.append(f"+{secs:.1f}s".ljust(8), style="dim")
+        out.append(f"{line.type:<17}", style=families.get(family, ""))
         what = line.what if line.count == 1 else f"×{line.count} {line.what}"
         out.append(what)
     return out