kash-shell 0.3.34__py3-none-any.whl → 0.3.35__py3-none-any.whl

kash/config/env_settings.py

@@ -22,9 +22,6 @@ class KashEnv(EnvEnum):
     KASH_SYSTEM_CACHE_DIR = "KASH_SYSTEM_CACHE_DIR"
     """The directory for system cache (caches separate from workspace caches)."""
 
-    KASH_MCP_WS = "KASH_MCP_WS"
-    """The directory for the workspace for MCP servers."""
-
     KASH_SHOW_TRACEBACK = "KASH_SHOW_TRACEBACK"
     """Whether to show tracebacks on actions and commands in the shell."""
 

kash/config/logger.py

@@ -281,6 +281,8 @@ def _do_logging_setup(log_settings: LogSettings):
 def prefix(line: str, emoji: str = "", warn_emoji: str = "") -> str:
     prefix = task_stack_prefix_str()
     emojis = f"{warn_emoji}{emoji}".strip()
+    if emojis:
+        emojis += " "
     return "".join(filter(None, [prefix, emojis, line]))
 
 

kash/config/logger_basic.py

@@ -19,7 +19,16 @@ class SuppressedWarningsStreamHandler(logging.StreamHandler):
 def basic_file_handler(path: Path, level: LogLevel | LogLevelStr) -> logging.FileHandler:
     handler = logging.FileHandler(path)
     handler.setLevel(LogLevel.parse(level).value)
-    handler.setFormatter(Formatter("%(asctime)s %(levelname).1s %(name)s - %(message)s"))
+
+    class ThreadIdFormatter(Formatter):
+        def format(self, record):
+            # Add shortened thread ID as an attribute
+            record.thread_short = str(record.thread)[-5:]
+            return super().format(record)
+
+    handler.setFormatter(
+        ThreadIdFormatter("%(asctime)s %(levelname).1s [T%(thread_short)s] %(name)s - %(message)s")
+    )
     return handler
 
 

kash/config/settings.py

@@ -166,9 +166,6 @@ class Settings:
     system_cache_dir: Path
     """Default global and system cache directory (for global media, content, etc)."""
 
-    mcp_ws_dir: Path | None
-    """The directory for the MCP workspace, if set."""
-
     local_server_log_path: Path
     """The path to the local server log."""
 
@@ -245,14 +242,6 @@ def _get_system_cache_dir() -> Path:
     return KashEnv.KASH_SYSTEM_CACHE_DIR.read_path(default=_get_ws_root_dir() / "cache")
 
 
-def _get_mcp_ws_dir() -> Path | None:
-    mcp_dir = KashEnv.KASH_MCP_WS.read_str(default=None)
-    if mcp_dir:
-        return Path(mcp_dir).expanduser().resolve()
-    else:
-        return None
-
-
 @cache
 def _get_local_server_log_path() -> Path:
     return resolve_and_create_dirs(get_system_logs_dir() / f"{LOCAL_SERVER_LOG_NAME}.log")
@@ -266,7 +255,6 @@ def _read_settings():
         system_config_dir=_get_system_config_dir(),
         system_logs_dir=get_system_logs_dir(),
         system_cache_dir=_get_system_cache_dir(),
-        mcp_ws_dir=_get_mcp_ws_dir(),
         local_server_log_path=_get_local_server_log_path(),
         # These default to the global but can be overridden by workspace settings.
         media_cache_dir=_get_system_cache_dir() / MEDIA_CACHE_NAME,

kash/config/setup.py

@@ -75,6 +75,21 @@ def kash_setup(
 
 
 def _lib_setup():
+    import logging
+
+    log = logging.getLogger(__name__)
+
+    # Trust store integration, for consistent TLS behavior.
+    try:
+        import truststore  # type: ignore
+
+        truststore.inject_into_ssl()
+        log.info("truststore initialized: using system TLS trust store")
+    except Exception as exc:
+        # If not installed or fails, default TLS trust will be used.
+        log.warning("truststore not available at import time: %s", exc)
+
+    # Handle default YAML representers.
     from sidematter_format import register_default_yaml_representers
 
     register_default_yaml_representers()

kash/config/text_styles.py

@@ -262,7 +262,7 @@ PROMPT_ASSIST = "(assistant) ❯"
 
 EMOJI_HINT = "👉"
 
-EMOJI_MSG_INDENT = "⋮   "
+EMOJI_MSG_INDENT = "⋮ "
 
 EMOJI_START = "[➤]"
 

kash/config/warm_slow_imports.py

@@ -0,0 +1,60 @@
+from funlog import log_calls
+
+from kash.config.logger import get_logger
+from kash.utils.common.import_utils import warm_import_library
+
+log = get_logger(__name__)
+
+
+@log_calls(level="info", show_timing_only=True)
+def warm_slow_imports(include_extras: bool = True):
+    """
+    Pre-import slow packages to avoid delays when they are first used.
+
+    Args:
+        include_extras: If True, warm import optional libraries like LLM packages,
+                        scipy, torch, etc. Set to False for minimal/faster startup.
+    """
+    try:
+        # Loading actions also loads any kits that are discovered.
+        import kash.actions  # noqa: F401
+        import kash.local_server  # noqa: F401
+        import kash.local_server.local_server  # noqa: F401
+        import kash.mcp.mcp_server_sse  # noqa: F401
+
+        # Core libraries that should usually be present
+        for lib_name, max_depth in [("xonsh", 3), ("uvicorn", 3)]:
+            try:
+                warm_import_library(lib_name, max_depth=max_depth)
+            except Exception as e:
+                log.debug(f"Could not warm import {lib_name}: {e}")
+
+        if include_extras:
+            # Fully warm import larger libraries (only if they're installed)
+            # These are optional dependencies that may not be present
+            optional_libraries = [
+                ("pydantic", 5),
+                ("litellm", 5),
+                ("openai", 5),
+                ("torch", 3),  # torch is huge, limit depth
+                ("scipy", 3),  # scipy has test modules we want to skip
+                ("marker", 4),
+                ("pandas", 3),
+            ]
+
+            for lib_name, max_depth in optional_libraries:
+                try:
+                    warm_import_library(lib_name, max_depth=max_depth)
+                except Exception as e:
+                    log.debug(f"Could not warm import {lib_name}: {e}")
+
+            # Initialize litellm configuration if available
+            try:
+                from kash.llm_utils.init_litellm import init_litellm
+
+                init_litellm()
+            except ImportError:
+                pass  # litellm not installed
+
+    except ImportError as e:
+        log.warning(f"Error pre-importing packages: {e}")

kash/exec/action_decorators.py

@@ -204,7 +204,7 @@ def kash_action(
     precondition: Precondition = Precondition.always,
     arg_type: ArgType = ArgType.Locator,
     expected_args: ArgCount = ONE_ARG,
-    output_type: ItemType = ItemType.doc,
+    output_type: ItemType | None = None,
     output_format: Format | None = None,
     expected_outputs: ArgCount = ONE_ARG,
     params: ParamDeclarations = (),
@@ -349,7 +349,7 @@ def kash_action(
                         fmt_lines(self.params),
                     )
                     log.info(
-                        "Action function param values:\n%s",
+                        "Action function param values: %s",
                         self.param_value_summary_str(),
                     )
                 else:

kash/exec/action_exec.py

@@ -107,7 +107,7 @@ def log_action(action: Action, action_input: ActionInput, operation: Operation):
     log.message("%s Action: `%s`", EMOJI_START, action.name)
     log.info("Running: `%s`", operation.command_line(with_options=True))
     if len(action.param_value_summary()) > 0:
-        log.message("Parameters:\n%s", action.param_value_summary_str())
+        log.message("Parameters: %s", action.param_value_summary_str())
     log.info("Operation is: %s", operation)
     log.info("Input items are:\n%s", fmt_lines(action_input.items))
 

kash/exec/fetch_url_items.py

@@ -144,15 +144,17 @@ def fetch_url_item_content(
         if save_content:
             assert page_data.saved_content
             assert page_data.format_info
+            if not page_data.format_info.format:
+                log.warning("No format detected for content, defaulting to HTML: %s", url)
             content_item = url_item.new_copy_with(
                 external_path=str(page_data.saved_content),
                 # Use the original filename, not the local cache filename (which has a hash suffix).
                 original_filename=item.get_filename(),
-                format=page_data.format_info.format,
+                format=page_data.format_info.format or Format.html,
             )
 
     if not url_item.title:
-        log.warning("Failed to fetch page data: title is missing: %s", item.url)
+        log.info("Title is missing for url item: %s", item)
 
     # Now save the updated URL item and also the content item if we have one.
     ws.save(url_item, overwrite=overwrite)

kash/mcp/mcp_cli.py

@@ -11,8 +11,14 @@ from pathlib import Path
 
 from clideps.utils.readable_argparse import ReadableColorFormatter
 
-from kash.config.settings import DEFAULT_MCP_SERVER_PORT, LogLevel, global_settings
+from kash.config.settings import (
+    DEFAULT_MCP_SERVER_PORT,
+    LogLevel,
+    atomic_global_settings,
+    global_settings,
+)
 from kash.config.setup import kash_setup
+from kash.config.warm_slow_imports import warm_slow_imports
 from kash.shell.version import get_version
 
 __version__ = get_version()
@@ -26,8 +32,6 @@ log = logging.getLogger()
 
 
 def build_parser():
-    from kash.workspaces.workspaces import global_ws_dir
-
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=ReadableColorFormatter)
     parser.add_argument(
         "--version",
@@ -36,8 +40,8 @@ def build_parser():
     )
     parser.add_argument(
         "--workspace",
-        default=global_ws_dir(),
-        help=f"Set workspace directory. Defaults to kash global workspace directory: {global_ws_dir()}",
+        default=global_settings().global_ws_dir,
+        help=f"Set workspace directory. Defaults to kash global workspace directory: {global_settings().global_ws_dir}",
     )
     parser.add_argument(
         "--proxy",
@@ -95,6 +99,14 @@ def run_server(args: argparse.Namespace):
     log.warning("kash MCP CLI started, logging to: %s", MCP_CLI_LOG_PATH)
     log.warning("Current working directory: %s", Path(".").resolve())
 
+    # Eagerly import so the server is warmed up.
+    # This is important to save init time on fresh sandboxes like E2B!
+    warm_slow_imports(include_extras=True)
+
+    if args.workspace and args.workspace != global_settings().global_ws_dir:
+        with atomic_global_settings().updates() as settings:
+            settings.global_ws_dir = Path(args.workspace).absolute()
+
     ws: Workspace = get_ws(name_or_path=Path(args.workspace), auto_init=True)
     os.chdir(ws.base_dir)
     log.warning("Running in workspace: %s", ws.base_dir)

kash/mcp/mcp_server_routes.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 import asyncio
 import pprint
 from dataclasses import dataclass
+from pathlib import Path
 
+from clideps.env_vars.dotenv_utils import load_dotenv_paths
 from funlog import log_calls
 from mcp.server.lowlevel import Server
 from mcp.server.lowlevel.server import StructuredContent, UnstructuredContent
@@ -237,10 +239,10 @@ def run_mcp_tool(
     """
     try:
         with captured_output() as capture:
-            # XXX For now, unless the user has overridden the MCP workspace, we use the
-            # current workspace, which could be changed by the user by changing working
-            # directories. Maybe confusing?
-            explicit_mcp_ws = global_settings().mcp_ws_dir
+            dotenv_paths = load_dotenv_paths(True, True, Path("."))
+            log.warning("Loaded .env files: %s", dotenv_paths)
+            # Use the global workspace default
+            explicit_mcp_ws = global_settings().global_ws_dir
 
             with kash_runtime(
                 workspace_dir=explicit_mcp_ws,

kash/model/actions_model.py

@@ -244,11 +244,12 @@ class Action(ABC):
     be ONE_ARG.
     """
 
-    output_type: ItemType = ItemType.doc
+    output_type: ItemType | None = None
     """
     The type of the output item(s). If an action returns multiple output types,
     this will be the output type of the first output.
     This is mainly used for preassembly for the cache check if an output already exists.
+    None means to use the input type.
     """
 
     output_format: Format | None = None
@@ -451,7 +452,7 @@ class Action(ABC):
         return changed_params
 
     def param_value_summary_str(self) -> str:
-        return fmt_lines(
+        return ", ".join(
             [format_key_value(name, value) for name, value in self.param_value_summary().items()]
         )
 
@@ -560,7 +561,14 @@ class Action(ABC):
             # Using first input to determine the output title.
             primary_input = context.action_input.items[0]
             # In this case we only expect one output, of the type specified by the action.
-            primary_output = primary_input.derived_copy(context, 0, type=context.action.output_type)
+            output_type = context.action.output_type or primary_input.type
+            if not output_type:
+                log.warning(
+                    "No output type specified for action `%s`, using `doc` for preassembly",
+                    self.name,
+                )
+                output_type = ItemType.doc
+            primary_output = primary_input.derived_copy(context, 0, type=output_type)
             log.info("Preassembled output: source %s, %s", primary_output.source, primary_output)
             return ActionResult([primary_output])
         else:

kash/model/items_model.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from collections.abc import Sequence
 from copy import deepcopy
 from dataclasses import asdict, field, is_dataclass
@@ -636,8 +637,8 @@ class Item:
         pull_body_heading: bool = False,
     ) -> str:
         """
-        Get or infer a title for this item, falling back to the filename, URL, description, or
-        finally body text. Optionally, include the last operation as a parenthetical at the end
+        Get or infer a title for this item, falling back to the URL, description or
+        body text. Optionally, include the last operation as a parenthetical at the end
         of the title. Will use "Untitled" if all else fails.
         """
         # First special case: if we are pulling the title from the body header, check
@@ -651,12 +652,9 @@ class Item:
             if not self.title and self.url:
                 return abbrev_str(self.url, max_len)
 
-            filename_stem = self.filename_stem()
-
-            # Use the title or the path if possible, falling back to description or even body text.
+            # Use semantic sources for titles. The original filename is preserved separately.
             base_title = (
                 self.title
-                or filename_stem
                 or self.description
                 or (not self.is_binary and self.abbrev_body(max_len))
                 or UNTITLED
@@ -666,7 +664,11 @@ class Item:
         # indicating the last operation, if there was one. This makes filename slugs
         # more readable.
         suffix = ""
-        if add_ops_suffix and self.type.allows_op_suffix:
+        if (
+            add_ops_suffix
+            and self.type.allows_op_suffix
+            and not re.search(r"step\d+", base_title)  # Just in case, never add suffix twice.
+        ):
             last_op = self.history and self.history[-1].action_name
             if last_op:
                 step_num = len(self.history) + 1 if self.history else 1
@@ -894,18 +896,19 @@ class Item:
         if action_context:
             # Default the output item type and format to the action's declared output_type
             # and format if not explicitly set.
-            if "type" not in updates:
+            if "type" not in updates and action_context.action.output_type:
                 updates["type"] = action_context.action.output_type
             # If we were not given a format override, we leave the output type the same.
             elif action_context.action.output_format:
                 # Check an overridden format and then our own format.
-                new_output_format = updates.get("format", self.format)
+                new_output_format = updates.get("format")
                 if new_output_format and action_context.action.output_format != new_output_format:
                     log.warning(
-                        "Output item format `%s` does not match declared output format `%s` for action `%s`",
+                        "Output item format `%s` does not match declared output format `%s` for action `%s` on item: %s",
                         new_output_format,
                         action_context.action.output_format,
                         action_context.action.name,
+                        self,
                     )
 
         new_item = self.new_copy_with(update_timestamp=True, **updates)
@@ -927,7 +930,9 @@ class Item:
 
         # Fall back to action title template if we have it and title wasn't explicitly set.
         if "title" not in updates:
-            prev_title = self.title or (Path(self.store_path).stem if self.store_path else UNTITLED)
+            # Avoid using filenames as titles when deriving. Prefer existing semantic title
+            # or derive from body heading/URL.
+            prev_title = self.title or self.pick_title(pull_body_heading=True)
 
             if action:
                 new_item.title = action.format_title(prev_title)

kash/shell/shell_main.py

@@ -70,20 +70,9 @@ def build_parser() -> argparse.ArgumentParser:
 
 
 def _import_packages():
-    try:
-        # Slowest packages:
-        import uvicorn.protocols  # noqa: F401
-        import uvicorn.protocols.http.h11_impl  # noqa: F401
-        import uvicorn.protocols.websockets.websockets_impl  # noqa: F401
-        import xonsh.completers.init  # noqa: F401
-        import xonsh.pyghooks  # noqa: F401
-
-        import kash.actions  # noqa: F401
-        import kash.local_server  # noqa: F401
-        import kash.local_server.local_server  # noqa: F401
-        import kash.mcp.mcp_server_sse  # noqa: F401
-    except ImportError as e:
-        log.warning(f"Error pre-importing packages: {e}")
+    from kash.config.warm_slow_imports import warm_slow_imports
+
+    warm_slow_imports(include_extras=False)
 
     imports_done_event.set()
 

kash/utils/common/import_utils.py

@@ -74,26 +74,108 @@ def import_recursive(
     return tallies
 
 
+def _import_modules_from_package(
+    package: types.ModuleType,
+    package_name: str,
+    max_depth: int = 1,
+    include_private: bool = True,
+    current_depth: int = 0,
+    imported_modules: dict[str, types.ModuleType] | None = None,
+) -> dict[str, types.ModuleType]:
+    """
+    Internal helper to recursively import modules from a package.
+
+    Args:
+        package: The package module to import from
+        package_name: The fully qualified name of the package
+        max_depth: Maximum recursion depth (1 = direct children only)
+        include_private: Whether to import private modules (starting with _)
+        current_depth: Current recursion depth (internal use)
+        imported_modules: Dictionary to accumulate imported modules
+
+    Returns:
+        Dictionary mapping module names to their imported module objects
+    """
+    if imported_modules is None:
+        imported_modules = {}
+
+    if current_depth >= max_depth:
+        return imported_modules
+
+    # Get the module's __path__ if it's a package
+    if not hasattr(package, "__path__"):
+        return imported_modules
+
+    try:
+        for _finder, module_name, ispkg in pkgutil.iter_modules(
+            package.__path__, f"{package_name}."
+        ):
+            # Skip private modules unless requested
+            if not include_private and module_name.split(".")[-1].startswith("_"):
+                continue
+
+            # Skip test modules - they often have special import requirements
+            # and aren't needed for warming the import cache
+            module_parts = module_name.split(".")
+            if any(
+                part in ("tests", "test", "testing", "_test", "_tests") for part in module_parts
+            ):
+                continue
+
+            # Skip already imported modules
+            if module_name in imported_modules:
+                continue
+
+            try:
+                module = importlib.import_module(module_name)
+                imported_modules[module_name] = module
+
+                # Recursively import submodules if it's a package
+                if ispkg and current_depth + 1 < max_depth:
+                    _import_modules_from_package(
+                        module,
+                        module_name,
+                        max_depth=max_depth,
+                        include_private=include_private,
+                        current_depth=current_depth + 1,
+                        imported_modules=imported_modules,
+                    )
+
+            except Exception as e:
+                # Handle various import failures gracefully
+                # This includes ImportError, pytest.Skipped, and other exceptions
+                error_type = type(e).__name__
+                if error_type not in ("ImportError", "AttributeError", "TypeError"):
+                    log.debug(f"  Skipped {module_name}: {error_type}: {e}")
+                # Don't log common/expected import errors to reduce noise
+
+    except Exception as e:
+        log.warning(f"Error iterating modules in {package_name}: {e}")
+
+    return imported_modules
+
+
 def import_namespace_modules(namespace: str) -> dict[str, types.ModuleType]:
     """
     Find and import all modules or packages within a namespace package.
     Returns a dictionary mapping module names to their imported module objects.
     """
-    importlib.import_module(namespace)  # Propagate import errors
+    # Import the main module first
+    main_module = importlib.import_module(namespace)  # Propagate import errors
 
     # Get the package to access its __path__
-    package = sys.modules.get(namespace)
-    if not package or not hasattr(package, "__path__"):
+    if not hasattr(main_module, "__path__"):
         raise ImportError(f"`{namespace}` is not a package or namespace package")
 
-    log.info(f"Discovering modules in `{namespace}` namespace, searching: {package.__path__}")
+    log.info(f"Discovering modules in `{namespace}` namespace, searching: {main_module.__path__}")
+
+    # Use the common helper with depth=1 (no recursion) and include_private=True
+    modules = _import_modules_from_package(
+        main_module, namespace, max_depth=1, include_private=True
+    )
 
-    # Iterate through all modules in the namespace package
-    modules = {}
-    for _finder, module_name, _ispkg in pkgutil.iter_modules(package.__path__, f"{namespace}."):
-        module = importlib.import_module(module_name)  # Propagate import errors
-        log.info(f"Imported module: {module_name} from {module.__file__}")
-        modules[module_name] = module
+    # Add the main module itself
+    modules[namespace] = main_module
 
     log.info(f"Imported {len(modules)} modules from namespace `{namespace}`")
     return modules
@@ -106,8 +188,13 @@ def recursive_reload(
     Recursively reload all modules in the given package that match the filter function.
     Returns a list of module names that were reloaded.
 
-    :param filter_func: A function that takes a module name and returns True if the
-        module should be reloaded.
+    Args:
+        package: The package to reload.
+        filter_func: A function that takes a module name and returns True if the
+            module should be reloaded.
+
+    Returns:
+        List of module names that were reloaded.
     """
     package_name = package.__name__
     modules = {
@@ -124,3 +211,40 @@ def recursive_reload(
         importlib.reload(modules[name])
 
     return module_names
+
+
+def warm_import_library(
+    library_name: str, max_depth: int = 3, include_private: bool = False
+) -> dict[str, types.ModuleType]:
+    """
+    Recursively import all submodules of a library to warm the import cache.
+    This is useful for servers where you want to pay the import cost upfront
+    rather than during request handling.
+
+    Args:
+        library_name: Name of the library to import (e.g., 'litellm', 'openai')
+        max_depth: Maximum depth to recurse into submodules
+        include_private: Whether to import private modules (starting with _)
+
+    Returns:
+        Dictionary mapping module names to their imported module objects
+    """
+    try:
+        # Import the main module first
+        main_module = importlib.import_module(library_name)
+
+        # Use the common helper for recursive imports
+        imported_modules = _import_modules_from_package(
+            main_module, library_name, max_depth=max_depth, include_private=include_private
+        )
+
+        # Add the main module itself
+        imported_modules[library_name] = main_module
+
+    except ImportError as e:
+        log.warning(f"Could not import {library_name}: {e}")
+        return {}
+
+    log.info(f"Warmed {len(imported_modules)} modules from {library_name}")
+
+    return imported_modules