kash-shell 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

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/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__)
 
@@ -174,7 +174,7 @@ def _merge_param_declarations(
             merged_params[fp.name] = Param(
                 name=fp.name,
                 description=None,
-                type=fp.type or str,
+                type=fp.effective_type or str,
                 default_value=fp.default if fp.has_default else None,
                 is_explicit=not fp.has_default,
             )
@@ -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
@@ -248,13 +241,13 @@ def kash_action(
 
         # Inspect and sanity check the formal params.
         func_params = inspect_function_params(orig_func)
-        if len(func_params) == 0 or func_params[0].type not in (ActionInput, Item):
+        if len(func_params) == 0 or func_params[0].effective_type not in (ActionInput, Item):
             raise InvalidDefinition(
                 f"Decorator `@kash_action` requires exactly one positional parameter, "
                 f"`input` of type `ActionInput` or `Item` on function `{orig_func.__name__}` but "
                 f"got params: {func_params}"
             )
-        if any(fp.is_positional for fp in func_params[1:]):
+        if any(fp.is_pure_positional for fp in func_params[1:]):
             raise InvalidDefinition(
                 "Decorator `@kash_action` requires all parameters after the first positional "
                 f"parameter to be keyword parameters on function `{orig_func.__name__}` but "
@@ -265,7 +258,7 @@ def kash_action(
         context_param = next((fp for fp in func_params if fp.name == "context"), None)
         if context_param:
             func_params.remove(context_param)
-        if context_param and context_param.is_positional:
+        if context_param and context_param.is_pure_positional:
             raise InvalidDefinition(
                 "Decorator `@kash_action` requires the `context` parameter to be a keyword "
                 "parameter, not positional, on function `{func.__name__}`"
@@ -273,7 +266,7 @@ def kash_action(
 
         # If the original function is a simple action function (processes a single item),
         # wrap it to convert to an ActionFunction.
-        is_simple_func = func_params[0].type == Item
+        is_simple_func = func_params[0].effective_type == Item
         action_func: ActionFunction
         if is_simple_func:
             simple_func = cast(SimpleActionFunction, orig_func)
@@ -333,7 +326,7 @@ def kash_action(
                 if context_param:
                     kw_args["context"] = context
                 for fp in func_params[1:]:
-                    if fp.is_positional:
+                    if fp.is_pure_positional:
                         pos_args.append(self.get_param(fp.name))
                     else:
                         kw_args[fp.name] = self.get_param(fp.name)
@@ -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)