localcode 0.3.62__tar.gz → 0.3.64__tar.gz

{localcode-0.3.62/src/localcode.egg-info → localcode-0.3.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.62
+Version: 0.3.64
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.62 → localcode-0.3.64}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.62"
+version = "0.3.64"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.3.62"
+    __version__ = "0.3.64"

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/agent/helpers.py

@@ -510,15 +510,6 @@ def _execute_tool_result(app: "LocalCodeApp", name: str, args: dict, out: "Outpu
             facts={"tool": name, "ok": False, "plan_mode_blocked": True},
         )
 
-    try:
-        hook = getattr(app, "hooks", None)
-        decision = hook.on_pre_tool_use(name, args) if hook is not None else None
-        if decision is not None and decision.blocked:
-            reason = decision.error or decision.output or "pre-tool hook blocked"
-            return ToolResult(text=f"REJECTED: {reason}", ok=False, facts={"tool": name, "ok": False, "hook_blocked": True})
-    except Exception:
-        pass
-
     # Lint-gate: for source-file writes/edits, snapshot the file before the
     # tool runs so we can auto-revert on syntax-break. Motivation: the model
     # at 2-bit quant has been observed to delete import statements during
@@ -567,19 +558,8 @@ def _execute_tool_result(app: "LocalCodeApp", name: str, args: dict, out: "Outpu
         result = _tools_dispatch_result(name, ToolContext(app=app, out=out), args)
     except Exception as e:
         text = f"Error in {name}: {type(e).__name__}: {e}"
-        try:
-            if getattr(app, "hooks", None) is not None:
-                app.hooks.on_post_tool_use(name, args, text, error=True)
-        except Exception:
-            pass
         return ToolResult(text=text, ok=False, facts={"tool": name, "ok": False, "error_type": type(e).__name__})
 
-    try:
-        if getattr(app, "hooks", None) is not None:
-            app.hooks.on_post_tool_use(name, args, result.text, error=not result.ok)
-    except Exception:
-        pass
-
     if target_path is not None and target_path.exists() and target_path.suffix == ".py":
         # Python: ast.parse is cheap and authoritative.
         import ast as _ast
@@ -596,12 +576,6 @@ def _execute_tool_result(app: "LocalCodeApp", name: str, args: dict, out: "Outpu
                 "user explicitly asked."
             )
             return ToolResult(text=text, ok=False, facts={"tool": name, "ok": False, "path": str(target_path), "reverted": True})
-    if name in _lint_tools:
-        try:
-            if getattr(app, "hooks", None) is not None:
-                app.hooks.on_post_edit(str(args.get("path", "")), result.text, error=not result.ok)
-        except Exception:
-            pass
     return result
 
 

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/agent/loop.py

@@ -784,15 +784,9 @@ def run_agent_loop(
                     f"Compacting conversation (≈{estimate_tokens(messages)} tokens "
                     f"of {ctx_tokens} context → summary)..."
                 )
-                _before_compact_count = len(messages)
                 messages[:] = compact(
                     messages, app.engine, context_window=ctx_tokens, ram_gb=_ram_gb
                 )
-                try:
-                    if getattr(app, "hooks", None) is not None:
-                        app.hooks.on_post_compaction(_before_compact_count, len(messages))
-                except Exception:
-                    pass
         except Exception as _compact_err:
             # Never let compaction failure kill the agent loop — continue
             # with the unchanged messages and let the user see the error.

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/agent/turn_finalization.py

@@ -70,15 +70,6 @@ def finalize_turn(
     """Emit turn_end and persist task/session state."""
     blocked_reason = final_text if loop_exit_reason == "blocked_question" else ""
     completion_status, task_status = status_for_exit(loop_exit_reason)
-    try:
-        hook = getattr(app, "hooks", None)
-        if hook is not None:
-            hook_result = hook.on_pre_completion(final_text, completion_status)
-            if hook_result.blocked:
-                completion_status, task_status = "stopped_early", "failed"
-                blocked_reason = hook_result.error or hook_result.output or "pre-completion hook blocked"
-    except Exception as exc:
-        _emit_finalization_error(turn_id, "pre_completion_hook", exc)
     try:
         from ..events import emit
 

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/app.py

@@ -38,7 +38,6 @@ from .history import HistoryDB
 from .verification import guess_verify_command, run_verification
 from .auto_compact import compact_if_needed
 from .autonomy import AutonomyLevel, apply_autonomy_to_permissions, get_policy
-from .hooks import HookRunner
 from .snapshots import SnapshotStore, create_snapshot
 from .turn_diff import TurnDiffTracker, print_turn_diff
 from .agent.goal import infer_goal_state
@@ -219,15 +218,12 @@ class LocalCodeApp:
         self.history = HistoryDB()  # unified SQLite history
         self.embedding_search = EmbeddingSearch(str(self.repo_root))
         self.perms = PermissionManager()  # tool permissions
-        self.hooks = HookRunner(str(self.repo_root), self.session.session_id, self.runtime_model)
         self.snapshot_store = SnapshotStore()
         self.turn_tracker = TurnDiffTracker(self.repo_root)
         # Apply autonomy mode
         autonomy_level = os.environ.get("LOCALCODE_AUTONOMY", "auto_edit")
         self._autonomy = AutonomyLevel(autonomy_level) if autonomy_level in ("suggest", "auto_edit", "full_auto") else AutonomyLevel.AUTO_EDIT
         apply_autonomy_to_permissions(self.perms, get_policy(self._autonomy))
-        # Run session start hook
-        self.hooks.on_session_start()
         self._spec_executor = SpeculativeExecutor(self.toolkit.execute_tool_calls)
         self._memory = self._load_memory()
         # Per-session notebook directory — a disk-backed "working memory"
@@ -498,11 +494,6 @@ class LocalCodeApp:
             provider=self.config.runtime.provider,
         )
 
-        # Lifecycle hook: user prompt submit
-        hook_result = self.hooks.on_user_prompt_submit(user_text)
-        if hook_result.blocked:
-            self.console.print(f"[dim]  Hook blocked prompt: {hook_result.error or hook_result.output}[/]")
-            return
         # Start turn tracking
         self.turn_tracker.start_turn(watched_files=self.session.pinned_files)
         _turn_start = time.time()

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/config.py

@@ -55,14 +55,7 @@ max_retries = 3
 max_rounds = 0
 thinking_budget_tokens = 0
 
-[search]
-provider = "duckduckgo"
-google_api_key = ""
-google_cx = ""
-brave_api_key = ""
-serpapi_api_key = ""
-
-# [browser] and [voice] sections removed during T0.9 purge.
+# [search], [browser] and [voice] sections removed during T0.9 purge.
 
 [ui]
 show_debug = false
@@ -149,13 +142,9 @@ class RuntimeConfig:
     max_retries: int = 3
 
 
-@dataclass
-class SearchConfig:
-    provider: str = "duckduckgo"
-    google_api_key: str = ""
-    google_cx: str = ""
-    brave_api_key: str = ""
-    serpapi_api_key: str = ""
+# SearchConfig removed — the Google/Brave/SerpAPI web-search path was dead
+# (the agent's web_search tool uses DuckDuckGo directly) and its config keys
+# did nothing.
 
 
 # BrowserConfig / VoiceConfig removed during T0.9 — no UI path fed the
@@ -200,7 +189,6 @@ class TelemetryConfig:
 @dataclass
 class AppConfig:
     runtime: RuntimeConfig
-    search: SearchConfig
     ui: UIConfig
     safety: SafetyConfig = None  # type: ignore[assignment]
     logging: LoggingConfig = None  # type: ignore[assignment]
@@ -225,9 +213,8 @@ def get_home_dir() -> Path:
 def ensure_home_dirs() -> Path:
     """Create `~/.localcode/` and its children, owner-only (0700).
 
-    This tree holds `config.toml` (google / brave / serpapi API keys),
-    `history.db` (every prompt and response), saved sessions and the
-    lexical index. None of it should be readable by other accounts on
+    This tree holds `config.toml`, `history.db` (every prompt and response),
+    saved sessions and the lexical index. None of it should be readable by other accounts on
     the machine, so both the root and each child are created 0700 and
     the root's mode is re-asserted on every call (cheap, and it repairs
     a directory created 0755 by an older version).
@@ -299,13 +286,7 @@ def save_config(config: AppConfig) -> Path:
         f"max_context_chars = {config.runtime.max_context_chars}\n"
         f"request_timeout_seconds = {config.runtime.request_timeout_seconds}\n"
         f"max_retries = {config.runtime.max_retries}\n\n"
-        "[search]\n"
-        f'provider = {_toml_str(config.search.provider)}\n'
-        f'google_api_key = {_toml_str(config.search.google_api_key)}\n'
-        f'google_cx = {_toml_str(config.search.google_cx)}\n'
-        f'brave_api_key = {_toml_str(config.search.brave_api_key)}\n'
-        f'serpapi_api_key = "{config.search.serpapi_api_key}"\n\n'
-        # [browser] / [voice] sections removed during T0.9 purge.
+        # [search] / [browser] / [voice] sections removed during T0.9 purge.
         "[ui]\n"
         f"show_debug = {'true' if config.ui.show_debug else 'false'}\n"
         f'thinking_mode = {_toml_str(config.ui.thinking_mode)}\n'
@@ -333,9 +314,9 @@ def save_config(config: AppConfig) -> Path:
     # final rename.
     with _SAVE_LOCK:
         tmp = path.with_name(f".{path.name}.tmp{os.getpid()}")
-        # config.toml carries google / brave / serpapi API keys. Write the
-        # temp file 0600 BEFORE the rename so the final file is never
-        # world-readable, not even for the instant between rename and chmod.
+        # config.toml can hold sensitive settings. Write the temp file 0600
+        # BEFORE the rename so the final file is never world-readable, not even
+        # for the instant between rename and chmod.
         write_private(tmp, content)
         os.replace(tmp, path)
         chmod_quiet(path, 0o600)
@@ -347,8 +328,8 @@ def load_config() -> AppConfig:
     path = get_config_path()
     if not path.exists():
         init_config_file()
-    # Repair an install from before config.toml was written 0600: this file
-    # holds google / brave / serpapi API keys and was created world-readable.
+    # Repair an install from before config.toml was written 0600: it may have
+    # been created world-readable.
     chmod_quiet(path, 0o600)
     # A config file that fails to parse (hand-edited, or written by an old
     # save_config that didn't escape string values) must not crash launch —
@@ -361,8 +342,7 @@ def load_config() -> AppConfig:
         except Exception:
             data = {}
     runtime_data = data.get("runtime", {})
-    search_data = data.get("search", {})
-    # browser / voice sections removed during T0.9 purge
+    # search / browser / voice sections removed during T0.9 purge
     ui_data = data.get("ui", {})
     runtime = RuntimeConfig(
         provider=os.environ.get("LOCALCODE_PROVIDER", runtime_data.get("provider", "llama_cpp")),
@@ -425,14 +405,7 @@ def load_config() -> AppConfig:
         request_timeout_seconds=int(os.environ.get("LOCALCODE_REQUEST_TIMEOUT_SECONDS", runtime_data.get("request_timeout_seconds", 120))),
         max_retries=int(os.environ.get("LOCALCODE_MAX_RETRIES", runtime_data.get("max_retries", 2))),
     )
-    search = SearchConfig(
-        provider=os.environ.get("LOCALCODE_SEARCH_PROVIDER", search_data.get("provider", "duckduckgo")),
-        google_api_key=os.environ.get("LOCALCODE_GOOGLE_API_KEY", search_data.get("google_api_key", "")),
-        google_cx=os.environ.get("LOCALCODE_GOOGLE_CX", search_data.get("google_cx", "")),
-        brave_api_key=os.environ.get("LOCALCODE_BRAVE_API_KEY", search_data.get("brave_api_key", "")),
-        serpapi_api_key=os.environ.get("LOCALCODE_SERPAPI_API_KEY", search_data.get("serpapi_api_key", "")),
-    )
-    # browser / voice config loaders removed during T0.9 purge.
+    # search / browser / voice config loaders removed during T0.9 purge.
     ui = UIConfig(
         show_debug=str(os.environ.get("LOCALCODE_SHOW_DEBUG", ui_data.get("show_debug", False))).lower() in {"1", "true", "yes", "on"},
         thinking_mode=os.environ.get("LOCALCODE_THINKING_MODE", ui_data.get("thinking_mode", "summary")),
@@ -473,7 +446,7 @@ def load_config() -> AppConfig:
         if not runtime.base_url or "11434" in runtime.base_url:
             runtime.base_url = "http://localhost:8081"
 
-    config = AppConfig(runtime=runtime, search=search,
+    config = AppConfig(runtime=runtime,
                        ui=ui, safety=safety, logging=logging_cfg,
                        telemetry=telemetry_cfg)
 

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/errors.py

@@ -97,9 +97,6 @@ _REGISTRY: list[ErrorCode] = [
               cause="model"),
     ErrorCode("E2110", "Tool denied by permission policy",
               "The user (or session policy) declined this tool call.", cause="user"),
-    ErrorCode("E2111", "Tool blocked by hook",
-              "A configured hook in ~/.localcode/hooks.toml refused the tool call.",
-              cause="user"),
 
     # E3xxx — Runtime / model
     ErrorCode("E3101", "The model stopped responding too early",

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/mcp/__init__.py

@@ -51,7 +51,13 @@ is re-exported here so `from localcode.mcp import ...` is unchanged.
 from __future__ import annotations
 
 from ._bridge import _CONNECT_TIMEOUT, _DEFAULT_TIMEOUT, _EventLoopThread
-from ._config import MCP_CONFIG_PATH, _config_path, load_mcp_config
+from ._config import (
+    MCP_CONFIG_PATH,
+    _config_path,
+    add_mcp_server,
+    load_mcp_config,
+    remove_mcp_server,
+)
 from ._transports import _InMemoryTokenStorage, _build_oauth_provider
 from .client import (
     MCPClient,
@@ -72,6 +78,8 @@ __all__ = [
     # config
     "MCP_CONFIG_PATH",
     "load_mcp_config",
+    "add_mcp_server",
+    "remove_mcp_server",
     # client
     "MCPClient",
     # registry

localcode-0.3.64/src/localcode/mcp/_config.py

@@ -0,0 +1,79 @@
+"""Config loading for the MCP package.
+
+Reads `~/.localcode/mcp.json` (key `mcpServers`), honoring LOCALCODE_HOME
+like the rest of the app.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+
+MCP_CONFIG_PATH = Path.home() / ".localcode" / "mcp.json"
+
+
+def _config_path() -> Path:
+    """Resolve the mcp.json path, honoring LOCALCODE_HOME like the rest of
+    the app (config.get_home_dir). Falls back to ~/.localcode."""
+    override = os.environ.get("LOCALCODE_HOME")
+    if override:
+        return Path(override).expanduser() / "mcp.json"
+    return MCP_CONFIG_PATH
+
+
+def load_mcp_config() -> dict[str, dict]:
+    """Read ~/.localcode/mcp.json. Returns the `mcpServers` dict."""
+    path = _config_path()
+    if not path.is_file():
+        return {}
+    try:
+        return json.loads(path.read_text()).get("mcpServers", {})
+    except Exception:
+        return {}
+
+
+def _read_full_config(path: Path) -> dict:
+    """The whole mcp.json document (not just `mcpServers`), so a write preserves
+    any other keys the user keeps in the file. Empty dict if missing/invalid."""
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text())
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def add_mcp_server(name: str, entry: dict) -> Path:
+    """Add (or replace) one server under `mcpServers` and write mcp.json back,
+    creating the file and its parent directory if needed. Returns the path.
+
+    This is what the in-TUI "add server" form calls so a user never has to
+    hand-edit the JSON. The written shape is exactly what ``load_mcp_config``
+    reads and ``connect_all`` consumes.
+    """
+    path = _config_path()
+    data = _read_full_config(path)
+    servers = data.get("mcpServers")
+    if not isinstance(servers, dict):
+        servers = {}
+    servers[name] = entry
+    data["mcpServers"] = servers
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    return path
+
+
+def remove_mcp_server(name: str) -> bool:
+    """Drop one server from mcp.json. True if it was there, False otherwise."""
+    path = _config_path()
+    data = _read_full_config(path)
+    servers = data.get("mcpServers")
+    if not isinstance(servers, dict) or name not in servers:
+        return False
+    del servers[name]
+    data["mcpServers"] = servers
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    return True

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/toolkit.py

@@ -940,14 +940,7 @@ class LocalCodeToolkit:
     # ── Web search implementations ───────────────────────────────────────
 
     def _web_search(self, query: str, max_results: int = 5) -> str:
-        provider = self.config.search.provider.lower()
-        if provider == "google":
-            return self._google_search(query, max_results)
-        if provider == "brave":
-            return self._brave_search(query, max_results)
-        if provider == "serpapi":
-            return self._serpapi_search(query, max_results)
-        # Default: try DuckDuckGo, fall back to scraping if needed
+        # Try DuckDuckGo, fall back to scraping if needed.
         result = self._duckduckgo_search(query, max_results)
         if result == "No results found." or "Search error" in result:
             # Fallback: try bash curl to get a quick answer
@@ -1017,46 +1010,6 @@ class LocalCodeToolkit:
             return f"Search error: {exc}"
         return "\n\n".join(results) if results else "No results found."
 
-    def _google_search(self, query: str, max_results: int = 5) -> str:
-        if not self.config.search.google_api_key or not self.config.search.google_cx:
-            return "Google search not configured. Set LOCALCODE_GOOGLE_API_KEY and LOCALCODE_GOOGLE_CX."
-        response = httpx.get(
-            "https://www.googleapis.com/customsearch/v1",
-            params={"key": self.config.search.google_api_key, "cx": self.config.search.google_cx, "q": query, "num": max_results},
-            timeout=20.0,
-        )
-        response.raise_for_status()
-        items = response.json().get("items", [])
-        results = [f"{item.get('title', '')}\n{item.get('snippet', '')}\n{item.get('link', '')}" for item in items]
-        return "\n\n".join(results) if results else "No results found."
-
-    def _brave_search(self, query: str, max_results: int = 5) -> str:
-        if not self.config.search.brave_api_key:
-            return "Brave search not configured. Set LOCALCODE_BRAVE_API_KEY."
-        response = httpx.get(
-            "https://api.search.brave.com/res/v1/web/search",
-            params={"q": query, "count": max_results},
-            headers={"X-Subscription-Token": self.config.search.brave_api_key},
-            timeout=20.0,
-        )
-        response.raise_for_status()
-        results_data = response.json().get("web", {}).get("results", [])
-        results = [f"{item.get('title', '')}\n{item.get('description', '')}\n{item.get('url', '')}" for item in results_data]
-        return "\n\n".join(results) if results else "No results found."
-
-    def _serpapi_search(self, query: str, max_results: int = 5) -> str:
-        if not self.config.search.serpapi_api_key:
-            return "SerpAPI not configured. Set LOCALCODE_SERPAPI_API_KEY."
-        response = httpx.get(
-            "https://serpapi.com/search.json",
-            params={"engine": "google", "q": query, "api_key": self.config.search.serpapi_api_key, "num": max_results},
-            timeout=20.0,
-        )
-        response.raise_for_status()
-        items = response.json().get("organic_results", [])
-        results = [f"{item.get('title', '')}\n{item.get('snippet', '')}\n{item.get('link', '')}" for item in items]
-        return "\n\n".join(results) if results else "No results found."
-
     # ── Plugin & MCP ─────────────────────────────────────────────────────
 
     def _register_plugin_tools(self) -> None:
@@ -1273,17 +1226,7 @@ class LocalCodeToolkit:
             client.close()
 
     def search_status(self) -> tuple[str, str]:
-        provider = self.config.search.provider.lower()
-        if provider == "google":
-            ok = bool(self.config.search.google_api_key and self.config.search.google_cx)
-            return provider, "configured" if ok else "missing_api_key_or_cx"
-        if provider == "brave":
-            ok = bool(self.config.search.brave_api_key)
-            return provider, "configured" if ok else "missing_api_key"
-        if provider == "serpapi":
-            ok = bool(self.config.search.serpapi_api_key)
-            return provider, "configured" if ok else "missing_api_key"
-        return provider, "configured"
+        return "duckduckgo", "configured"
 
     def diagnostics(self) -> list[str]:
         rows: list[str] = []

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/tui/app.py

@@ -238,10 +238,9 @@ class LocalCodeTUI(App):
                 # Even if config load fails (truly fresh install),
                 # build a minimal default so the screen has SOMETHING
                 # to read.
-                from ..config import AppConfig, RuntimeConfig, SearchConfig, UIConfig, SafetyConfig, LoggingConfig
+                from ..config import AppConfig, RuntimeConfig, UIConfig, SafetyConfig, LoggingConfig
                 self.config = AppConfig(
                     runtime=RuntimeConfig(),
-                    search=SearchConfig(),
                     ui=UIConfig(),
                     safety=SafetyConfig(),
                     logging=LoggingConfig(),

{localcode-0.3.62 → localcode-0.3.64}/src/localcode/tui/screens/chat.py

@@ -1293,21 +1293,8 @@ class ChatScreen(Screen):
         # scroll the chat — these keys are how, so they must be discoverable.
         log.append_info(
             "Ctrl+U/D scroll · Shift+↑/↓ line · Home/End jump · "
-            "Shift+Enter newline · paste to attach an image"
+            "Shift+Enter newline · paste to attach an image · ! runs a shell command"
         )
-        # Warn if this repo ships hooks that shell out but haven't been trusted.
-        # They are NOT loaded (see hooks.py) — this just tells the user they
-        # exist and how to enable them after review.
-        try:
-            if getattr(getattr(self.tui, "engine", None), "hooks", None) is not None and \
-                    getattr(self.tui.engine.hooks, "untrusted_project_hooks", False):
-                log.append_info(
-                    "⚠ This repo has .localcode/hooks.toml (runs shell commands). "
-                    "It is disabled. Review the file, then relaunch with "
-                    "LOCALCODE_TRUST_PROJECT_HOOKS=1 to enable it."
-                )
-        except Exception:
-            pass
         # If the user launched with --resume, the TUI app stored prior
         # messages in `_pending_resume_messages`. Replay them into the
         # chat log now so the conversation picks up visually where it
@@ -2109,6 +2096,21 @@ class ChatScreen(Screen):
                 self._slash_window = 0
                 menu.remove_class("active")
                 status_bar.remove_class("hidden")
+        elif text.startswith("!"):
+            # Shell-mode affordance, mirroring the leading CLI agents' "! for
+            # shell" hint. `!cmd` runs in the user's shell (_run_bash) and the
+            # output lands in the log. Keep _slash_matches empty so Enter falls
+            # through to _submit_message (which runs the command) instead of
+            # the slash menu trying to select a row.
+            self._slash_matches = []
+            self._slash_selected = 0
+            self._slash_window = 0
+            menu.update(
+                "[bold]!  shell mode[/]  "
+                "[dim]Enter runs this command in your shell[/]"
+            )
+            menu.add_class("active")
+            status_bar.add_class("hidden")
         else:
             self._slash_matches = []
             self._slash_selected = 0