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

kash/workspaces/workspaces.py

@@ -7,18 +7,14 @@ from typing import TYPE_CHECKING, TypeVar
 
 from prettyfmt import fmt_path
 
-from kash.config.logger import get_logger, reset_log_root
+from kash.config.logger import get_logger, reset_rich_logging
 from kash.config.settings import (
     GLOBAL_WS_NAME,
-    RECOMMENDED_API_KEYS,
-    get_global_ws_dir,
-    get_ws_root_dir,
     global_settings,
     resolve_and_create_dirs,
 )
 from kash.file_storage.metadata_dirs import MetadataDirs
 from kash.model.params_model import GLOBAL_PARAMS, RawParamValues
-from kash.shell.clideps.api_keys import print_api_key_setup
 from kash.utils.errors import FileNotFound, InvalidInput, InvalidState
 from kash.utils.file_utils.ignore_files import IgnoreFilter, is_ignored_default
 from kash.workspaces.workspace_registry import WorkspaceInfo, get_ws_registry
@@ -128,7 +124,7 @@ def resolve_ws(name: str | Path) -> WorkspaceInfo:
             resolved = name
             parent_dir = resolved.parent
         else:
-            parent_dir = get_ws_root_dir()
+            parent_dir = global_settings().ws_root_dir
             resolved = parent_dir / name
     elif name_str.startswith(".") or name_str.startswith("/"):
         # Explicit paths respected otherwise use workspace root.
@@ -136,7 +132,7 @@ def resolve_ws(name: str | Path) -> WorkspaceInfo:
         parent_dir = resolved.parent
         name = resolved.name
     else:
-        parent_dir = get_ws_root_dir()
+        parent_dir = global_settings().ws_root_dir
         resolved = parent_dir / Path(name_str)
 
     ws_name = check_strict_workspace_name(resolved.name)
@@ -161,7 +157,7 @@ def get_ws(name_or_path: str | Path, auto_init: bool = True) -> "FileStore":
 
 @cache
 def global_ws_dir() -> Path:
-    kb_path = resolve_and_create_dirs(get_global_ws_dir(), is_dir=True)
+    kb_path = resolve_and_create_dirs(global_settings().global_ws_dir, is_dir=True)
     log.debug("Global workspace path: %s", kb_path)
     return kb_path
 
@@ -190,7 +186,7 @@ def switch_to_ws(base_dir: Path) -> "FileStore":
     ws_dirs = MetadataDirs(base_dir=info.base_dir, is_global_ws=info.is_global_ws)
 
     # Use the global log root for the global_ws, and the workspace log root otherwise.
-    reset_log_root(None, info.name if not info.is_global_ws else None)
+    reset_rich_logging(None, info.name if not info.is_global_ws else None)
 
     if info.is_global_ws:
         # If not in a workspace, use the global cache locations.
@@ -237,8 +233,6 @@ def current_ws(silent: bool = False) -> "FileStore":
     ws = switch_to_ws(base_dir)
 
     if not silent:
-        # Delayed, once-only logging of any setup warnings.
-        print_api_key_setup(RECOMMENDED_API_KEYS, once=True)
         ws.log_workspace_info(once=True)
 
     return ws

kash/xonsh_custom/command_nl_utils.py

@@ -3,20 +3,16 @@ import re
 from prettyfmt import fmt_words
 
 INNER_PUNCT_CHARS = r"-'’–—"
-OUTER_PUNCT_CHARS = r".,'\"“”‘’:!?()"
+OUTER_PUNCT_CHARS = r".,'\"" "''':;!?()"
 
-WORD_PAT = (
-    rf"[{OUTER_PUNCT_CHARS}]{{0,2}}[\w]+(?:[{INNER_PUNCT_CHARS}\w]+)*[{OUTER_PUNCT_CHARS}]{{0,2}}"
-)
-"""
-Pattern to match a word in natural language text (i.e. words and natural
-language-only punctuation).
-"""
+ESCAPED_INNER_PUNCT_CHARS = re.escape(INNER_PUNCT_CHARS)
+ESCAPED_OUTER_PUNCT_CHARS = re.escape(OUTER_PUNCT_CHARS)
 
-NL_PAT = rf"^{WORD_PAT}(?:\s+{WORD_PAT})*$"
-"""
-Pattern to match natural language text in a command line.
-"""
+PUNCT_SEQ_RE = re.compile(rf"[{ESCAPED_INNER_PUNCT_CHARS}{ESCAPED_OUTER_PUNCT_CHARS}]+")
+
+ONLY_WORDS_RE = re.compile(rf"^[\w\s{ESCAPED_INNER_PUNCT_CHARS}]*$")
+
+PLAIN_WORD_RE = re.compile(r"^\w.*\w$")
 
 
 def as_nl_words(text: str) -> str:
@@ -30,18 +26,25 @@ def as_nl_words(text: str) -> str:
 
 def looks_like_nl(text: str) -> bool:
     """
-    Check if a text looks like plain natural language text, i.e. word chars,
-    possibly with ? or hyphens/apostrophes when inside words but not other
-    code or punctuation.
+    Check if a text looks like plain natural language text. Just very simple
+    based on words and only basic punctuation.
     """
-    return bool(re.match(NL_PAT, text.strip()))
+    is_only_word_chars = bool(ONLY_WORDS_RE.fullmatch(text))
+    without_punct = PUNCT_SEQ_RE.sub("", text)
+    is_only_words_punct = bool(ONLY_WORDS_RE.fullmatch(without_punct))
+    words = without_punct.strip().split()
+    one_longer_word = any(len(word) > 3 for word in words)
+
+    return one_longer_word and (
+        (is_only_words_punct and len(words) >= 3) or (is_only_word_chars and len(words) >= 2)
+    )
 
 
 ## Tests
 
 
 def test_as_nl_words():
-    assert as_nl_words("x=3+9; foo('bar')") == "x=3+9; foo('bar"
+    assert as_nl_words("x=3+9; foo('bar')") == "x=3+9 foo('bar"
     assert as_nl_words("cd ..") == "cd .."
     assert as_nl_words("transcribe some-file_23.mp3") == "transcribe some-file_23.mp3"
     assert as_nl_words("hello world ") == "hello world"
@@ -57,14 +60,32 @@ def test_looks_like_nl():
     assert looks_like_nl("hello world")
     assert looks_like_nl(" hello world ")
     assert looks_like_nl("what's up")
-    assert looks_like_nl("hello-world")
     assert looks_like_nl("is this a question?")
     assert looks_like_nl("'quoted text'")
     assert looks_like_nl("git push origin main")
+    assert looks_like_nl("this is natural language")
+    assert looks_like_nl(" what's up, doc? ")
+    assert looks_like_nl("multiple   spaces   here")
+    assert looks_like_nl("go to the store (buy milk)")
+    assert looks_like_nl("'quoted text' has three words")
+    assert looks_like_nl("git push origin main")
+    assert looks_like_nl("what's up")
 
+    assert not looks_like_nl("hello-world")
+    assert not looks_like_nl("cd ..")
+    assert not looks_like_nl("file_name.txt")
+    assert not looks_like_nl("ls -la")
+    assert not looks_like_nl("https://example.com")
+    assert not looks_like_nl("cmd | grep pattern")
+    assert not looks_like_nl("use a+b")
+    assert not looks_like_nl("x=3")
+    assert not looks_like_nl("a > b")
+    assert not looks_like_nl("file_name.txt")
+    assert not looks_like_nl("foo;")
+    assert not looks_like_nl("hello-world")
     assert not looks_like_nl("ls -la")
     assert not looks_like_nl("cd ..")
     assert not looks_like_nl("echo $HOME")
     assert not looks_like_nl("https://example.com")
-    assert not looks_like_nl("file.txt")
+    assert not looks_like_nl(text="file.txt")
     assert not looks_like_nl("cmd | grep pattern")

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

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,52 +1,49 @@
-from kash.config.setup import setup
-from kash.config.text_styles import LOGO_NAME, STYLE_HINT
-from kash.mcp.mcp_server_commands import start_mcp_server
-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.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()
 
@@ -59,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()
 
@@ -106,7 +103,7 @@ def load_into_xonsh():
 
         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