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

kash/config/logger.py

@@ -55,6 +55,10 @@ class LogSettings:
     log_objects_dir: Path
     log_file_path: Path
 
+    @property
+    def is_quiet(self) -> bool:
+        return self.log_console_level >= LogLevel.error
+
 
 LOG_NAME_GLOBAL = "workspace"
 
@@ -83,6 +87,13 @@ def get_log_settings() -> LogSettings:
     return _log_settings.copy()
 
 
+def is_console_quiet() -> bool:
+    """
+    Whether to suppress non-logging console output.
+    """
+    return global_settings().console_quiet
+
+
 def make_valid_log_name(name: str) -> str:
     name = str(name).strip().rstrip("/").removesuffix(".log")
     name = re.sub(r"[^\w-]", "_", name)
@@ -244,14 +255,6 @@ def _do_logging_setup(log_settings: LogSettings):
 
     # Manually adjust logging for a few packages, removing previous verbose default handlers.
 
-    try:
-        import litellm
-        from litellm import _logging  # noqa: F401
-
-        litellm.suppress_debug_info = True  # Suppress overly prominent exception messages.
-    except ImportError:
-        pass
-
     log_levels = {
         None: INFO,
         "LiteLLM": INFO,
@@ -276,10 +279,12 @@ def prefix(line: str, emoji: str = "", warn_emoji: str = "") -> str:
     return " ".join(filter(None, [prefix, emojis, line]))
 
 
-def prefix_args(args: tuple[Any], emoji: str = "", warn_emoji: str = "") -> tuple[Any]:
-    if len(args) > 0:
-        args = (prefix(str(args[0]), emoji, warn_emoji),) + args[1:]
-    return args
+def prefix_args(
+    msg: object, *other_args: object, emoji: str = "", warn_emoji: str = ""
+) -> tuple[str, *tuple[object, ...]]:
+    """Prefixes the string representation of msg and returns it with other_args."""
+    prefixed_msg = prefix(str(msg), emoji, warn_emoji)
+    return (prefixed_msg,) + other_args
 
 
 class CustomLogger(logging.Logger):
@@ -290,29 +295,29 @@ class CustomLogger(logging.Logger):
     """
 
     @override
-    def debug(self, *args, **kwargs):
-        super().debug(*prefix_args(args), **kwargs)
+    def debug(self, msg: object, *args: object, **kwargs: Any) -> None:
+        super().debug(*prefix_args(msg, *args), **kwargs)
 
     @override
-    def info(self, *args, **kwargs):
-        super().info(*prefix_args(args), **kwargs)
+    def info(self, msg: object, *args: object, **kwargs: Any) -> None:
+        super().info(*prefix_args(msg, *args), **kwargs)
 
     @override
-    def warning(self, *args, **kwargs):
-        super().warning(*prefix_args(args, warn_emoji=EMOJI_WARN), **kwargs)
+    def warning(self, msg: object, *args: object, **kwargs: Any) -> None:
+        super().warning(*prefix_args(msg, *args, warn_emoji=EMOJI_WARN), **kwargs)
 
     @override
-    def error(self, *args, **kwargs):
-        super().error(*prefix_args(args, warn_emoji=EMOJI_ERROR), **kwargs)
+    def error(self, msg: object, *args: object, **kwargs: Any) -> None:
+        super().error(*prefix_args(msg, *args, warn_emoji=EMOJI_ERROR), **kwargs)
 
-    def log_at(self, level: LogLevel, *args, **kwargs):
+    def log_at(self, level: LogLevel, *args: object, **kwargs: Any) -> None:
         getattr(self, level.name)(*args, **kwargs)
 
-    def message(self, *args, **kwargs):
+    def message(self, msg: object, *args: object, **kwargs: Any) -> None:
         """
         An informative message that should appear even if log level is set to warning.
         """
-        super().warning(*prefix_args(args), **kwargs)
+        super().warning(*prefix_args(msg, *args), **kwargs)
 
     def save_object(
         self,
@@ -321,7 +326,7 @@ class CustomLogger(logging.Logger):
         obj: Any,
         level: LogLevel = LogLevel.info,
         file_ext: str = "txt",
-    ):
+    ) -> None:
         """
         Save an object to a file in the log directory. Useful for details too large to
         log normally but useful for debugging.
@@ -342,7 +347,7 @@ class CustomLogger(logging.Logger):
 
         self.log_at(level, "%s %s saved: %s", EMOJI_SAVED, description, path)
 
-    def dump_stack(self, all_threads: bool = True, level: LogLevel = LogLevel.info):
+    def dump_stack(self, all_threads: bool = True, level: LogLevel = LogLevel.info) -> None:
         self.log_at(level, "Stack trace dump:\n%s", current_stack_traces(all_threads))
 
     def __repr__(self):

kash/config/logger_basic.py

@@ -3,7 +3,7 @@ import sys
 from logging import FileHandler, Formatter, LogRecord
 from pathlib import Path
 
-from kash.config.settings import LogLevel
+from kash.config.settings import LogLevel, LogLevelStr
 from kash.config.suppress_warnings import demote_warnings
 
 # Basic logging setup for non-interactive logging, like on a server.
@@ -16,21 +16,21 @@ class SuppressedWarningsStreamHandler(logging.StreamHandler):
         super().emit(record)
 
 
-def basic_file_handler(path: Path, level: LogLevel) -> logging.FileHandler:
+def basic_file_handler(path: Path, level: LogLevel | LogLevelStr) -> logging.FileHandler:
     handler = logging.FileHandler(path)
-    handler.setLevel(level.value)
+    handler.setLevel(LogLevel.parse(level).value)
     handler.setFormatter(Formatter("%(asctime)s %(levelname).1s %(name)s - %(message)s"))
     return handler
 
 
-def basic_stderr_handler(level: LogLevel) -> logging.StreamHandler:
+def basic_stderr_handler(level: LogLevel | LogLevelStr) -> logging.StreamHandler:
     handler = SuppressedWarningsStreamHandler(stream=sys.stderr)
-    handler.setLevel(level.value)
+    handler.setLevel(LogLevel.parse(level).value)
     handler.setFormatter(Formatter("%(asctime)s %(levelname).1s %(name)s - %(message)s"))
     return handler
 
 
-def basic_logging_setup(log_path: Path | None, level: LogLevel):
+def basic_logging_setup(log_path: Path | None, level: LogLevel | LogLevelStr):
     """
     Set up basic logging to a file and to stderr.
     """

kash/config/settings.py

@@ -1,10 +1,13 @@
+from __future__ import annotations
+
 import os
-from enum import Enum
+from dataclasses import dataclass
+from enum import IntEnum
 from functools import cache
 from logging import DEBUG, ERROR, INFO, WARNING
 from pathlib import Path
+from typing import Literal
 
-from pydantic.dataclasses import dataclass
 from strif import AtomicVar
 
 from kash.config.env_settings import KashEnv
@@ -64,7 +67,14 @@ LOCAL_SERVER_PORTS_MAX = 30
 LOCAL_SERVER_LOG_NAME = "local_server"
 
 
-class LogLevel(Enum):
+LogLevelStr = Literal["debug", "info", "message", "warning", "error"]
+
+
+class LogLevel(IntEnum):
+    """
+    Convenience enum for log levels with parsing and ordering.
+    """
+
     debug = DEBUG
     info = INFO
     warning = WARNING
@@ -72,7 +82,9 @@ class LogLevel(Enum):
     error = ERROR
 
     @classmethod
-    def parse(cls, level_str: str):
+    def parse(cls, level_str: str | LogLevelStr | LogLevel) -> LogLevel:
+        if isinstance(level_str, LogLevel):
+            return level_str
         canon_name = level_str.strip().lower()
         if canon_name == "warn":
             canon_name = "warning"
@@ -87,7 +99,7 @@ class LogLevel(Enum):
         return self.name
 
 
-DEFAULT_LOG_LEVEL = LogLevel.parse(KashEnv.KASH_LOG_LEVEL.read_str("warning"))
+DEFAULT_LOG_LEVEL = LogLevel.parse(KashEnv.KASH_LOG_LEVEL.read_str(default="warning"))
 
 
 def resolve_and_create_dirs(path: Path | str, is_dir: bool = False) -> Path:
@@ -174,6 +186,9 @@ class Settings:
     console_log_level: LogLevel
     """The log level for console-based logging."""
 
+    console_quiet: bool
+    """If true, suppress non-logging console output."""
+
     file_log_level: LogLevel
     """The log level for file-based logging."""
 
@@ -205,7 +220,7 @@ def _get_ws_root_dir() -> Path:
 
 
 def _get_global_ws_dir() -> Path:
-    kash_ws_dir = KashEnv.KASH_GLOBAL_WS.read_path()
+    kash_ws_dir = KashEnv.KASH_GLOBAL_WS.read_path(default=None)
     if kash_ws_dir:
         return kash_ws_dir
     else:
@@ -225,7 +240,7 @@ def _get_system_cache_dir() -> Path:
 
 
 def _get_mcp_ws_dir() -> Path | None:
-    mcp_dir = KashEnv.KASH_MCP_WS.read_str()
+    mcp_dir = KashEnv.KASH_MCP_WS.read_str(default=None)
     if mcp_dir:
         return Path(mcp_dir).expanduser().resolve()
     else:
@@ -254,6 +269,7 @@ def _read_settings():
         default_editor="nano",
         file_log_level=LogLevel.info,
         console_log_level=DEFAULT_LOG_LEVEL,
+        console_quiet=False,
         local_server_ports_start=LOCAL_SERVER_PORT_START,
         local_server_ports_max=LOCAL_SERVER_PORTS_MAX,
         local_server_port=0,

kash/config/setup.py

@@ -7,7 +7,13 @@ from clideps.env_vars.dotenv_utils import load_dotenv_paths
 
 from kash.config.logger import reset_rich_logging
 from kash.config.logger_basic import basic_logging_setup
-from kash.config.settings import LogLevel, configure_ws_and_settings, global_settings
+from kash.config.settings import (
+    LogLevel,
+    LogLevelStr,
+    atomic_global_settings,
+    configure_ws_and_settings,
+    global_settings,
+)
 
 
 @cache
@@ -16,7 +22,9 @@ def kash_setup(
     rich_logging: bool,
     kash_ws_root: Path | None = None,
     log_path: Path | None = None,
-    level: LogLevel = LogLevel.info,
+    log_level: LogLevel | LogLevelStr | None = None,
+    console_log_level: LogLevel | LogLevelStr | None = None,
+    console_quiet: bool | None = None,
 ):
     """
     One-time top-level setup of essential logging, keys, directories, and configs.
@@ -25,8 +33,14 @@ def kash_setup(
     Can call this if embedding kash in another app.
     Can be used to set the global default workspace and logs directory
     and/or the default log file.
-    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.
+
+    Basic logging is to the specified log file.
+    If enabled, rich logging is to the console as well.
+
+    By default console is "warning" level but can be controlled with
+    the `console_log_level` parameter.
+    All console/shell output can be suppressed with `console_quiet`. By default
+    console is quiet if `console_log_level` is "error" or higher.
     """
     from kash.utils.common.stack_traces import add_stacktrace_handler
 
@@ -40,10 +54,24 @@ def kash_setup(
         configure_ws_and_settings(kash_ws_root)
 
     # Now set up logging, as it might depend on workspace root.
+    log_level = LogLevel.parse(log_level) if log_level else LogLevel.info
+
     if rich_logging:
+        # These settings are only used for rich logging.
+        console_log_level = (
+            LogLevel.parse(console_log_level) if console_log_level else LogLevel.warning
+        )
+        console_quiet = (
+            console_quiet if console_quiet is not None else console_log_level >= LogLevel.error
+        )
+
+        with atomic_global_settings().updates() as settings:
+            settings.console_log_level = console_log_level
+            settings.file_log_level = log_level
+            settings.console_quiet = console_quiet
         reset_rich_logging(log_path=log_path)
     else:
-        basic_logging_setup(log_path=log_path, level=level)
+        basic_logging_setup(log_path=log_path, level=log_level)
 
     _lib_setup()
 

kash/config/text_styles.py

@@ -73,8 +73,8 @@ COLOR_VALUE = "cyan"
 COLOR_PATH = "cyan"
 COLOR_HINT = "bright_black"
 COLOR_HINT_DIM = "dim bright_black"
-COLOR_SKIP = "green"
-COLOR_TASK = "magenta"
+COLOR_SKIP = "bright_blue"
+COLOR_ACTION = "magenta"
 COLOR_SAVED = "blue"
 COLOR_TIMING = "bright_black"
 COLOR_CALL = "bright_yellow"
@@ -133,7 +133,7 @@ RICH_STYLES = {
     "hint": COLOR_HINT,
     "hint_dim": COLOR_HINT_DIM,
     "skip": COLOR_SKIP,
-    "task": COLOR_TASK,
+    "action": COLOR_ACTION,
     "saved": COLOR_SAVED,
     "timing": COLOR_TIMING,
     "call": COLOR_CALL,
@@ -218,12 +218,14 @@ RICH_STYLES = {
     "kash.size_k": STYLE_SIZE2,
     "kash.size_m": STYLE_SIZE3,
     "kash.size_gtp": STYLE_SIZE4,
-    "kash.filename": Style(color=COLOR_VALUE),
-    "kash.task_stack_header": Style(color=COLOR_TASK),
-    "kash.task_stack": Style(color=COLOR_TASK),
+    "kash.filename": Style(color=COLOR_HINT),
+    "kash.start_action": Style(color=COLOR_ACTION, bold=True),
+    "kash.task_stack_header": Style(color=COLOR_HINT),
+    "kash.task_stack": Style(color=COLOR_HINT),
     "kash.task_stack_prefix": Style(color=COLOR_HINT),
     # Emoji colors:
-    "kash.task": Style(color=COLOR_TASK),
+    "kash.action": Style(color=COLOR_ACTION),
+    "kash.start": Style(color=COLOR_ACTION, bold=True),
     "kash.success": Style(color=COLOR_SUCCESS, bold=True),
     "kash.skip": Style(color=COLOR_SKIP, bold=True),
     "kash.failure": Style(color=COLOR_ERROR, bold=True),
@@ -259,17 +261,24 @@ PROMPT_ASSIST = "(assistant) ❯"
 
 EMOJI_HINT = "👉"
 
-# More ideas: ⦿⧁⧀⦿⦾⟐⦊⟡
+EMOJI_MSG_INDENT = "⋮"
 
+EMOJI_START = "[➤]"
 
-EMOJI_COMMAND = "⧁"
+EMOJI_SUCCESS = "[✔︎]"
 
-EMOJI_ACTION = "⛭"
+EMOJI_SKIP = "[-]"
+
+EMOJI_FAILURE = "[✘]"
 
 EMOJI_SNIPPET = "❯"
 
 EMOJI_HELP = "?"
 
+EMOJI_ACTION = "⛭"
+
+EMOJI_COMMAND = "⧁"  # More ideas: ⦿⧁⧀⦿⦾⟐⦊⟡
+
 EMOJI_SHELL = "⦊"
 
 EMOJI_RECOMMENDED = "•"
@@ -282,26 +291,18 @@ EMOJI_SAVED = "⩣"
 
 EMOJI_TIMING = "⏱"
 
-EMOJI_SUCCESS = "[✔︎]"
-
-EMOJI_SKIP = "[∕]"
-
-EMOJI_FAILURE = "[✘]"
-
 EMOJI_CALL_BEGIN = "≫"
 
 EMOJI_CALL_END = "≪"
 
 EMOJI_ASSISTANT = "🤖"
 
-EMOJI_MSG_INDENT = "⋮"
-
 EMOJI_BREADCRUMB_SEP = "›"
 
 
 ## Special headings
 
-TASK_STACK_HEADER = "Task stack:"
+TASK_STACK_HEADER = "Task stack"
 
 
 ## Rich setup
@@ -320,15 +321,17 @@ class KashHighlighter(RegexHighlighter):
     base_style = "kash."
     highlights = [
         _combine_regex(
+            # Important patterns that color the whole line:
+            f"(?P<start_action>{re.escape(EMOJI_START + ' Action')}.*)",
+            f"(?P<timing>{re.escape(EMOJI_TIMING)}.*)",
             # Task stack in logs:
             f"(?P<task_stack_header>{re.escape(TASK_STACK_HEADER)})",
             f"(?P<task_stack>{re.escape(EMOJI_BREADCRUMB_SEP)}.*)",
             f"(?P<task_stack_prefix>{re.escape(EMOJI_MSG_INDENT)})",
-            # Emojis that color the whole line:
-            f"(?P<timing>{re.escape(EMOJI_TIMING)}.*)",
             # Color emojis by themselves:
             f"(?P<saved>{re.escape(EMOJI_SAVED)})",
-            f"(?P<task>{re.escape(EMOJI_ACTION)})",
+            f"(?P<action>{re.escape(EMOJI_ACTION)})",
+            f"(?P<start>{re.escape(EMOJI_START)})",
             f"(?P<success>{re.escape(EMOJI_SUCCESS)})",
             f"(?P<skip>{re.escape(EMOJI_SKIP)})",
             f"(?P<failure>{re.escape(EMOJI_FAILURE)})",

kash/docs/load_source_code.py

@@ -104,7 +104,7 @@ def load_source_code() -> SourceCode:
             kash_base_path / "model" / "assistant_response_model.py",
         ),
         text_tool_src=read_source_code(
-            kash_base_path / "text_handling",
+            kash_base_path / "utils" / "text_handling",
             kash_base_path / "utils" / "lang_utils",
             # TODO: Include additional dep libs like chopdiff TextDoc too?
         ),

kash/embeddings/cosine.py

@@ -1,10 +1,16 @@
+from __future__ import annotations
+
 from collections.abc import Sequence
-from typing import Any, TypeAlias
+from typing import TYPE_CHECKING, Any, TypeAlias
 
-import numpy as np
+if TYPE_CHECKING:
+    from numpy import ndarray
 
-# Type aliases for clarity
-ArrayLike: TypeAlias = Sequence[float] | np.ndarray[Any, Any]
+    # Type aliases for clarity
+    ArrayLike: TypeAlias = Sequence[float] | ndarray[Any, Any]
+else:
+    # Keep numpy import lazy.
+    ArrayLike = Any
 
 
 def cosine(u: ArrayLike, v: ArrayLike) -> float:
@@ -12,6 +18,8 @@ def cosine(u: ArrayLike, v: ArrayLike) -> float:
     Compute the cosine distance between two 1-D arrays.
     Could use scipy.spatial.distance.cosine, but avoiding the dependency.
     """
+    import numpy as np
+
     # Convert to numpy arrays
     u_array = np.asarray(u, dtype=np.float64)
     v_array = np.asarray(v, dtype=np.float64)

kash/embeddings/embeddings.py

@@ -3,17 +3,18 @@ from __future__ import annotations
 import ast
 from collections.abc import Iterable
 from pathlib import Path
-from typing import TypeAlias, cast
+from typing import TYPE_CHECKING, TypeAlias, cast
 
-import pandas as pd
-from litellm import embedding
-from litellm.types.utils import EmbeddingResponse
 from pydantic.dataclasses import dataclass
 from strif import abbrev_list
 
 from kash.config.logger import get_logger
+from kash.llm_utils.init_litellm import init_litellm
 from kash.llm_utils.llms import DEFAULT_EMBEDDING_MODEL
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 log = get_logger(__name__)
 
 
@@ -41,11 +42,13 @@ class Embeddings:
     def as_iterable(self) -> Iterable[tuple[Key, str, list[float]]]:
         return ((key, text, emb) for key, (text, emb) in self.data.items())
 
-    def as_df(self) -> pd.DataFrame:
+    def as_df(self) -> DataFrame:
+        from pandas import DataFrame
+
         keys, texts, embeddings = zip(
             *[(key, text, emb) for key, (text, emb) in self.data.items()], strict=False
         )
-        return pd.DataFrame(
+        return DataFrame(
             {
                 "key": keys,
                 "text": texts,
@@ -61,6 +64,11 @@ class Embeddings:
 
     @classmethod
     def embed(cls, keyvals: list[KeyVal], model=DEFAULT_EMBEDDING_MODEL) -> Embeddings:
+        from litellm import embedding
+        from litellm.types.utils import EmbeddingResponse
+
+        init_litellm()
+
         data = {}
         log.message(
             "Embedding %d texts (model %s, batch size %s)…",
@@ -102,6 +110,8 @@ class Embeddings:
 
     @classmethod
     def read_from_csv(cls, path: Path) -> Embeddings:
+        import pandas as pd
+
         df = pd.read_csv(path)
         df["embedding"] = df["embedding"].apply(ast.literal_eval)
         data = {row["key"]: (row["text"], row["embedding"]) for _, row in df.iterrows()}

kash/embeddings/text_similarity.py

@@ -1,9 +1,8 @@
-from typing import cast
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
 
-import litellm
 from funlog import log_calls
-from litellm import embedding
-from litellm.types.utils import EmbeddingResponse
 
 from kash.config.logger import get_logger
 from kash.embeddings.cosine import ArrayLike, cosine
@@ -11,6 +10,9 @@ from kash.embeddings.embeddings import Embeddings
 from kash.llm_utils.llms import DEFAULT_EMBEDDING_MODEL, EmbeddingModel
 from kash.utils.errors import ApiResultError
 
+if TYPE_CHECKING:
+    from litellm.types.utils import EmbeddingResponse
+
 log = get_logger(__name__)
 
 
@@ -20,6 +22,10 @@ def cosine_relatedness(x: ArrayLike, y: ArrayLike) -> float:
 
 @log_calls(level="info", show_return_value=False)
 def embed_query(model: EmbeddingModel, query: str) -> EmbeddingResponse:
+    import litellm
+    from litellm import embedding
+    from litellm.types.utils import EmbeddingResponse
+
     try:
         response: EmbeddingResponse = cast(
             EmbeddingResponse, embedding(model=model.litellm_name, input=[query])

kash/exec/__init__.py

@@ -12,6 +12,7 @@ from kash.exec.resolve_args import (
     resolve_locator_arg,
     resolve_path_arg,
 )
+from kash.exec.runtime_settings import current_runtime_settings, kash_runtime
 
 __all__ = [
     "kash_action",
@@ -20,6 +21,8 @@ __all__ = [
     "prepare_action_input",
     "run_action_with_shell_context",
     "kash_command",
+    "kash_runtime",
+    "current_runtime_settings",
     "import_and_register",
     "llm_transform_item",
     "llm_transform_str",

kash/exec/action_decorators.py

@@ -21,22 +21,22 @@ from typing_extensions import override
 from kash.config.logger import get_logger
 from kash.exec.action_exec import run_action_with_caching
 from kash.exec.action_registry import register_action_class
+from kash.exec.runtime_settings import current_runtime_settings
 from kash.exec_model.args_model import ONE_ARG, ArgCount, ArgType
 from kash.model.actions_model import (
     Action,
     ActionInput,
     ActionResult,
-    ExecContext,
     LLMOptions,
     ParamSource,
     TitleTemplate,
 )
-from kash.model.items_model import Item, ItemType, State
+from kash.model.exec_model import ExecContext
+from kash.model.items_model import Item, ItemType
 from kash.model.params_model import Param, ParamDeclarations, TypedParamValues
 from kash.model.preconditions_model import Precondition
 from kash.utils.common.function_inspect import FuncParam, inspect_function_params
 from kash.utils.errors import InvalidDefinition
-from kash.workspaces.workspaces import current_ws
 
 log = get_logger(__name__)
 
@@ -209,13 +209,6 @@ def kash_action(
     mcp_tool: bool = False,
     title_template: TitleTemplate = TitleTemplate("{title}"),
     llm_options: LLMOptions = LLMOptions(),
-    override_state: State | None = None,
-    # Including these for completeness but usually don't want to set them globally
-    # in the decorator:
-    rerun: bool = False,
-    refetch: bool = False,
-    tmp_output: bool = False,
-    no_format: bool = False,
 ) -> Callable[[AF], AF]:
     """
     A function decorator to create and register an action. The annotated function must
@@ -386,15 +379,7 @@ def kash_action(
             if provided_context:
                 context = provided_context
             else:
-                context = ExecContext(
-                    action,
-                    current_ws().base_dir,
-                    rerun=rerun,
-                    refetch=refetch,
-                    override_state=override_state,
-                    tmp_output=tmp_output,
-                    no_format=no_format,
-                )
+                context = ExecContext(action, current_runtime_settings())
 
             # Run the action.
             result, _, _ = run_action_with_caching(context, action_input)