kash-shell 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

kash/xonsh_custom/custom_shell.py

@@ -1,15 +1,17 @@
 import os
-import sys
+import signal
 import threading
 import time
 from collections.abc import Callable
 from os.path import expanduser
-from typing import cast
+from subprocess import CalledProcessError
+from types import TracebackType
+from typing import TypeAlias, cast
 
 import xonsh.tools as xt
 from prompt_toolkit.formatted_text import FormattedText
 from pygments.token import Token
-from strif import abbrev_str
+from strif import abbrev_str, quote_if_needed
 from typing_extensions import override
 from xonsh.built_ins import XSH
 from xonsh.environ import xonshrc_context
@@ -27,7 +29,7 @@ from kash.config import colors
 from kash.config.lazy_imports import import_start_time  # usort:skip
 from kash.config.logger import get_console, get_log_settings, get_logger
 from kash.config.settings import APP_NAME, find_rcfiles
-from kash.config.text_styles import SPINNER, STYLE_ASSISTANCE
+from kash.config.text_styles import SPINNER, STYLE_ASSISTANCE, STYLE_HINT
 from kash.help.assistant import AssistanceType
 from kash.shell.output.shell_output import cprint
 from kash.shell.ui.shell_syntax import is_assist_request_str
@@ -108,12 +110,33 @@ class CustomPTKPromptFormatter(PTKPromptFormatter):
         return super().__call__(template=cast(str, template), **kwargs)
 
 
+def exit_code_str(e: CalledProcessError) -> str:
+    """
+    Prettier version of `CalledProcessError.__str__()`.
+    """
+    if isinstance(e.cmd, list):
+        cmd = "`" + " ".join(quote_if_needed(c) for c in e.cmd) + "`"
+    else:
+        cmd = str(e.cmd)
+    if e.returncode and e.returncode < 0:
+        try:
+            signal_name = signal.Signals(-e.returncode).name
+            return f"Command died with {signal_name} ({e.returncode}): {cmd}"
+        except ValueError:
+            return f"Command died with unknown signal {e.returncode}: {cmd}"
+    else:
+        return f"Command returned non-zero exit status {e.returncode}: {cmd}"
+
+
 # Base shell can be ReadlineShell or PromptToolkitShell.
 # Completer can be RankingCompleter or the standard Completer.
 # from xonsh.completer import Completer
 # from xonsh.shells.readline_shell import ReadlineShell
 from xonsh.shells.ptk_shell import PromptToolkitShell
 
+ExcInfo: TypeAlias = tuple[type[BaseException], BaseException, TracebackType]
+OptExcInfo: TypeAlias = ExcInfo | tuple[None, None, None]
+
 
 class CustomAssistantShell(PromptToolkitShell):
     """
@@ -122,7 +145,6 @@ class CustomAssistantShell(PromptToolkitShell):
     We're trying to reuse code where possible but need to change some of xonsh's
     behavior. Note event hooks in xonsh do let you customize handling but don't
     let you disable xonsh's processing, so it seems like this is necessary.
-    so it seems like this is necessary.
     """
 
     def __init__(self, **kwargs):
@@ -186,16 +208,24 @@ class CustomAssistantShell(PromptToolkitShell):
         exc_info = (None, None, None)
         try:
             log.info("Running shell code: %r", src)
-            exc_info = run_compiled_code(code, self.ctx, None, "single")
-            if exc_info != (None, None, None):
-                raise exc_info[1]  # pyright: ignore
+            exc_info: OptExcInfo = run_compiled_code(code, self.ctx, None, "single")  # pyright: ignore
+            log.debug("Completed shell code: %r", src)
+            _type, exc, _traceback = exc_info
+            if exc:
+                log.info("Shell exception info: %s", exc)
+                raise exc
             ts1 = time.time()
             if hist is not None and hist.last_cmd_rtn is None:
                 hist.last_cmd_rtn = 0  # returncode for success
-            log.info("Shell code completed successfully: %s", src)
+        except CalledProcessError as e:
+            # No point in logging stack trace here as it is only the shell stack,
+            # not the original code.
+            log.warning("%s", exit_code_str(e))
+            cprint("See `logs` for more details.", style=STYLE_HINT)
+            # print(e.args[0], file=sys.stderr)
         except xt.XonshError as e:
             log.info("Shell exception details: %s", e, exc_info=True)
-            print(e.args[0], file=sys.stderr)
+            # print(e.args[0], file=sys.stderr)
             if hist is not None and hist.last_cmd_rtn is None:  # pyright: ignore
                 hist.last_cmd_rtn = 1  # return code for failure
         except (SystemExit, KeyboardInterrupt) as err:
@@ -323,7 +353,9 @@ def customize_xonsh_settings(is_interactive: bool):
         # Disable suggest for command not found errors (we handle this ourselves).
         "SUGGEST_COMMANDS": False,
         # TODO: Consider enabling and adapting auto-suggestions.
-        "AUTO_SUGGEST": False,
+        "AUTO_SUGGEST": True,
+        # Show auto-suggestions in the completion menu.
+        "AUTO_SUGGEST_IN_COMPLETIONS": False,
         # Completions can be "none", "single", "multi", or "readline".
         # "single" lets us have rich completions with descriptions alongside.
         # https://xon.sh/envvars.html#completions-display
@@ -445,7 +477,7 @@ def start_shell(single_command: str | None = None, ready_event: threading.Event
 
     # If we want to replicate all the xonsh settings including .xonshrc, we could call
     # start_services(). It may be problematic to support all xonsh enhancements, however,
-    # so let's only load ~/.kashrc files.
+    # so let's only load ~/.config/kash/kashrc files.
     load_rcfiles(execer, ctx)
 
     # Imports are so slow we will need to improve this. Let's time it.

kash/xonsh_custom/customize_prompt.py

@@ -1,3 +1,4 @@
+import os
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
@@ -29,8 +30,10 @@ class PromptInfo:
     workspace_details: str
     is_global_ws: bool
     cwd_str: str
+    cwd_short_str: str
     cwd_details: str
     cwd_in_workspace: bool
+    cwd_in_home: bool
 
 
 def get_prompt_info() -> PromptInfo:
@@ -42,28 +45,39 @@ def get_prompt_info() -> PromptInfo:
     workspace_details = f"Workspace at {ws.base_dir}"
 
     cwd = Path(".").resolve()
-    if cwd.is_relative_to(ws.base_dir):
-        cwd_in_workspace = True
+    cwd_in_home = cwd.is_relative_to(Path.home())
+    cwd_in_workspace = cwd.is_relative_to(ws.base_dir)
+    if cwd_in_workspace:
         rel_cwd = cwd.relative_to(ws.base_dir)
         if rel_cwd != Path("."):
             cwd_str = str(rel_cwd)
         else:
             cwd_str = ""
-    elif cwd.is_relative_to(Path.home()):
-        cwd_in_workspace = False
+        cwd_short_str = cwd_str
+    elif cwd_in_home:
         rel_to_home = cwd.relative_to(Path.home())
-        if rel_to_home != Path("."):
-            cwd_str = "~/" + rel_to_home.as_posix()
+        if cwd == Path.home():
+            cwd_str = cwd_short_str = "~"
+        elif cwd.parent == Path.home():
+            cwd_str = cwd_short_str = os.path.join("~", cwd.name)
         else:
-            cwd_str = "~"
+            cwd_str = "~/" + str(rel_to_home)
+            # Show only last two levels of dirs when inside home.
+            cwd_short_str = os.path.join(cwd.parent.name, cwd.name)
     else:
-        cwd_in_workspace = False
-        cwd_str = cwd.as_posix()
+        cwd_str = cwd_short_str = str(cwd)
 
     cwd_details = f"Current directory at {cwd}"
 
     return PromptInfo(
-        ws_name, workspace_details, is_global_ws, cwd_str, cwd_details, cwd_in_workspace
+        ws_name,
+        workspace_details,
+        is_global_ws,
+        cwd_str,
+        cwd_short_str,
+        cwd_details,
+        cwd_in_workspace,
+        cwd_in_home,
     )
 
 
@@ -167,17 +181,21 @@ def kash_xonsh_prompt() -> FormattedText:
     ).as_ptk_tokens(style=workspace_color)
 
     cwd_style = settings.ptk_style_bright if info.cwd_in_workspace else settings.ptk_style_normal
-    # Use two-line prompt if cwd is outside workspace, one-line prompt otherwise.
-    if info.cwd_str and not info.cwd_in_workspace:
+    # Separator could be "\n" if you like a 2-line prompt.
+    # separator = "\n" + settings.prompt_prefix
+    separator = ""
+    # Using shorter cwd str.
+    cwd_str = info.cwd_short_str
+    # If outside the workspace, show both workspace and cwd.
+    if info.cwd_short_str and not info.cwd_in_workspace:
         cwd_tokens = (
-            [(settings.ptk_style_dim, "\n" + settings.prompt_prefix)]
-            + text_with_tooltip(info.cwd_str, hover_text=info.cwd_details).as_ptk_tokens(
-                style=cwd_style
-            )
+            [(settings.ptk_style_dim, separator)]
+            + text_with_tooltip(cwd_str, hover_text=info.cwd_details).as_ptk_tokens(style=cwd_style)
             + [(settings.ptk_style_dim, " ")]
         )
-    elif info.cwd_str:
-        cwd_tokens = text_with_tooltip(info.cwd_str, hover_text=info.cwd_details).as_ptk_tokens(
+    elif cwd_str:
+        # If inside the workspace, show just cwd.
+        cwd_tokens = text_with_tooltip(cwd_str, hover_text=info.cwd_details).as_ptk_tokens(
             style=cwd_style
         )
     else:
@@ -187,9 +205,9 @@ def kash_xonsh_prompt() -> FormattedText:
     ptk_tokens = (
         settings.hrule
         + [(settings.ptk_style_dim, settings.prompt_prefix)]
-        + [
-            (settings.ptk_style_dim, "workspace: "),
-        ]
+        # + [
+        #     (settings.ptk_style_dim, "ws: "),
+        # ]
         + workspace_tokens
         + [
             (settings.ptk_style_dim, " "),

kash/xonsh_custom/load_into_xonsh.py

@@ -1,51 +1,49 @@
-from kash.config.setup import setup
-from kash.config.text_styles import LOGO_NAME, STYLE_HINT
-from kash.xonsh_custom.shell_load_commands import (
-    is_interactive,
-    log_command_action_info,
-    reload_shell_commands_and_actions,
-    set_env,
-)
+from kash.config.setup import kash_setup
 
-setup(rich_logging=True)  # Set up logging first.
+kash_setup(rich_logging=True)  # Set up logging first.
 
 import time
 
+from clideps.pkgs.pkg_check import pkg_check
 from xonsh.built_ins import XSH
 from xonsh.prompt.base import PromptFields
 
 from kash.commands.base.general_commands import self_check
-from kash.commands.help import doc_commands
+from kash.commands.help.welcome import welcome
 from kash.config.logger import get_logger
-from kash.config.settings import check_kerm_code_support
-from kash.local_server.local_server import start_local_server
+from kash.config.settings import RECOMMENDED_PKGS, check_kerm_code_support
+from kash.config.text_styles import LOGO_NAME, STYLE_HINT
+from kash.local_server.local_server import start_ui_server
 from kash.local_server.local_url_formatters import enable_local_urls
-from kash.shell.clideps.pkg_deps import pkg_check
+from kash.mcp.mcp_server_commands import start_mcp_server
 from kash.shell.output.shell_output import PrintHooks, cprint
 from kash.shell.version import get_version_tag
 from kash.workspaces import current_ws
 from kash.xonsh_custom.customize_prompt import get_prompt_info, kash_xonsh_prompt
+from kash.xonsh_custom.shell_load_commands import (
+    is_interactive,
+    log_command_action_info,
+    reload_shell_commands_and_actions,
+    set_env,
+)
 from kash.xonsh_custom.xonsh_completers import load_completers
+from kash.xonsh_custom.xonsh_keybindings import add_key_bindings
 from kash.xonsh_custom.xonsh_modern_tools import modernize_shell
 
 log = get_logger(__name__)
 
 
-def _kash_workspace_str() -> str:
-    return get_prompt_info().workspace_name
-
-
 def _shell_interactive_setup():
-    from kash.xonsh_custom.xonsh_completers import add_key_bindings
-
     # Set up a prompt field for the workspace string.
     fields = PromptFields(XSH)
-    fields["workspace_str"] = _kash_workspace_str
+    prompt_info = get_prompt_info()
+    fields["workspace_str"] = prompt_info.workspace_name
+    fields["cwd_short_str"] = prompt_info.cwd_short_str
     set_env("PROMPT_FIELDS", fields)
 
     # Set up the prompt and title template.
     set_env("PROMPT", kash_xonsh_prompt)
-    set_env("TITLE", LOGO_NAME + " - {workspace_str}")
+    set_env("TITLE", LOGO_NAME + " - {workspace_str} - {cwd_short_str}")
 
     add_key_bindings()
 
@@ -58,12 +56,12 @@ def load_into_xonsh():
     """
 
     if is_interactive():
+        # Do welcome first since init could take a few seconds.
+        welcome()
+
         # Do first so in case there is an error, the shell prompt etc works as expected.
         _shell_interactive_setup()
 
-        # Then do welcome first since init could take a few seconds.
-        doc_commands.welcome()
-
         def load():
             load_start_time = time.time()
 
@@ -91,20 +89,21 @@ def load_into_xonsh():
         # Currently only Kerm supports our advanced UI with Kerm codes.
         supports_kerm_codes = check_kerm_code_support()
         if supports_kerm_codes:
-            start_local_server()
+            start_ui_server()
             enable_local_urls(True)
         else:
             cprint(
-                "If your terminal supports it, you may use `start_local_server` to enable local links.",
+                "If your terminal supports it, you may use `start_ui_server` to enable local links.",
                 style=STYLE_HINT,
             )
+        start_mcp_server()
 
         cprint()
         log_command_action_info()
 
         current_ws()  # Validates and logs info for user.
 
-        pkg_check().warn_if_missing()
+        pkg_check().warn_if_missing(*RECOMMENDED_PKGS)
 
     else:
         reload_shell_commands_and_actions()

kash/xonsh_custom/shell_load_commands.py

@@ -1,8 +1,8 @@
 from kash.actions import get_loaded_kits
-from kash.config.setup import setup
+from kash.config.setup import kash_setup
 from kash.config.text_styles import COLOR_VALUE, STYLE_HINT
 
-setup(rich_logging=True)  # Set up logging first.
+kash_setup(rich_logging=True)  # Set up logging first.
 
 from collections.abc import Callable
 from typing import TYPE_CHECKING, TypeVar

kash/xonsh_custom/xonsh_completers.py

@@ -1,14 +1,8 @@
-import re
 from dataclasses import dataclass
 from typing import Any, cast
 
 from funlog import log_calls
-from prompt_toolkit import search
-from prompt_toolkit.application import get_app
-from prompt_toolkit.filters import Condition
-from prompt_toolkit.key_binding import KeyBindings, merge_key_bindings
-from prompt_toolkit.key_binding.key_processor import KeyPressEvent
-from prompt_toolkit.shortcuts import print_formatted_text
+from strif import AtomicVar
 from xonsh.built_ins import XSH
 from xonsh.completers.completer import add_one_completer
 from xonsh.completers.tools import (
@@ -19,7 +13,6 @@ from xonsh.completers.tools import (
 )
 from xonsh.parsers.completion_context import CommandContext
 
-from kash.actions.core.assistant_chat import assistant_chat
 from kash.config.logger import get_logger
 from kash.exec.action_registry import get_all_actions_defaults
 from kash.exec.command_registry import get_all_commands
@@ -34,8 +27,6 @@ from kash.shell.completions.shell_completions import (
     get_std_command_completions,
     trace_completions,
 )
-from kash.shell.ui.shell_syntax import assist_request_str
-from kash.utils.common.atomic_var import AtomicVar
 from kash.utils.errors import ApiResultError, InvalidState
 from kash.xonsh_custom.command_nl_utils import as_nl_words, looks_like_nl
 from kash.xonsh_custom.shell_which import is_valid_command
@@ -351,7 +342,7 @@ def _params_for_command(command_name: str) -> list[Param[Any]] | None:
     if command:
         return annotate_param_info(command)
     elif action:
-        return list(action.params)
+        return action.shell_params
     else:
         return None
 
@@ -482,244 +473,6 @@ def options_enum_completer(context: CompletionContext) -> CompleterResult:
 # - `source_code`
 
 
-@Condition
-def is_unquoted_assist_request():
-    app = get_app()
-    buf = app.current_buffer
-    text = buf.text.strip()
-    is_default_buffer = buf.name == "DEFAULT_BUFFER"
-    has_prefix = text.startswith("?") and not (text.startswith('? "') or text.startswith("? '"))
-    return is_default_buffer and has_prefix
-
-
-_command_regex = re.compile(r"^[a-zA-Z0-9_-]+$")
-
-_python_keyword_regex = re.compile(
-    r"assert|async|await|break|class|continue|def|del|elif|else|except|finally|"
-    r"for|from|global|if|import|lambda|nonlocal|pass|raise|return|try|while|with|yield"
-)
-
-
-def _extract_command_name(text: str) -> str | None:
-    text = text.split()[0]
-    if _python_keyword_regex.match(text):
-        return None
-    if _command_regex.match(text):
-        return text
-    return None
-
-
-@Condition
-def whitespace_only() -> bool:
-    app = get_app()
-    buf = app.current_buffer
-    return not buf.text.strip()
-
-
-@Condition
-def is_typo_command() -> bool:
-    """
-    Is the command itself invalid? Should be conservative, so we can suppress
-    executing it if it is definitely a typo.
-    """
-
-    app = get_app()
-    buf = app.current_buffer
-    text = buf.text.strip()
-
-    is_default_buffer = buf.name == "DEFAULT_BUFFER"
-    if not is_default_buffer:
-        return False
-
-    # Assistant NL requests always allowed.
-    has_assistant_prefix = text.startswith("?") or text.rstrip().endswith("?")
-    if has_assistant_prefix:
-        return False
-
-    # Anything more complex is probably Python.
-    # TODO: Do a better syntax parse of this as Python, or use xonsh's algorithm.
-    for s in ["\n", "(", ")"]:
-        if s in text:
-            return False
-
-    # Empty command line allowed.
-    if not text:
-        return False
-
-    # Now look at the command.
-    command_name = _extract_command_name(text)
-
-    # Python or missing command is fine.
-    if not command_name:
-        return False
-
-    # Recognized command.
-    if is_valid_command(command_name):
-        return False
-
-    # Okay it's almost certainly a command typo.
-    return True
-
-
-@Condition
-def is_completion_menu_active() -> bool:
-    app = get_app()
-    return app.current_buffer.complete_state is not None
-
-
-@Condition
-def could_show_more_tab_completions() -> bool:
-    return _MULTI_TAB_STATE.value.could_show_more()
-
-
-# Set up prompt_toolkit key bindings.
-def add_key_bindings() -> None:
-    custom_bindings = KeyBindings()
-
-    # Need to be careful only to bind with a filter if the state is suitable.
-    # Only add more completions if we've seen some results but user hasn't pressed
-    # tab a second time yet. Otherwise the behavior should fall back to usual ptk
-    # tab behavior (selecting each completion one by one).
-    @custom_bindings.add("tab", filter=could_show_more_tab_completions)
-    def _(event: KeyPressEvent):
-        """
-        Add a second tab to show more completions.
-        """
-        with _MULTI_TAB_STATE.updates() as state:
-            state.more_results_requested = True
-
-        trace_completions("More completion results requested", state)
-
-        # Restart completions.
-        buf = event.app.current_buffer
-        buf.complete_state = None
-        buf.start_completion()
-
-    @custom_bindings.add("s-tab")
-    def _(event: KeyPressEvent):
-        with _MULTI_TAB_STATE.updates() as state:
-            state.more_results_requested = True
-
-        trace_completions("More completion results requested", state)
-
-        # Restart completions.
-        buf = event.app.current_buffer
-        buf.complete_state = None
-        buf.start_completion()
-
-    @custom_bindings.add(" ", filter=whitespace_only)
-    def _(event: KeyPressEvent):
-        """
-        Map space at the start of the line to `? ` to invoke an assistant question.
-        """
-        buf = event.app.current_buffer
-        if buf.text == " " or buf.text == "":
-            buf.delete_before_cursor(len(buf.text))
-            buf.insert_text("? ")
-        else:
-            buf.insert_text(" ")
-
-    @custom_bindings.add(" ", filter=is_typo_command)
-    def _(event: KeyPressEvent):
-        """
-        If the user types two words and the first word is likely an invalid
-        command, jump back to prefix the whole line with `? ` to make it clear we're
-        in natural language mode.
-        """
-
-        buf = event.app.current_buffer
-        text = buf.text.strip()
-
-        if (
-            buf.cursor_position == len(buf.text)
-            and len(text.split()) >= 2
-            and not text.startswith("?")
-        ):
-            buf.transform_current_line(lambda line: "? " + line)
-            buf.cursor_position += 2
-
-        buf.insert_text(" ")
-
-    @custom_bindings.add("enter", filter=whitespace_only)
-    def _(_event: KeyPressEvent):
-        """
-        Suppress enter if the command line is empty, but add a newline above the prompt.
-        """
-        print_formatted_text("")
-
-    @custom_bindings.add("enter", filter=is_unquoted_assist_request)
-    def _(event: KeyPressEvent):
-        """
-        Automatically add quotes around assistant questions, so there are not
-        syntax errors if the command line contains unclosed quotes etc.
-        """
-
-        buf = event.app.current_buffer
-        text = buf.text.strip()
-
-        question_text = text[1:].strip()
-        if not question_text:
-            # If the user enters an empty assistant request, treat it as a shortcut to go to the assistant chat.
-            buf.delete_before_cursor(len(buf.text))
-            buf.insert_text(assistant_chat.__name__)
-        else:
-            # Convert it to an assistant question starting with a `?`.
-            buf.delete_before_cursor(len(buf.text))
-            buf.insert_text(assist_request_str(question_text))
-
-        buf.validate_and_handle()
-
-    @custom_bindings.add("enter", filter=is_typo_command)
-    def _(event: KeyPressEvent):
-        """
-        Suppress enter and if possible give completions if the command is just not a valid command.
-        """
-
-        buf = event.app.current_buffer
-        buf.start_completion()
-
-    # TODO: Also suppress enter if a command or action doesn't meet the required args,
-    # selection, or preconditions.
-    # Perhaps also have a way to get confirmation if its a rarely used or unexpected command
-    # (based on history/suggestions).
-    # TODO: Add suggested replacements, e.g. df -> duf, top -> btm, etc.
-
-    @custom_bindings.add("@")
-    def _(event: KeyPressEvent):
-        """
-        Auto-trigger item completions after `@` sign.
-        """
-        buf = event.app.current_buffer
-        buf.insert_text("@")
-        buf.start_completion()
-
-    @custom_bindings.add("escape", eager=True, filter=is_completion_menu_active)
-    def _(event: KeyPressEvent):
-        """
-        Close the completion menu when escape is pressed.
-        """
-        event.app.current_buffer.cancel_completion()
-
-    @custom_bindings.add("c-c", eager=True)
-    def _(event):
-        """
-        Control-C to reset the current buffer. Similar to usual behavior but doesn't
-        leave ugly prompt chars.
-        """
-        print_formatted_text("")
-        buf = event.app.current_buffer
-        # Abort reverse search/filtering, clear any selection, and reset the buffer.
-        search.stop_search()
-        buf.exit_selection()
-        buf.reset()
-
-    existing_bindings = __xonsh__.shell.shell.prompter.app.key_bindings  # noqa: F821 # pyright: ignore[reportUndefinedVariable]
-    merged_bindings = merge_key_bindings([existing_bindings, custom_bindings])
-    __xonsh__.shell.shell.prompter.app.key_bindings = merged_bindings  # noqa: F821 # pyright: ignore[reportUndefinedVariable]
-
-    log.info("Added custom %s key bindings.", len(merged_bindings.bindings))
-
-
 def load_completers():
     add_one_completer("command_completer", command_completer, "start")
     add_one_completer("recommended_shell_completer", recommended_shell_completer, "start")