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

kash/commands/base/debug_commands.py

@@ -12,7 +12,8 @@ from kash.help.function_param_info import annotate_param_info
 from kash.help.recommended_commands import RECOMMENDED_TLDR_COMMANDS
 from kash.model.params_model import Param
 from kash.shell.output.kerm_codes import IframePopover, TextTooltip
-from kash.shell.output.shell_output import PrintHooks, console_pager, cprint, format_name_and_value
+from kash.shell.output.shell_formatting import format_name_and_value
+from kash.shell.output.shell_output import PrintHooks, console_pager, cprint
 from kash.utils.errors import InvalidInput
 
 log = get_logger(__name__)
@@ -178,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
@@ -196,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,34 +1,34 @@
+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.api_keys import (
-    RECOMMENDED_APIS,
-    Api,
-    get_all_configured_models,
-    load_dotenv_paths,
-    print_api_key_setup,
-)
-from kash.config.dotenv_utils import env_var_is_set
 from kash.config.logger import get_logger
+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
+from kash.llm_utils.llm_api_keys import get_all_configured_models
 from kash.model.params_model import (
     DEFAULT_CAREFUL_LLM,
     DEFAULT_FAST_LLM,
     DEFAULT_STANDARD_LLM,
     DEFAULT_STRUCTURED_LLM,
 )
-from kash.shell.input.collect_dotenv import fill_missing_dotenv
+from kash.shell.clideps.api_keys import (
+    ApiEnvKey,
+    load_dotenv_paths,
+    print_api_key_setup,
+)
+from kash.shell.clideps.dotenv_setup import interactive_dotenv_setup
+from kash.shell.clideps.pkg_deps import pkg_check
+from kash.shell.clideps.terminal_features import terminal_check
 from kash.shell.input.input_prompts import input_choice
+from kash.shell.output.shell_formatting import format_name_and_value
 from kash.shell.output.shell_output import (
     PrintHooks,
     cprint,
-    format_failure,
-    format_name_and_value,
-    format_success,
     print_h2,
 )
-from kash.shell.utils.sys_tool_deps import sys_tool_check, terminal_feature_check
 from kash.shell.version import get_full_version_name
 from kash.utils.errors import InvalidState
 from kash.workspaces.workspaces import current_ws
@@ -50,8 +50,8 @@ def self_check(brief: bool = False) -> None:
     Self-check kash setup, including termal settings, tools, and API keys.
     """
     if brief:
-        terminal_feature_check().print_term_info()
-        print_api_key_setup(once=False)
+        terminal_check().print_term_info()
+        print_api_key_setup(recommended_keys=RECOMMENDED_API_KEYS, once=False)
         check_system_tools(brief=brief)
         tldr_refresh_cache()
         try:
@@ -63,7 +63,7 @@ def self_check(brief: bool = False) -> None:
     else:
         version()
         cprint()
-        terminal_feature_check().print_term_info()
+        terminal_check().print_term_info()
         cprint()
         list_apis()
         cprint()
@@ -86,28 +86,18 @@ def self_check(brief: bool = False) -> None:
 @kash_command
 def self_configure(all: bool = False, update: bool = False) -> None:
     """
-    Interactively configure your .env file with recommended API keys.
-
-    :param all: Configure all known API keys (instead of just recommended ones).
-    :param update: Update values even if they are already set.
+    Interactively configure API keys and preferred models.
     """
 
+    if all:
+        api_keys = [key.value for key in ApiEnvKey]
+    else:
+        api_keys = RECOMMENDED_API_KEYS
     # Show APIs before starting.
     list_apis()
 
-    apis = Api if all else RECOMMENDED_APIS
-    keys = [api.value for api in apis]
-    if not update:
-        keys = [key for key in keys if not env_var_is_set(key)]
-
-    cprint()
-    print_h2("Configuring .env file")
-    if keys:
-        cprint(format_failure(f"API keys needed: {', '.join(keys)}"))
-        fill_missing_dotenv(keys)
-        reload_env()
-    else:
-        cprint(format_success("All requested API keys are set!"))
+    interactive_dotenv_setup(api_keys, update=update)
+    reload_env()
 
     cprint()
     ws = current_ws()
@@ -170,15 +160,15 @@ def check_system_tools(warn_only: bool = False, brief: bool = False) -> None:
     :param brief: Print summary as a single line.
     """
     if warn_only:
-        sys_tool_check().warn_if_missing()
+        pkg_check().warn_if_missing()
     else:
         if brief:
-            cprint(sys_tool_check().status())
+            cprint(pkg_check().status())
         else:
             print_h2("Installed System Tools")
-            cprint(sys_tool_check().formatted())
+            cprint(pkg_check().formatted())
             cprint()
-            sys_tool_check().warn_if_missing()
+            pkg_check().warn_if_missing()
 
 
 @kash_command
@@ -187,10 +177,10 @@ 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()
+        print_api_key_setup(RECOMMENDED_API_KEYS)
     else:
         raise InvalidState("No .env file found")
 
@@ -209,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
@@ -222,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,11 +7,11 @@ 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_output import cprint, format_name_and_value, print_status
+from kash.shell.output.shell_formatting import format_name_and_value
+from kash.shell.output.shell_output import cprint, print_status
 from kash.shell.utils.native_utils import tail_file
 from kash.utils.common.format_utils import fmt_loc
 
@@ -85,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/base/model_commands.py

@@ -1,17 +1,19 @@
 from flowmark import Wrap
 from rich.text import Text
 
-from kash.config.api_keys import Api
-from kash.config.dotenv_utils import env_var_is_set
-from kash.config.text_styles import format_success_emoji
 from kash.exec.command_registry import kash_command
-from kash.llm_utils import LLM
-from kash.shell.output.shell_output import (
-    cprint,
+from kash.llm_utils import LLM, api_for_model
+from kash.shell.clideps.api_keys import ApiEnvKey
+from kash.shell.clideps.dotenv_utils import env_var_is_set
+from kash.shell.output.shell_formatting import (
     format_failure,
     format_name_and_value,
     format_success,
+    format_success_emoji,
     format_success_or_failure,
+)
+from kash.shell.output.shell_output import (
+    cprint,
     print_h2,
 )
 
@@ -23,11 +25,11 @@ def list_models() -> None:
     """
     print_h2("Models")
     for model in LLM.all_names():
-        api = Api.for_model(model)
-        have_key = bool(api and env_var_is_set(api.env_var))
+        api = api_for_model(model)
+        have_key = bool(api and env_var_is_set(api.value))
         if api:
             provider_msg = format_success(f"provider {api.name}")
-            key_message = format_success_or_failure(have_key, f"{api.env_var}")
+            key_message = format_success_or_failure(have_key, f"{api.value}")
         else:
             provider_msg = format_failure("provider not recognized")
             key_message = format_failure("unknown API key")
@@ -46,11 +48,11 @@ def list_apis() -> None:
     List and check configuration for all APIs.
     """
     print_h2("API keys")
-    for api in Api:
-        emoji = format_success_emoji(env_var_is_set(api.env_var))
+    for api in ApiEnvKey:
+        emoji = format_success_emoji(env_var_is_set(api.value))
         message = (
-            f"API key {api.env_var} found"
-            if env_var_is_set(api.env_var)
-            else f"API key {api.env_var} not found"
+            f"API key {api.value} found"
+            if env_var_is_set(api.value)
+            else f"API key {api.value} not found"
         )
         cprint(Text.assemble(emoji, format_name_and_value(api.name, message)))

kash/commands/base/search_command.py

@@ -3,8 +3,8 @@ from pathlib import Path
 from kash.config.logger import get_logger
 from kash.exec import assemble_path_args, kash_command
 from kash.exec_model.shell_model import ShellResult
+from kash.shell.clideps.pkg_deps import Pkg, pkg_check
 from kash.shell.output.shell_output import cprint
-from kash.shell.utils.sys_tool_deps import SysTool, sys_tool_check
 from kash.utils.common.parse_shell_args import shell_quote
 from kash.utils.errors import InvalidState
 
@@ -33,7 +33,7 @@ def search(
     :param ignore_case: Ignore case when searching.
     :param verbose: Also print the ripgrep command line.
     """
-    sys_tool_check().require(SysTool.ripgrep)
+    pkg_check().require(Pkg.ripgrep)
     from ripgrepy import RipGrepNotFound, Ripgrepy
 
     resolved_paths = assemble_path_args(*paths)

kash/commands/workspace/workspace_commands.py

@@ -36,13 +36,12 @@ from kash.model.items_model import Item, ItemType
 from kash.model.params_model import GLOBAL_PARAMS
 from kash.model.paths_model import StorePath, fmt_store_path
 from kash.shell.input.param_inputs import input_param_name, input_param_value
+from kash.shell.output.shell_formatting import format_name_and_description, format_name_and_value
 from kash.shell.output.shell_output import (
     PrintHooks,
     Wrap,
     console_pager,
     cprint,
-    format_name_and_description,
-    format_name_and_value,
     print_h2,
     print_h3,
     print_status,
@@ -55,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,18 +12,21 @@ from pathlib import Path
 from typing import IO, Any, cast
 
 import rich
-from rich import reconfigure
+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
 
 import kash.config.suppress_warnings  # noqa: F401
-from kash.config.logger_basic import basic_file_handler
-from kash.config.settings import GLOBAL_LOGS_DIR, LogLevel, get_global_kash_dir, global_settings
+from kash.config.logger_basic import basic_file_handler, basic_stderr_handler
+from kash.config.settings import (
+    LogLevel,
+    get_system_logs_dir,
+    global_settings,
+)
 from kash.config.text_styles import (
     EMOJI_ERROR,
     EMOJI_SAVED,
@@ -48,9 +51,9 @@ class LogSettings:
     log_file_path: Path
 
 
-_log_base = get_global_kash_dir()
+_log_dir = get_system_logs_dir()
 """
-Parent of the "logs" directory. Initially the global kash data root.
+Parent of the "logs" directory. Initially the global kash workspace.
 """
 
 
@@ -72,14 +75,14 @@ def make_valid_log_name(name: str) -> str:
 
 
 def _read_log_settings() -> LogSettings:
-    global _log_base, _log_name
+    global _log_dir, _log_name
     return LogSettings(
         log_console_level=global_settings().console_log_level,
         log_file_level=global_settings().file_log_level,
-        global_log_dir=GLOBAL_LOGS_DIR,
-        log_dir=_log_base / "logs",
-        log_objects_dir=_log_base / "logs" / "objects" / _log_name,
-        log_file_path=_log_base / "logs" / f"{_log_name}.log",
+        global_log_dir=get_system_logs_dir(),
+        log_dir=_log_dir,
+        log_objects_dir=_log_dir / "objects" / _log_name,
+        log_file_path=_log_dir / f"{_log_name}.log",
     )
 
 
@@ -102,7 +105,7 @@ def reset_log_root(log_root: Path | None = None, log_name: str | None = None):
     """
     global _log_lock, _log_base, _log_name
     with _log_lock:
-        _log_base = log_root or get_global_kash_dir()
+        _log_base = log_root or get_system_logs_dir()
         _log_name = make_valid_log_name(log_name or LOG_NAME_GLOBAL)
         reload_rich_logging_setup()
 
@@ -125,9 +128,6 @@ def get_theme():
     return Theme(RICH_STYLES)
 
 
-reconfigure(theme=get_theme(), highlighter=get_highlighter())
-
-
 def get_console() -> Console:
     """
     Return the Rich global console, unless it is overridden by a
@@ -166,7 +166,7 @@ def record_console() -> Generator[Console, None, None]:
 
 
 _file_handler: logging.FileHandler
-_console_handler: RichHandler
+_console_handler: logging.Handler
 
 
 def reload_rich_logging_setup():
@@ -210,20 +210,25 @@ def _do_logging_setup(log_settings: LogSettings):
             super().emit(record)
 
     global _console_handler
-    _console_handler = PrefixedRichHandler(
-        # For now we use the fixed global console for logging.
-        # In the future we may want to add a way to have thread-local capture
-        # of all system logs.
-        console=rich.get_console(),
-        level=log_settings.log_console_level.value,
-        show_time=False,
-        show_path=False,
-        show_level=False,
-        highlighter=get_highlighter(),
-        markup=True,
-    )
-    _console_handler.setLevel(log_settings.log_console_level.value)
-    _console_handler.setFormatter(Formatter("%(message)s"))
+
+    # Use the Rich stdout handler only on terminals, stderr for servers or non-interactive use.
+    if get_console().is_terminal:
+        _console_handler = PrefixedRichHandler(
+            # For now we use the fixed global console for logging.
+            # In the future we may want to add a way to have thread-local capture
+            # of all system logs.
+            console=rich.get_console(),
+            level=log_settings.log_console_level.value,
+            show_time=False,
+            show_path=False,
+            show_level=False,
+            highlighter=get_highlighter(),
+            markup=True,
+        )
+        _console_handler.setLevel(log_settings.log_console_level.value)
+        _console_handler.setFormatter(Formatter("%(message)s"))
+    else:
+        _console_handler = basic_stderr_handler(log_settings.log_console_level)
 
     # Manually adjust logging for a few packages, removing previous verbose default handlers.
 
@@ -312,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:
@@ -337,17 +341,12 @@ class CustomLogger(logging.Logger):
         )
 
 
-logging.setLoggerClass(CustomLogger)
-
-
-reload_rich_logging_setup()
-
-
 def get_logger(name: str) -> CustomLogger:
     """
     Get a logger that's compatible with system logging but has our additional custom
     methods.
     """
+    init_rich_logging()
     logger = logging.getLogger(name)
     # print("Logger is", logger)
     return cast(CustomLogger, logger)
@@ -355,3 +354,12 @@ def get_logger(name: str) -> CustomLogger:
 
 def get_log_file_stream():
     return _file_handler.stream
+
+
+@cache
+def init_rich_logging():
+    rich.reconfigure(theme=get_theme(), highlighter=get_highlighter())
+
+    logging.setLoggerClass(CustomLogger)
+
+    reload_rich_logging_setup()

kash/config/logger_basic.py

@@ -1,13 +1,21 @@
 import logging
-from logging import FileHandler, Formatter
+import sys
+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)
@@ -16,7 +24,7 @@ def basic_file_handler(path: Path, level: LogLevel) -> logging.FileHandler:
 
 
 def basic_stderr_handler(level: LogLevel) -> logging.StreamHandler:
-    handler = logging.StreamHandler()
+    handler = SuppressedWarningsStreamHandler(stream=sys.stderr)
     handler.setLevel(level.value)
     handler.setFormatter(Formatter("%(asctime)s %(levelname).1s %(name)s - %(message)s"))
     return handler