kiwi-code 0.0.28__tar.gz → 0.0.30__tar.gz

{kiwi_code-0.0.28 → kiwi_code-0.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.28
+Version: 0.0.30
 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.28 → kiwi_code-0.0.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.28"
+version = "0.0.30"
 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.28 → kiwi_code-0.0.30}/src/kiwi_cli/client.py

@@ -177,52 +177,56 @@ class AutobotsClientWrapper:
         try:
             logger.info("Attempting to refresh access token")
 
-            # Need authenticated client for refresh
-            if not isinstance(self.client, AuthenticatedClient):
-                temp_client = AuthenticatedClient(
-                    base_url=self.base_url,
-                    token=refresh_token,
-                    raise_on_unexpected_status=False,
-                )
-            else:
-                temp_client = self.client
-
-            response = refresh_password_email_v1_auth_session_refresh_post.sync_detailed(
-                client=temp_client,
-                refresh_token=refresh_token,
-            )
-
-            if response.status_code == 200 and response.parsed:
-                auth_response = response.parsed
+            # NOTE: Don't use the OpenAPI AuthenticatedClient for refresh.
+            # It always injects an Authorization header, and depending on backend
+            # behavior, an invalid/expired bearer token can cause refresh to fail
+            # even if `refresh_token` is provided as a query param.
+            url = f"{self.base_url.rstrip('/')}/v1/auth/session/refresh"
+            with httpx.Client(timeout=30) as client:
+                resp = client.post(url, params={"refresh_token": refresh_token})
+
+            if resp.status_code != 200:
+                detail = (resp.text or "").strip()
+                if len(detail) > 200:
+                    detail = detail[:200] + "..."
+                error_msg = f"Token refresh failed with status {resp.status_code}"
+                if detail:
+                    error_msg += f": {detail}"
+                logger.error(error_msg)
+                return False, None, error_msg
 
-                if auth_response.session:
-                    session = auth_response.session
+            body = resp.json() if resp.content else {}
+            session = (body.get("session") or {}) if isinstance(body, dict) else {}
+            access = session.get("access_token") or (body.get("access_token") if isinstance(body, dict) else None)
+            new_refresh = session.get("refresh_token") or refresh_token
+            token_type = session.get("token_type") or "Bearer"
+            expires_in = session.get("expires_in")
 
-                    # Calculate expiry time
-                    expires_at = None
-                    if hasattr(session, 'expires_in') and session.expires_in:
-                        expires_at = datetime.now() + timedelta(seconds=session.expires_in)
+            if not access:
+                error_msg = f"Token refresh response missing access_token: {body}"
+                logger.error(error_msg)
+                return False, None, error_msg
 
-                    tokens = AuthTokens(
-                        access_token=session.access_token,
-                        refresh_token=session.refresh_token,
-                        token_type=session.token_type,
-                        expires_at=expires_at,
-                    )
+            # Calculate expiry time when provided by the backend.
+            expires_at = None
+            try:
+                if isinstance(expires_in, (int, float)) and expires_in:
+                    expires_at = datetime.now() + timedelta(seconds=int(expires_in))
+            except Exception:
+                expires_at = None
+
+            tokens = AuthTokens(
+                access_token=str(access),
+                refresh_token=str(new_refresh),
+                token_type=str(token_type),
+                expires_at=expires_at,
+            )
 
-                    # Update client with new token
-                    self.update_token(tokens.access_token)
+            # Update client with new token
+            self.update_token(tokens.access_token)
 
-                    logger.info("Token refresh successful")
-                    return True, tokens, "Token refreshed successfully"
-                else:
-                    error_msg = "No session in refresh response"
-                    logger.error(error_msg)
-                    return False, None, error_msg
-            else:
-                error_msg = f"Token refresh failed with status {response.status_code}"
-                logger.error(error_msg)
-                return False, None, error_msg
+            logger.info("Token refresh successful")
+            return True, tokens, "Token refreshed successfully"
 
         except Exception as e:
             error_msg = f"Token refresh error: {str(e)}"

{kiwi_code-0.0.28 → kiwi_code-0.0.30}/src/kiwi_runtime/main.py

@@ -244,24 +244,25 @@ async def _get_valid_access_token(http_base_url: str, fallback_token: str) -> st
             return str(data3.get("access_token") or access2 or fallback_token)
 
 
-async def _force_refresh_access_token(http_base_url: str, fallback_token: str) -> str:
-    """Force a refresh (if refresh_token exists). Used after HTTP 401."""
-    data = _load_tokens_file(TOKENS_PATH)
-    refresh = None
+async def _force_refresh_access_token(http_base_url: str) -> dict[str, Any] | None:
+    """Force a refresh (if refresh_token exists). Used after HTTP 401/403.
+
+    Returns:
+        tokens.json-compatible dict on success, otherwise None.
+    """
+    data = _load_tokens_file(TOKENS_PATH) or {}
     with _TokensLock():
         data2 = _load_tokens_file(TOKENS_PATH) or data or {}
-        refresh2 = data2.get("refresh_token") or refresh
+        refresh_token = data2.get("refresh_token")
+        if not refresh_token:
+            return None
         try:
-            new_data = await _refresh_tokens(http_base_url, refresh2)
+            new_data = await _refresh_tokens(http_base_url, str(refresh_token))
             _atomic_write_tokens(TOKENS_PATH, new_data)
-            return str(new_data.get("access_token"))
+            return new_data
         except Exception:
-            data3 = _load_tokens_file(TOKENS_PATH) or data2
-            return str(data3.get("access_token") or fallback_token)
-        refresh2 = data2.get("refresh_token") or refresh
-        new_data = await _refresh_tokens(http_base_url, refresh2)
-        _atomic_write_tokens(TOKENS_PATH, new_data)
-        return str(new_data.get("access_token"))
+            # If refresh failed, keep existing auth state and let the caller decide.
+            return None
 
 _chunked_writes_lock = threading.Lock()
 MAX_OUTPUT_BYTES = 50 * 1024  # 50KB cap on command output
@@ -2329,17 +2330,23 @@ async def handle_read_files(
                 # If the access token expired mid-session, try once more after a refresh.
                 if resp.status_code in (401, 403):
                     try:
-                        upload_token2 = await _force_refresh_access_token(http_base_url, upload_token)
-                        for fh in open_handles:
-                            try:
-                                fh.seek(0)
-                            except Exception:
-                                pass
-                        resp = await client.post(
-                            upload_url,
-                            files=file_tuples,
-                            headers={"Authorization": f"Bearer {upload_token2}"},
+                        new_data = await _force_refresh_access_token(http_base_url)
+                        upload_token2 = (
+                            str(new_data.get("access_token"))
+                            if isinstance(new_data, dict) and new_data.get("access_token")
+                            else ""
                         )
+                        if upload_token2:
+                            for fh in open_handles:
+                                try:
+                                    fh.seek(0)
+                                except Exception:
+                                    pass
+                            resp = await client.post(
+                                upload_url,
+                                files=file_tuples,
+                                headers={"Authorization": f"Bearer {upload_token2}"},
+                            )
                     except Exception:
                         # Fall through to error handling below.
                         pass
@@ -2349,9 +2356,15 @@ async def handle_read_files(
                     for meta in file_metas:
                         urls.append(str(meta["url"]))
                 else:
-                    errors.append(
-                        f"Upload failed: HTTP {resp.status_code} — {resp.text[:200]}"
-                    )
+                    if resp.status_code in (401, 403):
+                        errors.append(
+                            f"Upload failed: authentication expired (HTTP {resp.status_code}). "
+                            "Please login again in Kiwi Code (or run `kiwi login`) to refresh tokens.",
+                        )
+                    else:
+                        errors.append(
+                            f"Upload failed: HTTP {resp.status_code} — {resp.text[:200]}"
+                        )
         except Exception as e:
             errors.append(f"Upload error: {str(e)}")
         finally:

{kiwi_code-0.0.28 → kiwi_code-0.0.30}/src/kiwi_tui/main.py

@@ -192,7 +192,10 @@ class AutobotsTUI(App):
                         access_token = new_tokens.access_token
                     else:
                         logger.warning(f"Token refresh failed: {message}")
-                        self.token_manager.clear_tokens()
+                        # Keep tokens on disk so other processes (e.g. kiwi-runtime)
+                        # can still attempt refresh / recover. We'll prompt the user
+                        # to login again if needed.
+                        access_token = None
                 else:
                     logger.info("Valid access token found")
                     access_token = tokens.access_token
@@ -585,22 +588,28 @@ class AutobotsTUI(App):
         # if tokens and tokens.refresh_token:
         #     runtime_manager.save_refresh_token(tokens.refresh_token)
 
-    def _refresh_token_if_needed(self) -> None:
-        """Check token expiry and refresh if needed."""
+    def _refresh_token_if_needed(self, force: bool = False) -> bool:
+        """Check token expiry and refresh if needed.
+
+        Args:
+            force: If True, attempt refresh even if the token doesn't look expired.
+        """
         with self.token_manager.file_lock():
             tokens = self.token_manager.load_tokens()
             if not tokens:
                 logger.debug("No tokens to refresh")
-                return
+                return False
 
-            if not tokens.is_expired():
+            if (not force) and (not tokens.is_expired()):
                 logger.debug("Token still valid, skipping refresh")
-                return
+                return True
 
-            logger.info("Token expired or near expiry, refreshing...")
-            success, new_tokens, message = self.autobots_client.refresh_token(
-                tokens.refresh_token
-            )
+            if not getattr(tokens, "refresh_token", None):
+                logger.warning("No refresh token available; cannot refresh access token")
+                return False
+
+            logger.info("Refreshing access token...")
+            success, new_tokens, message = self.autobots_client.refresh_token(tokens.refresh_token)
 
             if success and new_tokens:
                 logger.info("Token refreshed successfully")
@@ -610,12 +619,10 @@ class AutobotsTUI(App):
                 self.autobots_client.update_token(new_tokens.access_token)
                 # Update shared state
                 self._kiwi_token = new_tokens.access_token
-                # Write to runtime directory so the runtime process can pick it up
-                # runtime_manager.save_token(new_tokens.access_token)
-                # if new_tokens.refresh_token:
-                #     runtime_manager.save_refresh_token(new_tokens.refresh_token)
-            else:
-                logger.error(f"Token refresh failed: {message}")
+                return True
+
+            logger.error(f"Token refresh failed: {message}")
+            return False
 
     # ------------------------------------------------------------------
 

kiwi_code-0.0.30/src/kiwi_tui/random_words.py

@@ -0,0 +1,9 @@
+from kiwi_tui.status_words import next_status_word
+def random_verb(*, default: str = "Thinking") -> str:
+    """Return a curated "-ing" status word for display (e.g. "Searching")."""
+
+    return next_status_word(default=default)
+
+
+def random_adjective(*, default: str = "Curious") -> str:  # pragma: no cover
+    return default

{kiwi_code-0.0.28 → kiwi_code-0.0.30}/src/kiwi_tui/screens/dashboard.py

@@ -2075,7 +2075,22 @@ class DashboardScreen(Screen):
             return
         names = [Path(p).name for p in file_paths]
         self.add_message(f"> Uploading: {', '.join(names)}", "user")
+        # Ensure the token is fresh before upload (important for long-running sessions).
+        try:
+            self.app._refresh_token_if_needed()
+        except Exception:
+            pass
+
         success, urls, message = self.app.autobots_client.upload_files(file_paths)
+        if (not success) and ("HTTP 401" in message or "HTTP 403" in message):
+            # Token may have expired or been rotated; force a refresh and retry once.
+            refreshed = False
+            try:
+                refreshed = bool(self.app._refresh_token_if_needed(force=True))
+            except Exception:
+                refreshed = False
+            if refreshed:
+                success, urls, message = self.app.autobots_client.upload_files(file_paths)
         if success:
             self._pending_urls.extend(urls)
             uploaded_names = [Path(u.rsplit("/", 1)[-1]).name for u in urls]

kiwi_code-0.0.30/src/kiwi_tui/status_words.py

@@ -0,0 +1,481 @@
+from collections import deque
+from dataclasses import dataclass, field
+from functools import lru_cache
+import random
+import threading
+import time
+from typing import Deque, Iterable
+
+
+_STATUS_WORDS_RAW: tuple[str, ...] = (
+    "Thinking",
+    "Working",
+    "Responding",
+    "Reasoning",
+    "Reflecting",
+    "Considering",
+    "Pondering",
+    "Deliberating",
+    "Planning",
+    "Prioritizing",
+    "Organizing",
+    "Outlining",
+    "Strategizing",
+    "Brainstorming",
+    "Ideating",
+    "Envisioning",
+    "Imagining",
+    "Inferring",
+    "Deducing",
+    "Concluding",
+    "Deciding",
+    "Choosing",
+    "Reconsidering",
+    "Reassessing",
+    "Evaluating",
+    "Estimating",
+    "Calculating",
+    "Computing",
+    "Measuring",
+    "Counting",
+    "Timing",
+    "Comparing",
+    "Contrasting",
+    "Weighing",
+    "Balancing",
+    "Aligning",
+    "Centering",
+    "Spacing",
+    "Arranging",
+    "Resizing",
+    "Wrapping",
+    "Rendering",
+    "Styling",
+    "Theming",
+    "Polishing",
+    "Refining",
+    "Improving",
+    "Optimizing",
+    "Tuning",
+    "Simplifying",
+    "Streamlining",
+    "Modernizing",
+    "Upgrading",
+    "Updating",
+    "Reworking",
+    "Rewriting",
+    "Editing",
+    "Proofreading",
+    "Formatting",
+    "Drafting",
+    "Writing",
+    "Summarizing",
+    "Condensing",
+    "Clarifying",
+    "Explaining",
+    "Describing",
+    "Documenting",
+    "Annotating",
+    "Commenting",
+    "Noting",
+    "Labeling",
+    "Tagging",
+    "Indexing",
+    "Cataloging",
+    "Listing",
+    "Sorting",
+    "Grouping",
+    "Filtering",
+    "Selecting",
+    "Collecting",
+    "Gathering",
+    "Compiling",
+    "Assembling",
+    "Combining",
+    "Merging",
+    "Splitting",
+    "Separating",
+    "Isolating",
+    "Narrowing",
+    "Pinpointing",
+    "Investigating",
+    "Inspecting",
+    "Reviewing",
+    "Rereading",
+    "Reading",
+    "Scanning",
+    "Browsing",
+    "Searching",
+    "Exploring",
+    "Discovering",
+    "Observing",
+    "Monitoring",
+    "Tracking",
+    "Tracing",
+    "Logging",
+    "Instrumenting",
+    "Profiling",
+    "Benchmarking",
+    "Testing",
+    "Retesting",
+    "Validating",
+    "Verifying",
+    "Confirming",
+    "Checking",
+    "Crosschecking",
+    "Doublechecking",
+    "Rechecking",
+    "Auditing",
+    "Diagnosing",
+    "Debugging",
+    "Reproducing",
+    "Triaging",
+    "Resolving",
+    "Fixing",
+    "Repairing",
+    "Mitigating",
+    "Preventing",
+    "Safeguarding",
+    "Securing",
+    "Hardening",
+    "Sanitizing",
+    "Normalizing",
+    "Cleaning",
+    "Tidying",
+    "Pruning",
+    "Trimming",
+    "Archiving",
+    "Restoring",
+    "Saving",
+    "Autosaving",
+    "Persisting",
+    "Storing",
+    "Caching",
+    "Preloading",
+    "Loading",
+    "Fetching",
+    "Retrieving",
+    "Downloading",
+    "Uploading",
+    "Syncing",
+    "Synchronizing",
+    "Refreshing",
+    "Connecting",
+    "Reconnecting",
+    "Handshaking",
+    "Authenticating",
+    "Authorizing",
+    "Negotiating",
+    "Provisioning",
+    "Initializing",
+    "Booting",
+    "Starting",
+    "Restarting",
+    "Resuming",
+    "Pausing",
+    "Waiting",
+    "Queueing",
+    "Retrying",
+    "Recovering",
+    "Stabilizing",
+    "Configuring",
+    "Reconfiguring",
+    "Customizing",
+    "Parameterizing",
+    "Templating",
+    "Generating",
+    "Synthesizing",
+    "Deriving",
+    "Transforming",
+    "Parsing",
+    "Tokenizing",
+    "Serializing",
+    "Deserializing",
+    "Encoding",
+    "Decoding",
+    "Compressing",
+    "Decompressing",
+    "Encrypting",
+    "Decrypting",
+    "Migrating",
+    "Seeding",
+    "Backfilling",
+    "Importing",
+    "Exporting",
+    "Consolidating",
+    "Aggregating",
+    "Reconciling",
+    "Harmonizing",
+    "Coordinating",
+    "Collaborating",
+    "Communicating",
+    "Listening",
+    "Asking",
+    "Answering",
+    "Advising",
+    "Suggesting",
+    "Recommending",
+    "Guiding",
+    "Coaching",
+    "Helping",
+    "Assisting",
+    "Supporting",
+    "Sharing",
+    "Notifying",
+    "Reporting",
+    "Presenting",
+    "Approving",
+    "Finalizing",
+    "Launching",
+    "Deploying",
+    "Building",
+    "Bundling",
+    "Packaging",
+    "Releasing",
+    "Shipping",
+    "Installing",
+    "Uninstalling",
+    "Executing",
+    "Running",
+    "Scheduling",
+    "Orchestrating",
+    "Automating",
+    "Scripting",
+    "Branching",
+    "Committing",
+    "Rebasing",
+    "Pushing",
+    "Pulling",
+    "Cloning",
+    "Forking",
+    "Versioning",
+    "Linting",
+    "Refactoring",
+    "Modularizing",
+    "Encapsulating",
+    "Integrating",
+    "Interfacing",
+    "Adapting",
+    "Abstracting",
+    "Decomposing",
+    "Recomposing",
+    "Prototyping",
+    "Sketching",
+    "Tinkering",
+    "Noodling",
+    "Spelunking",
+    "Diagramming",
+    "Visualizing",
+    "Simulating",
+    "Emulating",
+    "Staging",
+    "Navigating",
+    "Traversing",
+    "Examining",
+    "Disambiguating",
+    "Canonicalizing",
+    "Contextualizing",
+    "Operationalizing",
+    "Instrumenting",
+    "Triangulating",
+    "Deobfuscating",
+    "Deinterleaving",
+    "Reparameterizing",
+    "Recontextualizing",
+    "Disentangling",
+    "Deconvoluting",
+    "Corroborating",
+    "Extrapolating",
+    "Interpolating",
+    "Reconceptualizing",
+    "Rationalizing",
+    "Formalizing",
+    "Generalizing",
+    "Specializing",
+    "Particularizing",
+    "Virtualizing",
+    "Containerizing",
+    "Deprovisioning",
+    "Sandboxing",
+    "Backporting",
+    "Forwardporting",
+    "Snapshotting",
+    "Diffing",
+    "Grepping",
+    "Vendoring",
+    "Reindexing",
+    "Rerendering",
+    "Revalidating",
+    "Recalibrating",
+    "Reassociating",
+    "Enumerating",
+    "Assimilating",
+    "Ameliorating",
+    "Interrogating",
+    "Disseminating",
+    "Discretizing",
+    "Denormalizing",
+    "Deprioritizing",
+    "Underprovisioning",
+    "Assimilating",
+    "Scaffolding",
+    "Excavating",
+    "Unearthing",
+    "Deciphering",
+    "Synthesizing",
+    "Converging",
+    "Diverging",
+    "Reticulating",
+    "Transpiling",
+    "Hydrating",
+    "Materializing",
+    "Manifesting",
+    "Crystallizing",
+    "Coalescing",
+    "Distilling",
+    "Ferreting",
+    "Foraging",
+    "Sifting",
+    "Winnowing",
+    "Untangling",
+    "Unraveling",
+    "Threading",
+    "Stitching",
+    "Splicing",
+    "Grafting",
+    "Weaving",
+    "Braiding",
+    "Layering",
+    "Etching",
+    "Carving",
+    "Chiseling",
+    "Sculpting",
+    "Forging",
+    "Tempering",
+    "Annealing",
+    "Calibrating",
+    "Synchronizing",
+    "Sequencing",
+    "Interleaving",
+    "Compacting",
+    "Densifying",
+    "Canonicalizing",
+    "Curating",
+    "Shepherding",
+    "Marshalling",
+    "Funneling",
+    "Grounding",
+    "Anchoring",
+    "Illuminating",
+    "Conjuring",
+    "Juggling",
+    "Wrangling",
+    "Untangling",
+    "Unsnarling",
+    "Puzzling",
+    "Scheming",
+    "Machinating",
+    "Whispering",
+    "Summoning",
+    "Brewing",
+    "Steeping",
+    "Percolating",
+    "Marinating",
+    "Fermenting",
+    "Incubating",
+    "Hatching",
+    "Gobbling",
+    "Nibbling",
+    "Munching",
+    "Chewing",
+    "Digesting",
+    "Rummaging",
+    "Scavenging",
+    "Foraging",
+    "Poking",
+    "Prodding",
+    "Tickling",
+    "Massaging",
+    "Jiggling",
+    "Shimmying",
+    "Scooting",
+    "Zipping",
+    "Zooming",
+    "Whizzing",
+    "Bleeping",
+    "Blooping",
+    "Beeping",
+    "Booping",
+    "Tinkering",
+    "Fiddling",
+    "Doodling",
+    "Noodling",
+    "Goblinizing",
+    "Wizarding",
+    "Enchanting",
+    "Spellcasting",
+    "Alchemizing",
+    "Treasure-hunting",
+    "Dragon-wrangling",
+)
+
+
+def _clean_words(items: Iterable[str]) -> tuple[str, ...]:
+
+    seen: set[str] = set()
+    out: list[str] = []
+    for it in items:
+        w = str(it or "").strip()
+        if not w:
+            continue
+        if " " in w:
+            continue
+        if not w.isalpha():
+            continue
+        if not w.lower().endswith("ing"):
+            continue
+        w = w[0].upper() + w[1:]
+        if w in seen:
+            continue
+        seen.add(w)
+        out.append(w)
+    return tuple(out)
+
+
+STATUS_WORDS: tuple[str, ...] = _clean_words(_STATUS_WORDS_RAW)
+
+if len(STATUS_WORDS) < 50:  # pragma: no cover
+    STATUS_WORDS = ("Thinking", "Working", "Responding")
+
+
+@dataclass
+class _DeckRotator:
+    words: tuple[str, ...]
+    rng: random.Random
+    lock: threading.Lock = field(default_factory=threading.Lock)
+    deck: Deque[str] = field(default_factory=deque)
+
+    def next(self, *, default: str = "Thinking") -> str:
+        if not self.words:
+            return default
+
+        with self.lock:
+            if not self.deck:
+                items = list(self.words)
+                self.rng.shuffle(items)
+                self.deck.extend(items)
+
+            try:
+                return self.deck.popleft()
+            except Exception:
+                return default
+
+
+@lru_cache(maxsize=1)
+def _rotator() -> _DeckRotator:
+    seed = time.time_ns() & 0xFFFFFFFF
+    return _DeckRotator(words=STATUS_WORDS, rng=random.Random(seed))
+
+
+def next_status_word(*, default: str = "Thinking") -> str:
+    return _rotator().next(default=default)

{kiwi_code-0.0.28 → kiwi_code-0.0.30}/uv.lock

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

kiwi_code-0.0.28/src/kiwi_tui/random_words.py

@@ -1,80 +0,0 @@
-from functools import lru_cache
-
-
-@lru_cache(maxsize=1)
-def _ww() -> object | None:
-    try:
-        from wonderwords import RandomWord  # type: ignore
-
-        return RandomWord()
-    except Exception:
-        return None
-
-
-def _to_present_participle(verb: str) -> str:
-    v = (verb or "").strip()
-    if not v:
-        return ""
-    w = v.lower()
-
-    # Common irregulars / spelling rules that a simple suffix approach misses.
-    irregular = {
-        "be": "being",
-        "see": "seeing",
-        "flee": "fleeing",
-        "knee": "kneeing",
-        "die": "dying",
-        "tie": "tying",
-        "lie": "lying",
-    }
-    if w in irregular:
-        return irregular[w].capitalize()
-
-    # ie -> ying (die -> dying).
-    if w.endswith("ie") and len(w) > 2:
-        return (w[:-2] + "ying").capitalize()
-
-    # Drop trailing e (make -> making), but keep ee/ye/oe (see -> seeing).
-    if w.endswith("e") and not w.endswith(("ee", "ye", "oe")) and len(w) > 1:
-        return (w[:-1] + "ing").capitalize()
-
-    # Verbs ending in 'ic' often add 'k' (panic -> panicking).
-    if w.endswith("ic") and len(w) > 2:
-        return (w + "king").capitalize()
-
-    vowels = set("aeiou")
-    # Double final consonant for short CVC words with a/i/o/u vowel (run -> running).
-    if (
-        3 <= len(w) <= 4
-        and w[-1] not in vowels
-        and w[-1] not in "wxy"
-        and w[-2] in vowels
-        and w[-2] != "e"
-        and w[-3] not in vowels
-    ):
-        return (w + w[-1] + "ing").capitalize()
-
-    return (w + "ing").capitalize()
-
-
-def random_verb(*, default: str = "Thinking") -> str:
-    """Return a random present-participle verb for display (e.g. "Searching")."""
-    rw = _ww()
-    if rw is None:
-        return default
-
-    try:
-        # wonderwords supports parts_of_speech filtering.
-        word = rw.word(include_parts_of_speech=["verbs"])  # type: ignore[attr-defined]
-        word = str(word or "").strip()
-        if not word:
-            return default
-        ing = _to_present_participle(word)
-        return ing if ing else default
-    except Exception:
-        return default
-
-
-# Backward-compat alias (older code used adjectives).
-def random_adjective(*, default: str = "Curious") -> str:  # pragma: no cover
-    return default