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

kash/commands/base/debug_commands.py

@@ -179,7 +179,7 @@ def reload_system() -> None:
     the local the local server. Not perfect! But sometimes useful for development.
     """
     import kash
-    from kash.local_server.local_server import restart_local_server
+    from kash.local_server.local_server import restart_ui_server
     from kash.utils.common.import_utils import recursive_reload
 
     module = kash
@@ -197,7 +197,7 @@ def reload_system() -> None:
     log.info("Reloaded modules: %s", ", ".join(package_names))
     log.message("Reloaded %s modules from %s.", len(package_names), module.__name__)
 
-    restart_local_server()
+    restart_ui_server()
 
     # TODO Re-register commands and actions.
 

kash/commands/base/general_commands.py

@@ -1,7 +1,9 @@
+from flowmark import Wrap
+
 from kash.commands.base.model_commands import list_apis, list_models
 from kash.commands.workspace.workspace_commands import list_params
 from kash.config.logger import get_logger
-from kash.config.settings import RECOMMENDED_API_KEYS
+from kash.config.settings import RECOMMENDED_API_KEYS, get_system_config_dir
 from kash.docs.all_docs import all_docs
 from kash.exec import kash_command
 from kash.help.tldr_help import tldr_refresh_cache
@@ -175,7 +177,7 @@ def reload_env() -> None:
     Reload the environment variables from the .env file.
     """
 
-    env_paths = load_dotenv_paths()
+    env_paths = load_dotenv_paths(True, True, get_system_config_dir())
     if env_paths:
         cprint("Reloaded environment variables")
         print_api_key_setup(RECOMMENDED_API_KEYS)
@@ -197,7 +199,9 @@ def kits() -> None:
     else:
         cprint("Currently imported kits:")
         for kit in get_loaded_kits().values():
-            cprint(format_name_and_value(f"{kit.name} kit", str(kit.path or "")))
+            cprint(
+                format_name_and_value(f"{kit.name} kit", str(kit.path or ""), text_wrap=Wrap.NONE)
+            )
 
 
 @kash_command
@@ -210,5 +214,5 @@ def settings() -> None:
     settings = global_settings()
     print_h2("Global Settings")
     for field, value in settings.__dict__.items():
-        cprint(format_name_and_value(field, str(value)))
+        cprint(format_name_and_value(field, str(value), text_wrap=Wrap.NONE))
     PrintHooks.spacer()

kash/commands/base/logs_commands.py

@@ -7,8 +7,7 @@ from kash.config.logger import get_log_settings, get_logger, reload_rich_logging
 from kash.config.settings import (
     LogLevel,
     atomic_global_settings,
-    global_settings,
-    server_log_file_path,
+    local_server_log_path,
 )
 from kash.exec import kash_command
 from kash.shell.output.shell_formatting import format_name_and_value
@@ -86,8 +85,4 @@ def log_settings() -> None:
     cprint(format_name_and_value("log_objects_dir", str(settings.log_objects_dir)))
     cprint(format_name_and_value("log_file_level", settings.log_file_level.name))
     cprint(format_name_and_value("log_console_level", settings.log_console_level.name))
-    cprint(
-        format_name_and_value(
-            "server_log_file", str(server_log_file_path(global_settings().local_server_port))
-        )
-    )
+    cprint(format_name_and_value("server_log_file_path", str(local_server_log_path())))

kash/commands/workspace/workspace_commands.py

@@ -54,7 +54,7 @@ from kash.utils.common.type_utils import not_none
 from kash.utils.common.url import Url, is_url
 from kash.utils.errors import InvalidInput
 from kash.utils.file_formats.chat_format import tail_chat_history
-from kash.utils.file_utils.dir_size import is_nonempty_dir
+from kash.utils.file_utils.dir_info import is_nonempty_dir
 from kash.utils.lang_utils.inflection import plural
 from kash.web_content.file_cache_utils import cache_file
 from kash.workspaces import (

kash/concepts/cosine.py

@@ -1,9 +1,10 @@
 from collections.abc import Sequence
+from typing import Any, TypeAlias
 
 import numpy as np
 
 # Type aliases for clarity
-ArrayLike = Sequence[float] | np.ndarray
+ArrayLike: TypeAlias = Sequence[float] | np.ndarray[Any, Any]
 
 
 def cosine(u: ArrayLike, v: ArrayLike) -> float:

kash/concepts/text_similarity.py

@@ -1,12 +1,11 @@
 from typing import cast
 
 import litellm
-import pandas as pd
-from funlog import log_calls, tally_calls
+from funlog import log_calls
 from litellm import embedding
 from litellm.types.utils import EmbeddingResponse
 
-from kash.concepts.cosine import cosine
+from kash.concepts.cosine import ArrayLike, cosine
 from kash.concepts.embeddings import Embeddings
 from kash.config.logger import get_logger
 from kash.llm_utils.llms import DEFAULT_EMBEDDING_MODEL, EmbeddingModel
@@ -15,11 +14,7 @@ from kash.utils.errors import ApiResultError
 log = get_logger(__name__)
 
 
-def sort_by_length(values: list[str]) -> list[str]:
-    return sorted(values, key=lambda x: (len(x), x))
-
-
-def cosine_relatedness(x, y):
+def cosine_relatedness(x: ArrayLike, y: ArrayLike) -> float:
     return 1 - cosine(x, y)
 
 
@@ -60,53 +55,3 @@ def rank_by_relatedness(
     scored_strings.sort(key=lambda x: x[2], reverse=True)
 
     return scored_strings[:top_n]
-
-
-@tally_calls(level="warning", min_total_runtime=5, if_slower_than=10)
-def relate_texts_by_embedding(
-    embeddings: Embeddings, relatedness_fn=cosine_relatedness
-) -> pd.DataFrame:
-    log.message("Computing relatedness matrix of %d text embeddings…", len(embeddings.data))
-
-    keys = [key for key, _, _ in embeddings.as_iterable()]
-    relatedness_matrix = pd.DataFrame(index=keys, columns=keys)  # pyright: ignore
-
-    for i, (key1, _, emb1) in enumerate(embeddings.as_iterable()):
-        for j, (key2, _, emb2) in enumerate(embeddings.as_iterable()):
-            if i <= j:
-                score = relatedness_fn(emb1, emb2)
-                relatedness_matrix.at[key1, key2] = score
-                relatedness_matrix.at[key2, key1] = score
-
-    # Fill diagonal (self-relatedness).
-    for key in keys:
-        relatedness_matrix.at[key, key] = 1.0
-
-    return relatedness_matrix
-
-
-def find_related_pairs(
-    relatedness_matrix: pd.DataFrame, threshold: float = 0.9
-) -> list[tuple[str, str, float]]:
-    log.message(
-        "Finding near duplicates among %s items (threshold %s)",
-        relatedness_matrix.shape[0],
-        threshold,
-    )
-
-    pairs: list[tuple[str, str, float]] = []
-    keys = relatedness_matrix.index.tolist()
-
-    for i, key1 in enumerate(keys):
-        for j, key2 in enumerate(keys):
-            if i < j:
-                relatedness = relatedness_matrix.at[key1, key2]
-                if relatedness >= threshold:
-                    # Put shortest one first.
-                    [short_key, long_key] = sort_by_length([key1, key2])
-                    pairs.append((short_key, long_key, relatedness))
-
-    # Sort with highest relatedness first.
-    pairs.sort(key=lambda x: x[2], reverse=True)
-
-    return pairs

kash/config/env_settings.py

@@ -0,0 +1,59 @@
+import os
+from enum import Enum
+from pathlib import Path
+from typing import overload
+
+
+class KashEnv(str, Enum):
+    """
+    Environment variable settings for kash. None are required, but these may be
+    used to override default values.
+    """
+
+    KASH_LOG_LEVEL = "KASH_LOG_LEVEL"
+    """The log level for console-based logging."""
+
+    KASH_WS_ROOT = "KASH_WS_ROOT"
+    """The root directory for kash workspaces."""
+
+    KASH_GLOBAL_WS = "KASH_GLOBAL_WS"
+    """The global workspace directory."""
+
+    KASH_SYSTEM_LOGS_DIR = "KASH_SYSTEM_LOGS_DIR"
+    """The directory for system logs."""
+
+    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."""
+
+    @overload
+    def read_str(self) -> str | None: ...
+
+    @overload
+    def read_str(self, default: str) -> str: ...
+
+    def read_str(self, default: str | None = None) -> str | None:
+        """
+        Get the value of the environment variable from the environment (with
+        optional default).
+        """
+        return os.environ.get(self.value, default)
+
+    @overload
+    def read_path(self, default: None) -> None: ...
+
+    @overload
+    def read_path(self, default: Path) -> Path: ...
+
+    def read_path(self, default: Path | None = None) -> Path | None:
+        """
+        Get the value of the environment variable as a resolved path (with
+        optional default).
+        """
+        value = os.environ.get(self.value)
+        if value:
+            return Path(value).expanduser().resolve()
+        else:
+            return default.expanduser().resolve() if default else None

kash/config/logger.py

@@ -12,11 +12,11 @@ from pathlib import Path
 from typing import IO, Any, cast
 
 import rich
+from prettyfmt import slugify_snake
 from rich._null_file import NULL_FILE
 from rich.console import Console
 from rich.logging import RichHandler
 from rich.theme import Theme
-from slugify import slugify
 from strif import atomic_output_file, new_timestamped_uid
 from typing_extensions import override
 
@@ -317,8 +317,7 @@ class CustomLogger(logging.Logger):
         global _log_settings
         prefix = prefix_slug + "." if prefix_slug else ""
         filename = (
-            f"{prefix}{slugify(description, separator='_')}."
-            f"{new_timestamped_uid()}.{file_ext.lstrip('.')}"
+            f"{prefix}{slugify_snake(description)}.{new_timestamped_uid()}.{file_ext.lstrip('.')}"
         )
         path = _log_settings.log_objects_dir / filename
         with atomic_output_file(path, make_parents=True) as tmp_filename:

kash/config/logger_basic.py

@@ -1,14 +1,21 @@
 import logging
 import sys
-from logging import FileHandler, Formatter
+from logging import FileHandler, Formatter, LogRecord
 from pathlib import Path
 
 from kash.config.settings import LogLevel
+from kash.config.suppress_warnings import demote_warnings
 
 # Basic logging setup for non-interactive logging, like on a server.
 # For richer logging, see logger.py.
 
 
+class SuppressedWarningsStreamHandler(logging.StreamHandler):
+    def emit(self, record: LogRecord):
+        demote_warnings(record, level=logging.DEBUG)
+        super().emit(record)
+
+
 def basic_file_handler(path: Path, level: LogLevel) -> logging.FileHandler:
     handler = logging.FileHandler(path)
     handler.setLevel(level.value)
@@ -17,7 +24,7 @@ def basic_file_handler(path: Path, level: LogLevel) -> logging.FileHandler:
 
 
 def basic_stderr_handler(level: LogLevel) -> logging.StreamHandler:
-    handler = logging.StreamHandler(stream=sys.stderr)
+    handler = SuppressedWarningsStreamHandler(stream=sys.stderr)
     handler.setLevel(level.value)
     handler.setFormatter(Formatter("%(asctime)s %(levelname).1s %(name)s - %(message)s"))
     return handler

kash/config/server_config.py

@@ -7,7 +7,7 @@ if TYPE_CHECKING:
 
 
 def create_server_config(
-    app: Callable[..., Any], host: str, port: int, server_name: str, log_path: Path
+    app: Callable[..., Any], host: str, port: int, _server_name: str, log_path: Path
 ) -> "uvicorn.Config":
     """
     Create a common server configuration for both local and MCP servers.
@@ -43,11 +43,11 @@ def create_server_config(
                 "uvicorn": {"handlers": ["default"], "level": "INFO", "propagate": False},
                 "uvicorn.error": {"handlers": ["default"], "level": "INFO", "propagate": False},
                 "uvicorn.access": {"handlers": ["default"], "level": "INFO", "propagate": False},
-                f"kash.{server_name}": {
-                    "handlers": ["default"],
-                    "level": "INFO",
-                    "propagate": False,
-                },
+                # f"kash.{server_name}": {
+                #     "handlers": ["default"],
+                #     "level": "INFO",
+                #     "propagate": False,
+                # },
             },
         },
     )

kash/config/settings.py

@@ -3,10 +3,10 @@ from enum import Enum
 from functools import cache
 from logging import DEBUG, ERROR, INFO, WARNING
 from pathlib import Path
-from typing import overload
 
 from pydantic.dataclasses import dataclass
 
+from kash.config.env_settings import KashEnv
 from kash.utils.common.atomic_var import AtomicVar
 
 APP_NAME = "kash"
@@ -23,61 +23,53 @@ RECOMMENDED_API_KEYS = [
 ]
 
 
-@overload
-def path_from_env(env_name: str, default: None) -> None: ...
-
-
-@overload
-def path_from_env(env_name: str, default: Path) -> Path: ...
-
-
-def path_from_env(env_name: str, default: Path | None) -> Path | None:
-    value = os.environ.get(env_name)
-    if value:
-        return Path(value).expanduser().resolve()
-    else:
-        return default.expanduser().resolve() if default else None
-
-
 def get_ws_root_dir() -> Path:
     """Default root directory for kash workspaces."""
-    return path_from_env("KASH_WS_ROOT", Path("~/Kash").expanduser().resolve())
+    return KashEnv.KASH_WS_ROOT.read_path(Path("~/Kash"))
 
 
 def get_global_ws_dir() -> Path:
     """Default global workspace directory."""
-    kash_ws_dir = path_from_env("KASH_GLOBAL_WS", None)
+    kash_ws_dir = KashEnv.KASH_GLOBAL_WS.read_path(None)
     if kash_ws_dir:
         return kash_ws_dir
     else:
         return get_ws_root_dir() / GLOBAL_WS_NAME
 
 
+def get_system_config_dir() -> Path:
+    return Path("~/.config/kash").expanduser().resolve()
+
+
+def get_rcfile_path() -> Path:
+    return get_system_config_dir() / "kashrc"
+
+
 def get_system_logs_dir() -> Path:
     """Default global and system logs directory (for server logs, etc)."""
-    return path_from_env("KASH_SYSTEM_LOGS_DIR", get_ws_root_dir() / "logs")
+    return KashEnv.KASH_SYSTEM_LOGS_DIR.read_path(get_ws_root_dir() / "logs")
 
 
 def get_system_cache_dir() -> Path:
     """Default global and system cache directory (for global media, content, etc)."""
-    return path_from_env("KASH_SYSTEM_CACHE_DIR", get_ws_root_dir() / "cache")
+    return KashEnv.KASH_SYSTEM_CACHE_DIR.read_path(get_ws_root_dir() / "cache")
+
+
+def get_system_env_path() -> Path:
+    return get_system_config_dir() / "env.local"
 
 
 def get_mcp_ws_dir() -> Path | None:
     """
     Get the directory for the MCP workspace, if set.
     """
-    mcp_dir = os.environ.get("KASH_MCP_WS")
+    mcp_dir = KashEnv.KASH_MCP_WS.read_str()
     if mcp_dir:
         return Path(mcp_dir).expanduser().resolve()
     else:
         return None
 
 
-def get_rcfile_path() -> Path:
-    return Path("~/.kashrc").expanduser().resolve()
-
-
 MEDIA_CACHE_NAME = "media"
 CONTENT_CACHE_NAME = "content"
 
@@ -91,7 +83,12 @@ LOCAL_SERVER_PORT_START = 4470
 LOCAL_SERVER_PORTS_MAX = 30
 
 
-SERVER_LOG_FILE = str(get_system_logs_dir() / "{name}_{port}.log")
+LOCAL_SERVER_LOG_NAME = "local_server"
+
+
+@cache
+def local_server_log_path() -> Path:
+    return resolve_and_create_dirs(get_system_logs_dir() / f"{LOCAL_SERVER_LOG_NAME}.log")
 
 
 class LogLevel(Enum):
@@ -117,7 +114,7 @@ class LogLevel(Enum):
         return self.name
 
 
-DEFAULT_LOG_LEVEL = LogLevel.parse(os.environ.get("KASH_LOG_LEVEL", "warning"))
+DEFAULT_LOG_LEVEL = LogLevel.parse(KashEnv.KASH_LOG_LEVEL.read_str("warning"))
 
 
 def resolve_and_create_dirs(path: Path | str, is_dir: bool = False) -> Path:
@@ -201,12 +198,6 @@ class Settings:
     """If true, use Nerd Icons in file listings. Requires a compatible font."""
 
 
-@cache
-def server_log_file_path(name: str, port: int | str) -> Path:
-    # Use a different log file for each port (server instance).
-    return resolve_and_create_dirs(SERVER_LOG_FILE.format(name=name, port=port))
-
-
 # Initial default settings.
 _settings = AtomicVar(
     Settings(

kash/config/setup.py

@@ -1,12 +1,20 @@
 from enum import Enum
 from functools import cache
+from pathlib import Path
 from typing import Any
 
+from kash.config.logger_basic import basic_logging_setup
+from kash.config.settings import LogLevel, get_system_config_dir
+
 
 @cache
-def setup(rich_logging: bool):
+def setup(rich_logging: bool, file_log_path: Path | None = None, level: LogLevel = LogLevel.info):
     """
-    One-time setup of essential keys, directories, and configs. Idempotent.
+    One-time top-level setup of essential logging, keys, directories, and configs.
+    Idempotent.
+
+    If rich_logging is True, then rich logging with warnings only for console use.
+    If rich_logging is False, then use basic logging to a file and stderr.
     """
     from kash.config.logger import reload_rich_logging_setup
     from kash.shell.clideps.dotenv_utils import load_dotenv_paths
@@ -14,12 +22,14 @@ def setup(rich_logging: bool):
 
     if rich_logging:
         reload_rich_logging_setup()
+    else:
+        basic_logging_setup(file_log_path=file_log_path, level=level)
 
     _lib_setup()
 
     add_stacktrace_handler()
 
-    load_dotenv_paths()
+    load_dotenv_paths(True, True, get_system_config_dir())
 
 
 def _lib_setup():

kash/config/suppress_warnings.py

@@ -1,27 +1,45 @@
 import logging
 import warnings
 from logging import LogRecord
+from typing import Any
+from warnings import formatwarning
+
+FILTER_PATTERNS = [
+    "deprecated",
+    "Deprecation",
+    "PydanticDeprecatedSince20",
+    "pydantic",
+    # "pydub",
+]
+"""Warning messages to always suppress in console output."""
+
+
+def should_suppress(message: Any):
+    return any(pattern in str(message) for pattern in FILTER_PATTERNS)
 
 
 def filter_warnings():
+    for pattern in FILTER_PATTERNS:
+        warnings.filterwarnings("ignore", message=f".*{pattern}.*")
     warnings.filterwarnings("ignore", category=DeprecationWarning)
-    warnings.filterwarnings("ignore", message=".*deprecated.*")
-    warnings.filterwarnings("ignore", message=".*Deprecation.*")
-    warnings.filterwarnings("ignore", message=".*PydanticDeprecatedSince20.*")
-    warnings.filterwarnings("ignore", module="pydub")
-    warnings.filterwarnings("ignore", module="pydantic")
     warnings.filterwarnings("ignore", category=RuntimeWarning, module="xonsh.tools")
 
+    log = logging.getLogger("warnings")
+
+    def custom_showwarning(message, category, filename, lineno, _file=None, line=None):
+        if not should_suppress(message) and not should_suppress(category):
+            log.warning(formatwarning(message, category, filename, lineno, line))
+
+    # Override system default, which writes to stderr.
+    warnings.showwarning = custom_showwarning
+
 
 filter_warnings()
 
 
-# Doing it even more brute force since the approach above often doesn't work.
-def demote_warnings(record: LogRecord):
+# An even more brute force approach if the approach above doesn't work.
+def demote_warnings(record: LogRecord, level: int = logging.INFO):
     if record.levelno == logging.WARNING:
         # Check for any warning patterns that we're filtering in filter_warnings
-        if any(
-            pattern in record.msg
-            for pattern in ["deprecated", "Deprecation", "PydanticDeprecatedSince20"]
-        ) or any(module in str(record.pathname) for module in ["pydub", "pydantic", "xonsh.tools"]):
-            record.levelno = logging.INFO
+        if should_suppress(record.msg) or should_suppress(record.module):
+            record.levelno = level

kash/docs/markdown/topics/a2_installation.md

@@ -65,15 +65,19 @@ These are for `kash-media` but you can use a `kash-shell` for a more basic setup
    For macOS, you can again use brew:
 
    ```shell
-   # Install pyenv, pipx, and other tools:
    brew update
-   brew install ripgrep bat eza hexyl imagemagick libmagic ffmpeg 
+   brew install libmagic ffmpeg ripgrep bat eza hexyl imagemagick zoxide
    ```
 
    For Ubuntu:
 
    ```shell
-   apt install ripgrep bat eza hexyl imagemagick libmagic ffmpeg 
+   sudo apt-get update
+   sudo apt-get install -y libgl1 ffmpeg libmagic-dev 
+   # For the additional command-line tools, pixi is better on Ubuntu:
+   curl -fsSL https://pixi.sh/install.sh | sh
+   . ~/.bashrc
+   pixi global install ripgrep bat eza hexyl imagemagick zoxide
    ```
 
    For Windows or other platforms, see the uv instructions.

kash/docs/markdown/warning.md

@@ -1,8 +1,3 @@
-*Thank you for trying kash.
-It is new and has rough edges.
-I'd love to hear from you with issues, bugs, and ideas.
-Discuss at github.com/jlevy/kash and contact info at: github.com/jlevy*
-
-**Warning:** *This is a shell so actions and commands can be destructive or dangerous,
-including deleting files.
-Exercise caution and review commands carefully!*
+**Important:** *Kash will not execute commands without confirmation.
+But this is a shell so commands can be destructive or dangerous.
+Review commands carefully!*

kash/docs/markdown/welcome.md

@@ -5,5 +5,9 @@ You may simply ask a question and the kash assistant will help you.
 Press **space** (or type **?**), then write your question or request.
 Use `logs` for detailed logs.
 
+*I'd love to hear from you with issues, bugs, and ideas.
+Discuss at github.com/jlevy/kash or contact me github.com/jlevy or x.com/ojoshe (DMs
+open).*
+
 Try: `What is kash?`, `How can I transcribe a YouTube video?`, `getting_started`, `faq`,
 `self_check`, `self_configure`

kash/docs_base/load_recipe_snippets.py

@@ -8,7 +8,7 @@ from kash.help.help_types import RecipeScript, RecipeSnippet
 
 log = get_logger(__name__)
 
-RECIPE_EXT = ".ksh"
+RECIPE_EXT = ".sh"
 
 RECIPES_DIR = Path(__file__).parent / "recipes"
 

kash/docs_base/recipes/{general_system_commands.ksh → general_system_commands.sh}

@@ -1,5 +1,5 @@
 
-# Additional snippets not already in tldr_standard_commands.ksh
+# Additional snippets not already in tldr_standard_commands.sh
 
 # Show all current processes running `python`
 procs python

kash/exec/llm_transforms.py

@@ -5,6 +5,7 @@ from chopdiff.transforms import WindowSettings, accept_all, filtered_transform
 from flowmark import fill_markdown
 
 from kash.config.logger import get_logger
+from kash.config.settings import get_system_config_dir
 from kash.llm_utils import LLMName
 from kash.llm_utils.fuzzy_parsing import strip_markdown_fence
 from kash.llm_utils.llm_completion import llm_template_completion
@@ -47,7 +48,7 @@ def windowed_llm_transform(
 
 
 def llm_transform_str(options: LLMOptions, input_str: str, check_no_results: bool = True) -> str:
-    load_dotenv_paths()
+    load_dotenv_paths(True, True, get_system_config_dir())
 
     if options.windowing and options.windowing.size:
         log.message(

kash/file_storage/file_store.py

@@ -97,10 +97,6 @@ class FileStore(Workspace):
 
         add_to_ignore(self.base_dir / ".gitignore", [".kash/"])
 
-        self.vector_index = None
-        # FIXME: Add vector index support dynamically if available.
-        # self.vector_index = WsVectorIndex(self.base_dir / self.dirs.index_dir)
-
         # Initialize selection with history support.
         self.selections = SelectionHistory.init(self.base_dir / self.dirs.selection_yml)
 

kash/file_storage/item_file_format.py

@@ -48,7 +48,14 @@ def write_item(item: Item, path: Path):
     format = Format(item.format)
     if format == Format.html:
         fm_style = FmStyle.html
-    elif format in [Format.python, Format.kash_script, Format.diff, Format.csv, Format.log]:
+    elif format in [
+        Format.python,
+        Format.shellscript,
+        Format.xonsh,
+        Format.diff,
+        Format.csv,
+        Format.log,
+    ]:
         fm_style = FmStyle.hash
     elif format == Format.json:
         fm_style = FmStyle.slash

kash/help/assistant.py

@@ -318,7 +318,7 @@ def shell_context_assistance(
                 type=ItemType.script,
                 title=f"Assistant Answer: {capitalize_cms(input)}",
                 description=response_text,
-                format=Format.kash_script,
+                format=Format.shellscript,
                 body=script.script_str,
             )
             ws = current_ws()