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

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
@@ -192,9 +193,16 @@ class ItemId:
         from kash.web_content.canon_url import canonicalize_url
 
         item_id = None
-        if item.type == ItemType.resource and item.format == Format.url and item.url:
+        if (
+            item.type == ItemType.resource
+            and item.format == Format.url
+            and item.url
+            and not item.source
+        ):
+            # This is a plain URL resource, so its identity is its URL.
             item_id = ItemId(item.type, IdType.url, canonicalize_url(item.url))
         elif item.type == ItemType.concept and item.title:
+            # This is a concept, so its identity is its title.
             item_id = ItemId(item.type, IdType.concept, canonicalize_concept(item.title))
         elif item.source and item.source.cacheable and item.source.operation.has_known_inputs:
             # We know the source of this and if the action was cacheable, we can create
@@ -636,8 +644,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 +659,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 +671,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 +903,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 +937,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/model/params_model.py

@@ -206,10 +206,10 @@ A list of parameter declarations, possibly with default values.
 
 # These are the default models for typical use cases.
 # The user may override them with parameters.
-DEFAULT_CAREFUL_LLM = LLM.gpt_5
-DEFAULT_STRUCTURED_LLM = LLM.gpt_5
-DEFAULT_STANDARD_LLM = LLM.gpt_5
-DEFAULT_FAST_LLM = LLM.gpt_5_mini
+DEFAULT_CAREFUL_LLM = LLM.claude_sonnet_4_5
+DEFAULT_STRUCTURED_LLM = LLM.claude_sonnet_4_5
+DEFAULT_STANDARD_LLM = LLM.claude_sonnet_4_5
+DEFAULT_FAST_LLM = LLM.claude_haiku_4_5
 
 
 # Parameters set globally such as in the workspace.

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

kash/utils/common/s3_utils.py

@@ -1,13 +1,19 @@
 from __future__ import annotations
 
+import os
 import shutil
 import subprocess
+from logging import getLogger
 from pathlib import Path
 
+from dotenv import find_dotenv, load_dotenv
 from sidematter_format.sidematter_format import Sidematter
+from strif import abbrev_str
 
 from kash.utils.common.url import Url, is_s3_url, parse_s3_url
 
+log = getLogger(__name__)
+
 
 def check_aws_cli() -> None:
     """
@@ -19,6 +25,54 @@ def check_aws_cli() -> None:
         )
 
 
+def run_aws_command(cmd: list[str]) -> subprocess.CompletedProcess[str]:
+    """
+    Run an AWS CLI command and capture output.
+    Raises a RuntimeError with stdout/stderr on failure.
+    """
+    result = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        env=os.environ,
+    )
+
+    if result.returncode != 0:
+        # Build a detailed error message
+        error_parts = [f"AWS command failed with exit code {result.returncode}"]
+        error_parts.append(f"Command: {' '.join(cmd)}")
+
+        if result.stdout:
+            error_parts.append(f"stdout: {result.stdout}")
+        if result.stderr:
+            error_parts.append(f"stderr: {result.stderr}")
+
+        raise RuntimeError("\n".join(error_parts))
+
+    return result
+
+
+def reload_aws_env_vars() -> None:
+    """
+    Fresh reload of AWS env vars from .env.local.
+    """
+
+    def aws_creds() -> set[tuple[str, str]]:
+        return {(k, abbrev_str(v, 5)) for k, v in os.environ.items() if k.startswith("AWS_")}
+
+    if len(aws_creds()) == 0:
+        dotenv_path = find_dotenv(".env.local", usecwd=True) or find_dotenv(".env", usecwd=True)
+        load_dotenv(dotenv_path, override=True)
+        if len(aws_creds()) > 0:
+            log.info(
+                "Loaded %s, found AWS credentials: %s",
+                dotenv_path,
+                aws_creds(),
+            )
+        else:
+            log.warning("No AWS credentials found in env or .env files")
+
+
 def get_s3_parent_folder(url: Url) -> Url | None:
     """
     Get the parent folder of an S3 URL, or None if not an S3 URL.
@@ -47,6 +101,7 @@ def s3_sync_to_folder(
     - For a single file: the file URL (and sidematter file/dir URLs if included).
     - For a directory: the destination parent prefix URL (non-recursive reporting).
     """
+    reload_aws_env_vars()
 
     src_path = Path(src_path)
     if not src_path.exists():
@@ -71,7 +126,7 @@ def s3_sync_to_folder(
         for p in sync_paths:
             if p.is_file():
                 # Use sync with include/exclude to leverage default short-circuiting
-                subprocess.run(
+                run_aws_command(
                     [
                         "aws",
                         "s3",
@@ -82,27 +137,54 @@ def s3_sync_to_folder(
                         "*",
                         "--include",
                         p.name,
-                    ],
-                    check=True,
+                    ]
                 )
                 targets.append(Url(dest_prefix + p.name))
             elif p.is_dir():
                 dest_dir = dest_prefix + p.name + "/"
-                subprocess.run(["aws", "s3", "sync", str(p), dest_dir], check=True)
+                run_aws_command(["aws", "s3", "sync", str(p), dest_dir])
                 targets.append(Url(dest_dir))
 
         return targets
     else:
         # Directory mode: sync whole directory.
-        subprocess.run(
+        run_aws_command(
             [
                 "aws",
                 "s3",
                 "sync",
                 str(src_path),
                 dest_prefix,
-            ],
-            check=True,
+            ]
         )
         targets.append(Url(dest_prefix))
         return targets
+
+
+def s3_download_file(s3_url: Url, target_path: str | Path) -> None:
+    """
+    Download a file from S3 to a local path using the AWS CLI.
+
+    Args:
+        s3_url: The S3 URL to download from (s3://bucket/path/to/file)
+        target_path: The local path to save the file to
+    """
+    reload_aws_env_vars()
+
+    if not is_s3_url(s3_url):
+        raise ValueError(f"Source must be an s3:// URL: {s3_url}")
+
+    check_aws_cli()
+
+    target_path = Path(target_path)
+
+    # Use aws s3 cp to download the file
+    run_aws_command(
+        [
+            "aws",
+            "s3",
+            "cp",
+            str(s3_url),
+            str(target_path),
+        ]
+    )

kash/web_content/web_extract.py

@@ -26,7 +26,6 @@ def fetch_page_content(
 
     Force re-fetching and updating the cache by setting `refetch` to true.
 
-
     For HTML and other text files, uses the `text_extractor` to extract
     clean text and page metadata.
     """