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

kash/exec/shell_callable_action.py

@@ -1,5 +1,6 @@
 from funlog import log_tallies
 
+from kash.config.env_settings import KashEnv
 from kash.config.logger import get_console, get_logger
 from kash.config.text_styles import COLOR_ERROR, SPINNER
 from kash.exec.action_exec import run_action_with_shell_context
@@ -31,34 +32,43 @@ class ShellCallableAction:
     def __call__(self, args: list[str]) -> ShellResult | None:
         from kash.commands.help import help_commands
 
-        action_cls = self.action_cls
-        PrintHooks.before_shell_action_run()
+        log.debug("ShellCallableAction: %s: %s", self.action_cls.name, args)
 
-        shell_args = parse_shell_args(args)
-
-        # We will instantiate the action later but we create an unconfigured
-        # instance for help/info.
-        action = action_cls.create(None)
-        if shell_args.show_help:
-            print_action_help(action, verbose=True)
-            return ShellResult()
-        elif shell_args.options.get("show_source", False):
-            return help_commands.source_code(action_cls.name)
-
-        # Handle --rerun option at action invocation time.
-        rerun = bool(shell_args.options.get("rerun", False))
-
-        log.info("Action shell args: %s", shell_args)
         try:
+            action_cls = self.action_cls
+            PrintHooks.before_shell_action_run()
+
+            shell_args = parse_shell_args(args)
+
+            # We will instantiate the action later but we create an unconfigured
+            # instance for help/info.
+            action = action_cls.create(None)
+            if shell_args.show_help:
+                print_action_help(action, verbose=True)
+                return ShellResult()
+            elif shell_args.options.get("show_source", False):
+                return help_commands.source_code(action_cls.name)
+
+            # Handle --rerun and --refetch options at action invocation time.
+            rerun = bool(shell_args.options.get("rerun", False))
+            refetch = bool(shell_args.options.get("refetch", False))
+            no_format = bool(shell_args.options.get("no_format", False))
+
+            log.info("Action shell args: %s", shell_args)
             explicit_values = RawParamValues(shell_args.options)
             if not action.interactive_input:
                 with get_console().status(f"Running action {action.name}…", spinner=SPINNER):
                     result = run_action_with_shell_context(
-                        action_cls, explicit_values, *shell_args.args, rerun=rerun
+                        action_cls,
+                        explicit_values,
+                        *shell_args.args,
+                        rerun=rerun,
+                        refetch=refetch,
+                        no_format=no_format,
                     )
             else:
                 result = run_action_with_shell_context(
-                    action_cls, explicit_values, *shell_args.args, rerun=rerun
+                    action_cls, explicit_values, *shell_args.args, rerun=rerun, refetch=refetch
                 )
             # We don't return the result to keep the xonsh shell output clean.
         except NONFATAL_EXCEPTIONS as e:
@@ -66,6 +76,10 @@ class ShellCallableAction:
             log.error(f"[{COLOR_ERROR}]Action error:[/{COLOR_ERROR}] %s", summarize_traceback(e))
             log.info("Action error details: %s", e, exc_info=True)
             return ShellResult(exception=e)
+        except Exception as e:
+            # Log here while we are in the true call stack (not inside the xonsh call stack).
+            log.error("Action error: %s", e, exc_info=KashEnv.KASH_SHOW_TRACEBACK.read_bool(True))
+            raise
         finally:
             log_tallies(level="warning", if_slower_than=10.0)
             # output_separator()

kash/file_storage/file_store.py

@@ -270,10 +270,10 @@ class FileStore(Workspace):
             return self._tmp_path_for(item), False, None
         elif item.store_path:
             return StorePath(item.store_path), True, None
-        elif item_id in self.id_map:
+        elif item_id in self.id_map and self.exists(self.id_map[item_id]):
             # If this item has an identity and we've saved under that id before, use the same store path.
             store_path = self.id_map[item_id]
-            log.info(
+            log.warning(
                 "Found existing item with same id:\n%s",
                 fmt_lines([fmt_loc(store_path), item_id]),
             )
@@ -309,10 +309,16 @@ class FileStore(Workspace):
         )
 
     @log_calls()
-    def save(self, item: Item, as_tmp: bool = False, overwrite: bool = True) -> StorePath:
+    def save(
+        self, item: Item, *, overwrite: bool = True, as_tmp: bool = False, no_format: bool = False
+    ) -> StorePath:
         """
-        Save the item. Uses the store_path if it's already set or generates a new one.
-        Updates item.store_path.
+        Save the item. Uses the `store_path` if it's already set or generates a new one.
+        Updates `item.store_path`.
+
+        If `as_tmp` is true, will save the item to a temporary file.
+        If `overwrite` is false, will skip saving if the item already exists.
+        If `no_format` is true, will not normalize body text formatting (for Markdown).
         """
         # If external file already exists within the workspace, the file is already saved (without metadata).
         external_path = item.external_path and Path(item.external_path).resolve()
@@ -348,7 +354,7 @@ class FileStore(Workspace):
                 if item.external_path:
                     copyfile_atomic(item.external_path, full_path)
                 else:
-                    write_item(item, full_path)
+                    write_item(item, full_path, normalize=not no_format)
             except OSError as e:
                 log.error("Error saving item: %s", e)
                 try:
@@ -398,6 +404,7 @@ class FileStore(Workspace):
     def import_item(
         self,
         locator: Locator,
+        *,
         as_type: ItemType | None = None,
         reimport: bool = False,
     ) -> StorePath:
@@ -443,19 +450,11 @@ class FileStore(Workspace):
             if not path.exists():
                 raise FileNotFound(f"File not found: {fmt_loc(path)}")
 
-            # It's a path outside the store, so copy it in.
-            _name, filename_item_type, format, _file_ext = parse_item_filename(path)
+            # First treat it as an external file to analyze file type and format.
+            item = Item.from_external_path(path)
 
-            # Best guesses on item types if not specified.
-            item_type = as_type
-            if not item_type and filename_item_type:
-                item_type = filename_item_type
-            if not item_type and format:
-                item_type = ItemType.for_format(format)
-            if not item_type:
-                item_type = ItemType.resource
-
-            if format and format.supports_frontmatter:
+            # If it's a text/frontmatter-friendly, read it fully.
+            if item.format and item.format.supports_frontmatter:
                 log.message("Importing text file: %s", fmt_loc(path))
                 # This will read the file with or without frontmatter.
                 # We are importing so we want to drop the external path so we save the body.
@@ -479,15 +478,25 @@ class FileStore(Workspace):
                 log.message("Importing non-text file: %s", fmt_loc(path))
                 # Binary or other files we just copy over as-is, preserving the name.
                 # We know the extension is recognized.
-                item = Item.from_external_path(path)
-                store_path, _found, _prev = self.store_path_for(item)
+                store_path, _found, old_store_path = self.store_path_for(item)
                 if self.exists(store_path):
                     raise FileExists(f"Resource already in store: {fmt_loc(store_path)}")
 
-                item.type = item_type
-
-                log.message("Importing resource: %s -> %s", fmt_loc(path), fmt_loc(store_path))
+                log.message("Importing resource: %s", fmt_loc(path))
                 copyfile_atomic(path, self.base_dir / store_path, make_parents=True)
+
+                # Optimization: Don't import an identical file twice.
+                if old_store_path:
+                    old_hash = self.hash(old_store_path)
+                    new_hash = self.hash(store_path)
+                    if old_hash == new_hash:
+                        log.message(
+                            "Imported resource is identical to the previous import: %s",
+                            fmt_loc(old_store_path),
+                        )
+                        os.unlink(self.base_dir / store_path)
+                        store_path = old_store_path
+                log.message("Imported resource: %s", fmt_loc(store_path))
             return store_path
 
     def import_items(
@@ -496,7 +505,9 @@ class FileStore(Workspace):
         as_type: ItemType | None = None,
         reimport: bool = False,
     ) -> list[StorePath]:
-        return [self.import_item(locator, as_type, reimport) for locator in locators]
+        return [
+            self.import_item(locator, as_type=as_type, reimport=reimport) for locator in locators
+        ]
 
     def _filter_selection_paths(self):
         """
@@ -537,7 +548,7 @@ class FileStore(Workspace):
         # TODO: Update metadata of all relations that point to this path too.
 
     def archive(
-        self, store_path: StorePath, missing_ok: bool = False, quiet: bool = False
+        self, store_path: StorePath, *, missing_ok: bool = False, quiet: bool = False
     ) -> StorePath:
         """
         Archive the item by moving it into the archive directory.
@@ -553,6 +564,9 @@ class FileStore(Workspace):
         if missing_ok and not orig_path.exists():
             log.message("Item to archive not found so moving on: %s", fmt_loc(orig_path))
             return store_path
+        if not orig_path.exists():
+            log.warning("Item to archive not found: %s", fmt_loc(orig_path))
+            return store_path
         move_file(orig_path, archive_path)
         self._remove_references([store_path])
 
@@ -572,7 +586,7 @@ class FileStore(Workspace):
         move_file(full_input_path, original_path)
         return StorePath(store_path)
 
-    def log_workspace_info(self, once: bool = False):
+    def log_workspace_info(self, *, once: bool = False):
         """
         Log helpful information about the workspace.
         """
@@ -603,7 +617,7 @@ class FileStore(Workspace):
 
         if self.is_global_ws:
             PrintHooks.spacer()
-            log.warning("Note you are currently using the default `global` workspace.")
+            log.warning("Note you are currently using the default global workspace.")
             cprint(
                 "Create or switch to another workspace with the `workspace` command.",
                 style=STYLE_HINT,
@@ -615,6 +629,7 @@ class FileStore(Workspace):
     def walk_items(
         self,
         store_path: StorePath | None = None,
+        *,
         use_ignore: bool = True,
     ) -> Generator[StorePath, None, None]:
         """

kash/file_storage/item_file_format.py

@@ -22,7 +22,7 @@ _item_cache = MtimeCache[Item](max_size=2000, name="Item")
 
 
 @tally_calls()
-def write_item(item: Item, path: Path):
+def write_item(item: Item, path: Path, normalize: bool = True):
     """
     Write a text item to a file with standard frontmatter format YAML.
     Also normalizes formatting of the body text.
@@ -36,7 +36,10 @@ def write_item(item: Item, path: Path):
     # Clear cache before writing.
     _item_cache.delete(path)
 
-    body = normalize_formatting_ansi(item.body_text(), item.format)
+    if normalize:
+        body = normalize_formatting_ansi(item.body_text(), item.format)
+    else:
+        body = item.body_text()
 
     # Special case for YAML files to avoid a possible duplicate `---` divider in the body.
     if body and item.format == Format.yaml:

kash/file_storage/metadata_dirs.py

@@ -7,7 +7,12 @@ from pathlib import Path
 from pydantic.dataclasses import dataclass
 
 from kash.config.logger import get_logger
-from kash.config.settings import CONTENT_CACHE_NAME, DOT_DIR, MEDIA_CACHE_NAME, get_system_cache_dir
+from kash.config.settings import (
+    CONTENT_CACHE_NAME,
+    DOT_DIR,
+    MEDIA_CACHE_NAME,
+    global_settings,
+)
 from kash.file_storage.persisted_yaml import PersistedYaml
 from kash.model.paths_model import StorePath
 from kash.utils.common.format_utils import fmt_loc
@@ -62,7 +67,11 @@ class MetadataDirs:
     # in which case it is in the global cache path.
     @property
     def cache_dir(self) -> Path:
-        return get_system_cache_dir() if self.is_global_ws else StorePath(f"{DOT_DIR}/cache")
+        return (
+            global_settings().system_cache_dir
+            if self.is_global_ws
+            else StorePath(f"{DOT_DIR}/cache")
+        )
 
     @property
     def media_cache_dir(self) -> Path:

kash/help/assistant.py

@@ -110,7 +110,7 @@ def assist_current_state() -> Message:
         ws_info = f"Based on the current directory, the current workspace is: {ws_base_dir.name} at {fmt_loc(ws_base_dir)}"
     else:
         if is_global_ws:
-            about_ws = "You are currently using the `global` workspace."
+            about_ws = "You are currently using the default global workspace."
         else:
             about_ws = "The current directory is not a workspace."
         ws_info = (

kash/help/assistant_instructions.py

@@ -1,10 +1,11 @@
 from functools import cache
 from textwrap import dedent
 
+from strif import StringTemplate
+
 from kash.config.logger import get_logger
 from kash.docs.all_docs import all_docs
 from kash.docs.load_help_topics import load_help_src
-from kash.utils.common.string_template import StringTemplate
 
 log = get_logger(__name__)
 

kash/help/function_param_info.py

@@ -12,7 +12,7 @@ def _look_up_param_docs(func: Callable[..., Any], kw_params: list[FuncParam]) ->
         name = func_param.name
         param = ALL_COMMON_PARAMS.get(name)
         if not param:
-            param = Param(name, description=None, type=func_param.type or str)
+            param = Param(name, description=None, type=func_param.effective_type or str)
 
         # Also check the docstring for a description of this parameter.
         docstring = parse_docstring(func.__doc__ or "")

kash/help/help_embeddings.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from kash.concepts.embeddings import Embeddings
-from kash.concepts.text_similarity import rank_by_relatedness
 from kash.config.logger import get_logger
+from kash.embeddings.embeddings import Embeddings
+from kash.embeddings.text_similarity import rank_by_relatedness
 from kash.help.help_types import HelpDoc, HelpDocType
 from kash.web_content.local_file_cache import Loadable
 

kash/help/help_printing.py

@@ -1,5 +1,8 @@
+from typing import Any
+
 from kash.config.logger import get_logger
 from kash.config.text_styles import STYLE_HINT
+from kash.docs.all_docs import DocSelection
 from kash.exec.action_registry import look_up_action_class
 from kash.exec.command_registry import CommandFunction, look_up_command
 from kash.help.assistant import assist_preamble, assistance_unstructured
@@ -10,7 +13,7 @@ from kash.help.tldr_help import tldr_help
 from kash.llm_utils import LLM
 from kash.llm_utils.llm_messages import Message
 from kash.model.actions_model import Action
-from kash.model.params_model import COMMON_SHELL_PARAMS, RUNTIME_ACTION_PARAMS, Param
+from kash.model.params_model import COMMON_SHELL_PARAMS, Param
 from kash.model.preconditions_model import Precondition
 from kash.shell.output.shell_formatting import format_name_and_description, format_name_and_value
 from kash.shell.output.shell_output import (
@@ -32,7 +35,7 @@ GENERAL_HELP = (
 def _print_command_help(
     name: str,
     description: str | None = None,
-    param_info: list[Param] | None = None,
+    param_info: list[Param[Any]] | None = None,
     precondition: Precondition | None = None,
     verbose: bool = True,
     is_action: bool = False,  # pyright: ignore[reportUnusedParameter]
@@ -97,14 +100,7 @@ def print_action_help(
     include_options: bool = True,
     include_precondition: bool = True,
 ):
-    if include_options:
-        params = (
-            list(action.params)
-            + list(RUNTIME_ACTION_PARAMS.values())
-            + list(COMMON_SHELL_PARAMS.values())
-        )
-    else:
-        params = None
+    params = action.shell_params if include_options else None
 
     _print_command_help(
         action.name,
@@ -176,7 +172,7 @@ def print_explain_command(text: str, assistant_model: LLM | None = None):
         # Give the LLM full context on kash APIs.
         # But we do this here lazily to prevent circular dependencies.
         system_message = Message(
-            assist_preamble(is_structured=False, skip_api_docs=False, base_actions_only=False)
+            assist_preamble(is_structured=False, doc_selection=DocSelection.full)
         )
         chat_history.extend(
             [

kash/llm_utils/clean_headings.py

@@ -1,6 +1,6 @@
 from kash.llm_utils import Message, MessageTemplate, llm_template_completion
 from kash.llm_utils.llms import LLM
-from kash.text_handling.markdown_util import as_bullet_points
+from kash.text_handling.markdown_utils import as_bullet_points
 
 # TODO: Enforce that the edits below doesn't contain anything extraneous.
 

kash/llm_utils/llm_api_keys.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
 import litellm
+from clideps.env_vars.dotenv_utils import env_var_is_set
+from clideps.env_vars.env_names import EnvName
 from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider
 
 from kash.llm_utils.llm_names import LLMName
 from kash.llm_utils.llms import LLM
-from kash.shell.clideps.api_keys import ApiEnvKey
-from kash.shell.clideps.dotenv_utils import env_var_is_set
 
 
-def api_for_model(model: LLMName) -> ApiEnvKey | None:
+def api_for_model(model: LLMName) -> EnvName | None:
     """
     Get the API key name for a model or None if not found.
     """
@@ -18,7 +18,7 @@ def api_for_model(model: LLMName) -> ApiEnvKey | None:
     except litellm.exceptions.BadRequestError:
         return None
 
-    return ApiEnvKey.for_provider(custom_llm_provider)
+    return EnvName.api_env_name(custom_llm_provider)
 
 
 def have_key_for_model(model: LLMName) -> bool:

kash/llm_utils/llm_features.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal, TypeAlias
+
+from prettyfmt import custom_key_sort
+
+from kash.llm_utils.llm_names import LLMName
+from kash.llm_utils.llms import LLM
+
+Speed: TypeAlias = Literal["fast", "medium", "slow"]
+
+ContextSize: TypeAlias = Literal["small", "medium", "large"]
+
+ModelSize: TypeAlias = Literal["small", "medium", "large"]
+
+
+@dataclass(frozen=True)
+class LLMFeatures:
+    speed: Speed | None = None
+    context_size: ContextSize | None = None
+    model_size: ModelSize | None = None
+    structured_output: bool | None = None
+    thinking: bool = False
+
+    def satisfies(self, features: LLMFeatures) -> bool:
+        return all(
+            getattr(self, attr) == getattr(features, attr)
+            for attr in features.__dataclass_fields__
+            if getattr(self, attr) is not None
+        )
+
+
+def pick_llm(desired_features: LLMFeatures) -> LLMName:
+    """
+    Pick the preferred model that satisfies the desired features.
+    """
+    satisfied_models: list[LLMName] = [
+        llm for llm, features in FEATURES.items() if features.satisfies(desired_features)
+    ]
+    satisfied_models.sort(key=custom_key_sort(preferred_llms))
+    if not satisfied_models:
+        raise ValueError(f"No model found for features: {desired_features}")
+    return satisfied_models[0]
+
+
+FEATURES = {
+    LLM.o3_mini: LLMFeatures(
+        speed="fast",
+        context_size="small",
+        model_size="small",
+        structured_output=True,
+        thinking=True,
+    ),
+    # FIXME
+}
+
+preferred_llms: list[LLMName] = [
+    LLM.o3_mini,
+    LLM.o1_mini,
+    LLM.o1,
+    LLM.gpt_4o_mini,
+    LLM.gpt_4o,
+    LLM.gpt_4,
+    LLM.claude_3_7_sonnet,
+    LLM.claude_3_5_sonnet,
+    LLM.claude_3_5_haiku,
+]

kash/llm_utils/llm_messages.py

@@ -10,8 +10,7 @@ from pydantic_core.core_schema import (
     str_schema,
     to_string_ser_schema,
 )
-
-from kash.utils.common.string_template import StringTemplate
+from strif import StringTemplate
 
 
 class Message(str):

kash/llm_utils/llm_names.py

@@ -12,7 +12,7 @@ from pydantic_core.core_schema import (
 )
 from rich.text import Text
 
-from kash.config.text_styles import format_success_emoji
+from kash.shell.output.shell_formatting import format_success_emoji
 from kash.utils.common.type_utils import not_none
 
 

kash/llm_utils/llms.py

@@ -8,18 +8,23 @@ from kash.llm_utils.llm_names import LLMName
 class LLM(LLMName, Enum):
     """
     Convenience names for common LLMs. This isn't exhaustive, but just common
-    ones for autocomplete, docs, etc. Values are all LiteLLM names.
+    ones for autocomplete, docs, etc. Values are all LiteLLM names. See:
+    https://github.com/BerriAI/litellm/blob/main/litellm/model_prices_and_context_window_backup.json
     """
 
     # https://platform.openai.com/docs/models
-    o3_mini = LLMName("o3-mini")
     o1_mini = LLMName("o1-mini")
     o1 = LLMName("o1")
+    o3 = LLMName("o3")
+    o3_mini = LLMName("o3-mini")
+    o4_mini = LLMName("o4-mini")
     o1_preview = LLMName("o1-preview")
     gpt_4o_mini = LLMName("gpt-4o-mini")
     gpt_4o = LLMName("gpt-4o")
     gpt_4 = LLMName("gpt-4")
-    gpt_3_5_turbo = LLMName("gpt-3.5-turbo")
+    gpt_4_1 = LLMName("gpt-4.1")
+    gpt_4_1_mini = LLMName("gpt-4.1-mini")
+    gpt_4_1_nano = LLMName("gpt-4.1-nano")
 
     # https://docs.anthropic.com/en/docs/about-claude/models/all-models
     claude_3_7_sonnet = LLMName("claude-3-7-sonnet-latest")

kash/local_server/__init__.py

@@ -1,2 +1,5 @@
-# Ensure commands are registered.
-import kash.local_server.local_server_commands  # noqa: F401
+from pathlib import Path
+
+from kash.exec.importing import import_and_register
+
+import_and_register(__package__, Path(__file__).parent, ["."])

kash/local_server/local_server.py

@@ -14,7 +14,10 @@ from prettyfmt import fmt_path
 
 from kash.config.logger import get_logger
 from kash.config.server_config import create_server_config
-from kash.config.settings import atomic_global_settings, global_settings, local_server_log_path
+from kash.config.settings import (
+    atomic_global_settings,
+    global_settings,
+)
 from kash.local_server import local_server_routes
 from kash.local_server.port_tools import find_available_local_port
 from kash.utils.errors import InvalidInput, InvalidState
@@ -32,14 +35,14 @@ def _app_setup() -> FastAPI:
 
     # Map common exceptions to HTTP codes.
     # FileNotFound first, since it might also be an InvalidInput.
-    @app.exception_handler(FileNotFoundError)
+    @app.exception_handler(FileNotFoundError)  # pyright: ignore[reportUntypedFunctionDecorator]
     async def file_not_found_exception_handler(_request: Request, exc: FileNotFoundError):
         return JSONResponse(
             status_code=404,
             content={"message": f"File not found: {exc}"},
         )
 
-    @app.exception_handler(InvalidInput)
+    @app.exception_handler(InvalidInput)  # pyright: ignore[reportUntypedFunctionDecorator]
     async def invalid_input_exception_handler(_request: Request, exc: InvalidInput):
         return JSONResponse(
             status_code=400,
@@ -47,7 +50,7 @@ def _app_setup() -> FastAPI:
         )
 
     # Global exception handler.
-    @app.exception_handler(Exception)
+    @app.exception_handler(Exception)  # pyright: ignore[reportUntypedFunctionDecorator]
     async def global_exception_handler(_request: Request, _exc: Exception):
         return JSONResponse(
             status_code=500,
@@ -175,7 +178,7 @@ class LocalServer:
 
 # Singleton instance for the UI server.
 # Note this is quick to set up (lazy imports).
-_ui_server = LocalServer(UI_SERVER_NAME, UI_SERVER_HOST, local_server_log_path())
+_ui_server = LocalServer(UI_SERVER_NAME, UI_SERVER_HOST, global_settings().local_server_log_path)
 
 
 def start_ui_server():

kash/local_server/local_server_commands.py

@@ -1,5 +1,5 @@
 from kash.config.logger import get_logger
-from kash.config.settings import local_server_log_path
+from kash.config.settings import global_settings
 from kash.exec import kash_command
 from kash.local_server.local_url_formatters import enable_local_urls
 from kash.shell.utils.native_utils import tail_file
@@ -50,7 +50,7 @@ def local_server_logs(follow: bool = False) -> None:
 
     :param follow: Follow the file as it grows.
     """
-    log_path = local_server_log_path()
+    log_path = global_settings().local_server_log_path
     if not log_path.exists():
         raise InvalidState(
             f"Local ui server log not found (forgot to run `start_ui_server`?): {log_path}"

kash/local_server/local_server_routes.py

@@ -18,7 +18,6 @@ from kash.shell.file_icons.nerd_icons import icon_for_file
 from kash.shell.output.shell_output import Wrap
 from kash.utils.common.type_utils import not_none
 from kash.utils.errors import FileNotFound, InvalidFilename
-from kash.web_gen import base_templates_dir
 from kash.web_gen.template_render import render_web_template
 from kash.workspaces.workspace_output import print_file_info
 
@@ -140,14 +139,11 @@ def explain(text: str):
 
     return HTMLResponse(
         render_web_template(
-            base_templates_dir,
             "base_webpage.html.jinja",
             {
                 "title": f"Help: {text}",
                 "content": render_web_template(
-                    base_templates_dir,
-                    "explain_view.html.jinja",
-                    {"help_html": help_html, "page_url": page_url},
+                    "explain_view.html.jinja", {"help_html": help_html, "page_url": page_url}
                 ),
             },
         )
@@ -270,12 +266,10 @@ def _serve_item(
 
         return HTMLResponse(
             render_web_template(
-                base_templates_dir,
                 "base_webpage.html.jinja",
                 {
                     "title": display_title,
                     "content": render_web_template(
-                        base_templates_dir,
                         "item_view.html.jinja",
                         {
                             "item": item,

kash/local_server/local_url_formatters.py

@@ -4,13 +4,13 @@ from pathlib import Path
 
 from rich.style import Style
 from rich.text import Text
+from strif import AtomicVar
 from typing_extensions import override
 
 from kash.config.logger import get_logger
 from kash.config.text_styles import STYLE_HINT
 from kash.model.paths_model import StorePath
 from kash.shell.output.kerm_codes import KriLink, TextTooltip, UIAction, UIActionType
-from kash.utils.common.atomic_var import AtomicVar
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.errors import InvalidState
 from kash.workspaces import current_ws