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

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__)
 
@@ -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)

kash/exec/action_exec.py

@@ -4,7 +4,12 @@ from dataclasses import replace
 from prettyfmt import fmt_lines
 
 from kash.config.logger import get_logger
-from kash.config.text_styles import EMOJI_SKIP, EMOJI_SUCCESS, EMOJI_TIMING
+from kash.config.text_styles import (
+    EMOJI_SKIP,
+    EMOJI_START,
+    EMOJI_SUCCESS,
+    EMOJI_TIMING,
+)
 from kash.exec.preconditions import is_url_item
 from kash.exec.resolve_args import assemble_action_args
 from kash.exec_model.args_model import CommandArg
@@ -17,15 +22,16 @@ from kash.model.actions_model import (
     ExecContext,
     PathOpType,
 )
+from kash.model.exec_model import RuntimeSettings
 from kash.model.items_model import Item, State
 from kash.model.operations_model import Input, Operation, Source
 from kash.model.params_model import ALL_COMMON_PARAMS, GLOBAL_PARAMS, RawParamValues
 from kash.model.paths_model import StorePath
-from kash.shell.output.shell_output import PrintHooks, print_h3
+from kash.shell.output.shell_output import PrintHooks
+from kash.utils.common.inflection import plural
 from kash.utils.common.task_stack import task_stack
 from kash.utils.common.type_utils import not_none
-from kash.utils.errors import NONFATAL_EXCEPTIONS, ContentError, InvalidOutput
-from kash.utils.lang_utils.inflection import plural
+from kash.utils.errors import ContentError, InvalidOutput, get_nonfatal_exceptions
 from kash.workspaces import Selection, current_ws
 from kash.workspaces.workspace_importing import import_and_load
 
@@ -63,6 +69,7 @@ def validate_action_input(
     """
     Validate an action input, ensuring the right number of args, all explicit params are filled,
     and the precondition holds and return an `Operation` that describes what will happen.
+    For flexibility, we don't require the items to be saved (have a store path).
     """
     input_items = action_input.items
     # Validations:
@@ -75,10 +82,16 @@ def validate_action_input(
 
     # Now make a note of the the operation we will perform.
     # If the inputs are paths, record the input paths, including hashes.
-    store_paths = [StorePath(not_none(item.store_path)) for item in input_items if item.store_path]
-    inputs = [Input(store_path, ws.hash(store_path)) for store_path in store_paths]
+    def input_for(item: Item) -> Input:
+        if item.store_path:
+            return Input(StorePath(item.store_path), ws.hash(StorePath(item.store_path)))
+        else:
+            return Input(path=None, source_info="unsaved")
+
+    inputs = [input_for(item) for item in input_items]
+
     # Add any non-default runtime options into the options summary.
-    options = {**action.param_value_summary(), **context.runtime_options}
+    options = {**action.param_value_summary(), **context.settings.non_default_options}
     operation = Operation(action.name, inputs, options)
 
     return operation
@@ -89,7 +102,7 @@ def log_action(action: Action, action_input: ActionInput, operation: Operation):
     Log the action and the operation we are about to run.
     """
     PrintHooks.before_log_action_run()
-    print_h3(f"Action `{action.name}`")
+    log.message("%s Action: `%s`", EMOJI_START, action.name)
     log.message("Running: `%s`", operation.command_line(with_options=True))
     if len(action.param_value_summary()) > 0:
         log.message("Parameters:\n%s", action.param_value_summary_str())
@@ -106,8 +119,9 @@ def check_for_existing_result(
     already exist.
     """
     action = context.action
-    ws = context.workspace
-    rerun = context.rerun
+    settings = context.settings
+    ws = settings.workspace
+    rerun = settings.rerun
 
     existing_result = None
 
@@ -154,6 +168,7 @@ def run_action_operation(
 
     # Run the action.
     action = context.action
+    settings = context.settings
     if action.run_per_item:
         result = _run_for_each_item(context, action_input)
     else:
@@ -172,9 +187,9 @@ def run_action_operation(
         item.update_history(Source(operation=this_op, output_num=i, cacheable=action.cacheable))
 
     # Override the state if appropriate (this handles marking items as transient).
-    if context.override_state:
+    if settings.override_state:
         for item in result.items:
-            item.state = context.override_state
+            item.state = settings.override_state
 
     log.info("Action `%s` result: %s", action.name, result)
 
@@ -233,7 +248,7 @@ def _run_for_each_item(context: ExecContext, input: ActionInput) -> ActionResult
                 log.info("Caught SkipItem exception, skipping run on this item")
                 result_items.append(item)
                 continue
-            except NONFATAL_EXCEPTIONS as e:
+            except get_nonfatal_exceptions() as e:
                 errors.append(e)
                 had_error = True
 
@@ -293,14 +308,18 @@ def save_action_result(
             fmt_lines(skipped_paths),
         )
 
-    input_store_paths = [StorePath(not_none(item.store_path)) for item in input_items]
+    unsaved_items = [item for item in input_items if not item.store_path]
+    input_store_paths = [StorePath(item.store_path) for item in input_items if item.store_path]
     result_store_paths = [StorePath(item.store_path) for item in result.items if item.store_path]
     old_inputs = sorted(set(input_store_paths) - set(result_store_paths))
+    if unsaved_items:
+        log.info("unsaved_items:\n%s", fmt_lines(unsaved_items))
     log.info("result_store_paths:\n%s", fmt_lines(result_store_paths))
-    log.info("old_inputs:\n%s", fmt_lines(old_inputs))
+    if old_inputs:
+        log.info("old_inputs:\n%s", fmt_lines(old_inputs))
 
     # If there is a hint that the action replaces the input, archive any inputs that are not in the result.
-    archived_store_paths = []
+    archived_store_paths: list[StorePath] = []
     if result.replaces_input and input_items:
         for input_store_path in old_inputs:
             # Note some outputs may be missing if replace_input was used.
@@ -325,7 +344,8 @@ def run_action_with_caching(
     Note: Mutates the input but only to add `context` to each item.
     """
     action = context.action
-    ws = context.workspace
+    settings = context.settings
+    ws = settings.workspace
 
     # For convenience, we include the context to each item too (this helps so per-item
     # functions don't have to take context args everywhere).
@@ -341,7 +361,7 @@ def run_action_with_caching(
     # Check if a previous run already produced the result.
     existing_result = check_for_existing_result(context, action_input, operation)
 
-    if existing_result and not context.rerun:
+    if existing_result and not settings.rerun:
         # Use the cached result.
         result = existing_result
         result_store_paths = [StorePath(not_none(item.store_path)) for item in result.items]
@@ -349,7 +369,7 @@ def run_action_with_caching(
 
         PrintHooks.before_done_message()
         log.message(
-            "%s Action skipped: `%s` completed with %s %s",
+            "%s Skipped: `%s` completed with %s %s",
             EMOJI_SKIP,
             action.name,
             len(result.items),
@@ -359,12 +379,12 @@ def run_action_with_caching(
         # Run it!
         result = run_action_operation(context, action_input, operation)
         result_store_paths, archived_store_paths = save_action_result(
-            ws, result, action_input, as_tmp=context.tmp_output, no_format=context.no_format
+            ws, result, action_input, as_tmp=settings.tmp_output, no_format=settings.no_format
         )
 
         PrintHooks.before_done_message()
         log.message(
-            "%s Action done: `%s` completed with %s %s",
+            "%s Done: `%s` completed with %s %s",
             EMOJI_SUCCESS,
             action.name,
             len(result.items),
@@ -415,8 +435,7 @@ def run_action_with_shell_context(
     action_name = action.name
 
     # Execution context. This is fixed for the duration of the action.
-    context = ExecContext(
-        action=action,
+    settings = RuntimeSettings(
         workspace_dir=ws.base_dir,
         rerun=rerun,
         refetch=refetch,
@@ -424,6 +443,7 @@ def run_action_with_shell_context(
         tmp_output=tmp_output,
         no_format=no_format,
     )
+    context = ExecContext(action, settings)
 
     # Collect args from the provided args or otherwise the current selection.
     args, from_selection = assemble_action_args(*provided_args, use_selection=action.uses_selection)

kash/exec/llm_transforms.py

@@ -13,7 +13,7 @@ from kash.llm_utils.llm_completion import llm_template_completion
 from kash.llm_utils.llm_messages import Message, MessageTemplate
 from kash.model.actions_model import LLMOptions
 from kash.model.items_model import Item
-from kash.text_handling.doc_normalization import normalize_formatting_ansi
+from kash.text_handling.doc_normalization import normalize_formatting
 from kash.utils.errors import InvalidInput
 from kash.utils.file_utils.file_formats_model import Format
 
@@ -118,7 +118,7 @@ def llm_transform_item(
     if strip_fence:
         result_str = strip_markdown_fence(result_str)
     if normalize:
-        result_str = normalize_formatting_ansi(result_str, format=format)
+        result_str = normalize_formatting(result_str, format=format)
 
     result_item.body = result_str
     return result_item

kash/exec/preconditions.py

@@ -85,13 +85,13 @@ def contains_curly_vars(item: Item) -> bool:
 
 
 @kash_precondition
-def has_text_body(item: Item) -> bool:
-    return has_body(item) and item.format in (Format.plaintext, Format.markdown, Format.md_html)
+def has_simple_text_body(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_simple_text)
 
 
 @kash_precondition
 def has_html_body(item: Item) -> bool:
-    return has_body(item) and item.format in (Format.html, Format.md_html)
+    return bool(has_body(item) and item.format and item.format.is_html)
 
 
 @kash_precondition
@@ -106,7 +106,7 @@ def is_plaintext(item: Item) -> bool:
 
 @kash_precondition
 def is_markdown(item: Item) -> bool:
-    return has_body(item) and item.format in (Format.markdown, Format.md_html)
+    return bool(has_body(item) and item.format and item.format.is_markdown)
 
 
 @kash_precondition
@@ -119,14 +119,6 @@ def is_html(item: Item) -> bool:
     return has_body(item) and item.format == Format.html
 
 
-@kash_precondition
-def is_text_doc(item: Item) -> bool:
-    """
-    A document that can be processed by LLMs and other plaintext tools.
-    """
-    return (is_plaintext(item) or is_markdown(item)) and has_body(item)
-
-
 @kash_precondition
 def is_markdown_list(item: Item) -> bool:
     try: