kash-shell 0.3.18__py3-none-any.whl → 0.3.21__py3-none-any.whl

kash/actions/core/{markdownify.py → markdownify_html.py}

@@ -11,13 +11,10 @@ from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
 log = get_logger(__name__)
 
 
-@kash_action(
-    precondition=is_url_resource | has_html_body,
-    mcp_tool=True,
-)
-def markdownify(item: Item) -> Item:
+@kash_action(precondition=is_url_resource | has_html_body, mcp_tool=True)
+def markdownify_html(item: Item) -> Item:
     """
-    Converts a URL or raw HTML item to Markdown, fetching with the content
+    Converts raw HTML or the URL of an HTML page to Markdown, fetching with the content
     cache if needed. Also uses readability to clean up the HTML.
     """
 

kash/commands/workspace/workspace_commands.py

@@ -23,14 +23,12 @@ from kash.exec import (
     resolve_locator_arg,
 )
 from kash.exec.action_registry import get_all_actions_defaults
-from kash.exec.fetch_url_metadata import fetch_url_metadata
+from kash.exec.fetch_url_items import fetch_url_item
 from kash.exec.precondition_checks import actions_matching_paths
 from kash.exec.precondition_registry import get_all_preconditions
-from kash.exec.preconditions import is_url_resource
 from kash.exec_model.shell_model import ShellResult
 from kash.local_server.local_url_formatters import local_url_formatter
 from kash.media_base import media_tools
-from kash.media_base.media_services import is_media_url
 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
@@ -54,12 +52,11 @@ from kash.utils.common.format_utils import fmt_loc
 from kash.utils.common.obj_replace import remove_values
 from kash.utils.common.parse_key_vals import parse_key_value
 from kash.utils.common.type_utils import not_none
-from kash.utils.common.url import Url, is_url, parse_http_url
+from kash.utils.common.url import Url
 from kash.utils.errors import InvalidInput
 from kash.utils.file_formats.chat_format import tail_chat_history
 from kash.utils.file_utils.dir_info import is_nonempty_dir
 from kash.utils.file_utils.file_formats_model import Format
-from kash.utils.text_handling.doc_normalization import can_normalize
 from kash.web_content.file_cache_utils import cache_file
 from kash.workspaces import (
     current_ws,
@@ -189,85 +186,6 @@ def cache_content(*urls_or_paths: str, refetch: bool = False) -> None:
         PrintHooks.spacer()
 
 
-@kash_command
-def download(*urls_or_paths: str, refetch: bool = False, no_format: bool = False) -> ShellResult:
-    """
-    Download a URL or resource. Uses cached content if available, unless `refetch` is true.
-    Inputs can be URLs or paths to URL resources.
-    Creates both resource and document versions for text content.
-
-    :param no_format: If true, do not also normalize Markdown content.
-    """
-    ws = current_ws()
-    saved_paths = []
-
-    for url_or_path in urls_or_paths:
-        locator = resolve_locator_arg(url_or_path)
-        url: Url | None = None
-
-        # Get the URL from the locator
-        if not isinstance(locator, Path) and is_url(locator):
-            url = Url(locator)
-        elif isinstance(locator, StorePath):
-            url_item = ws.load(locator)
-            if is_url_resource(url_item):
-                url = url_item.url
-
-        if not url:
-            raise InvalidInput(f"Not a URL or URL resource: {fmt_loc(locator)}")
-
-        # Handle media URLs differently
-        if is_media_url(url):
-            log.message(
-                "URL is a media URL, so adding as a resource and will cache media: %s", fmt_loc(url)
-            )
-            store_path = ws.import_item(url, as_type=ItemType.resource, reimport=refetch)
-            saved_paths.append(store_path)
-            media_tools.cache_media(url)
-        else:
-            # Cache the content first
-            expiration_sec = 0 if refetch else None
-            cache_result = cache_file(url, expiration_sec=expiration_sec)
-            original_filename = Path(parse_http_url(url).path).name
-            mime_type = cache_result.content.headers and cache_result.content.headers.mime_type
-
-            # Create a resource item
-            resource_item = Item.from_external_path(
-                cache_result.content.path,
-                ItemType.resource,
-                url=url,
-                mime_type=mime_type,
-                original_filename=original_filename,
-            )
-            # For initial content, do not format or add frontmatter.
-            store_path = ws.save(resource_item, no_frontmatter=True, no_format=True)
-            saved_paths.append(store_path)
-            select(store_path)
-
-            # Also create a doc version for text content if we want to normalize formatting.
-            if resource_item.format and can_normalize(resource_item.format) and not no_format:
-                doc_item = Item.from_external_path(
-                    cache_result.content.path,
-                    ItemType.doc,
-                    url=url,
-                    mime_type=mime_type,
-                    original_filename=original_filename,
-                )
-                # Now use default formatting and frontmatter.
-                doc_store_path = ws.save(doc_item)
-                saved_paths.append(doc_store_path)
-                select(doc_store_path)
-
-    print_status(
-        "Downloaded %s %s:\n%s",
-        len(saved_paths),
-        plural("item", len(saved_paths)),
-        fmt_lines(saved_paths),
-    )
-
-    return ShellResult(show_selection=True)
-
-
 @kash_command
 def history(max: int = 30, raw: bool = False) -> None:
     """
@@ -536,10 +454,14 @@ def save_clipboard(
 
 
 @kash_command
-def fetch_metadata(*files_or_urls: str, refetch: bool = False) -> ShellResult:
+def fetch_url(*files_or_urls: str, refetch: bool = False) -> ShellResult:
     """
-    Fetch metadata for the given URLs or resources. Imports new URLs and saves back
-    the fetched metadata for existing resources.
+    Fetch content and metadata for the given URLs or resources, saving to the
+    current workspace.
+
+    Imports new URLs and saves back the fetched metadata for existing resources.
+    Also saves a resource item with the content of the URL, either HTML, text, or
+    of any other type.
 
     Skips items that already have a title and description, unless `refetch` is true.
     Skips (with a warning) items that are not URL resources.
@@ -552,7 +474,7 @@ def fetch_metadata(*files_or_urls: str, refetch: bool = False) -> ShellResult:
     store_paths = []
     for locator in locators:
         try:
-            fetched_item = fetch_url_metadata(locator, refetch=refetch)
+            fetched_item = fetch_url_item(locator, refetch=refetch)
             store_paths.append(fetched_item.store_path)
         except InvalidInput as e:
             log.warning(

kash/config/colors.py

@@ -139,14 +139,15 @@ web_light_translucent = SimpleNamespace(
     bg_header=hsl_to_hex("hsla(188, 42%, 70%, 0.2)"),
     bg_alt=hsl_to_hex("hsla(39, 24%, 90%, 0.3)"),
     bg_alt_solid=hsl_to_hex("hsla(39, 24%, 97%, 1)"),
-    bg_selected=hsl_to_hex("hsla(188, 44%, 94%, 0.95)"),
+    bg_meta_solid=hsl_to_hex("hsla(39, 24%, 94%, 1)"),
+    bg_selected=hsl_to_hex("hsla(188, 21%, 94%, 0.9)"),
     text=hsl_to_hex("hsl(188, 39%, 11%)"),
     code=hsl_to_hex("hsl(44, 38%, 23%)"),
     border=hsl_to_hex("hsl(188, 8%, 50%)"),
     border_hint=hsl_to_hex("hsla(188, 8%, 72%, 0.3)"),
     border_accent=hsl_to_hex("hsla(305, 18%, 65%, 0.85)"),
     hover=hsl_to_hex("hsl(188, 12%, 84%)"),
-    hover_bg=hsl_to_hex("hsla(188, 44%, 94%, 1)"),
+    hover_bg=hsl_to_hex("hsla(188, 18%, 97%, 1)"),
     hint=hsl_to_hex("hsl(188, 11%, 65%)"),
     hint_strong=hsl_to_hex("hsl(188, 11%, 46%)"),
     hint_gentle=hsl_to_hex("hsla(188, 11%, 65%, 0.2)"),
@@ -165,14 +166,15 @@ web_light_translucent = SimpleNamespace(
 web_dark_translucent = SimpleNamespace(
     primary=hsl_to_hex("hsl(188, 40%, 62%)"),
     primary_light=hsl_to_hex("hsl(188, 50%, 72%)"),
-    secondary=hsl_to_hex("hsl(188, 12%, 65%)"),
-    tertiary=hsl_to_hex("hsl(188, 7%, 40%)"),
+    secondary=hsl_to_hex("hsl(188, 12%, 70%)"),
+    tertiary=hsl_to_hex("hsl(188, 7%, 45%)"),
     bg=hsl_to_hex("hsla(220, 14%, 7%, 0.95)"),
     bg_solid=hsl_to_hex("hsl(220, 14%, 7%)"),
     bg_header=hsl_to_hex("hsla(188, 42%, 20%, 0.3)"),
     bg_alt=hsl_to_hex("hsla(220, 14%, 12%, 0.5)"),
-    bg_alt_solid=hsl_to_hex("hsl(220, 14%, 12%)"),
-    bg_selected=hsl_to_hex("hsla(188, 12%, 50%, 0.95)"),
+    bg_alt_solid=hsl_to_hex("hsl(220, 15%, 16%)"),
+    bg_meta_solid=hsl_to_hex("hsl(220, 14%, 25%)"),
+    bg_selected=hsl_to_hex("hsla(188, 13%, 33%, 0.95)"),
     text=hsl_to_hex("hsl(188, 10%, 90%)"),
     code=hsl_to_hex("hsl(44, 38%, 72%)"),
     border=hsl_to_hex("hsl(188, 8%, 25%)"),

kash/config/text_styles.py

@@ -277,6 +277,8 @@ EMOJI_HELP = "?"
 
 EMOJI_ACTION = "⛭"
 
+EMOJI_TASK = "⚒"
+
 EMOJI_COMMAND = "⧁"  # More ideas: ⦿⧁⧀⦿⦾⟐⦊⟡
 
 EMOJI_SHELL = "⦊"

kash/docs/markdown/topics/a1_what_is_kash.md

@@ -34,7 +34,7 @@ the Python framework, a few core utilities, and the Kash command-line shell.
 Additional actions for handling more complex tasks like converting documents and
 transcribing, researching, or annotating videos, are in the
 [kash-docs](https://github.com/jlevy/kash-docs) and
-[kash-media](https://github.com/jlevy/kash-docs) packages, all available on PyPI and
+[kash-media](https://github.com/jlevy/kash-media) packages, all available on PyPI and
 quick to install via uv.
 
 ### Key Concepts

kash/docs/markdown/topics/b1_kash_overview.md

@@ -165,48 +165,37 @@ works on readable text such as Markdown.
 This catches errors and allows you to find actions that might apply to a given selected
 set of items using `suggest_actions`.
 
-### Programmatic Use
-
-Since commands and actions are really just Python functions.
-
-### Useful Features
-
-Kash makes a few kinds of messy text manipulations easier:
-
-- Reusable LLM actions: A common kind of action is to invoke an LLM (like GPT-4o or o1)
-  on a text item, with a given system and user prompt template.
-  New LLM actions can be added with a few lines of Python by subclassing an action base
-  class, typically `Action`, `CachedItemAction` (for any action that doesn't need to be
-  rerun if it has the same single output), `CachedLLMAction` (if it also is performing
-  an LLM-based transform), or `ChunkedLLMAction` (if it will be processing a document
-  broken into <div class="chunk"> elements).
-
-- Sliding window transformations: LLMs can have trouble processing large inputs, not
-  just because of context window and because they may make more mistakes when making
-  lots of changes at once.
-  Kash supports running actions in a sliding window across the document, then stitching
-  the results back together when done.
-
-- Checking and enforcing changes: LLMs do not reliably do what they are asked to do.
-  So a key part of making them useful is to save outputs at each step of the way and
-  have a way to review their outputs or provide guardrails on what they can do with
-  content.
-
-- Fine-grainded diffs with word tokens: Documents can be represented at the word level,
-  using “word tokens” to represent words and normalized whitespace (word, sentence, and
-  paragraph breaks, but not line breaks).
-  This allows diffs of similar documents regardless of formatting.
-  For example, it is possible to ask an LLM only to add paragraph breaks, then drop any
-  other changes it makes to other words.
-  You can use this intelligent matching of words to “backfill” specific content from one
-  doc into an edited document, such as pulling timestamps from a full transcript back
-  into an edited transcript or summary.
-
-- Paragraph and sentence operations: A lot of operations within actions should be done
-  in chunks at the paragraph or sentence level.
-  Kash offers simple tools to subdivide documents into paragraphs and sentences and
-  these can be used together with sliding windows to process large documents.
-
-In addition, there are built-in kash commands that are part of the kash tool itself.
-These allow you to list items in the workspace, see or change the current selection,
-archive items, view logs, etc.
+### Programmatic Usage
+
+Kash can be used entirely programmatically, so that actions are called just like
+functions from Python, but the additional functionality of the items model, saving files
+to a workspace, and so on, are all automatic.
+
+This means you can use Kash to build your own CLI apps much more quickly.
+
+For an example of this, see [textpress](https://github.com/jlevy/textpress), which wraps
+quite a few kash actions to allow clean publishing of docx or PDF files on
+[textpress.md](https://textpress.md/).
+
+### Utilities and Supporting Libraries
+
+Kash includes a number of utility libraries to help with common tasks, either in the
+base `kash-shell` package or or smaller dependencies:
+
+- See [frontmatter-format](https://github.com/jlevy/frontmatter-format) for the spec and
+  implementation we use of frontmatter YAML format.
+
+- See
+  [utils/file_utils](https://github.com/jlevy/kash/tree/main/src/kash/utils/file_utils)
+  for file format detection, conversion, filename handling, etc.
+
+- See [chopdiff](https://github.com/jlevy/chopdiff) for a simple text doc data model
+  that includes sentences and paragraphs and fairly advanced diffing, filtered diffing,
+  and windowed transformations of text via LLM calls.
+
+- See [clideps](https://github.com/jlevy/clideps) for utilities for helping with dot-env
+  files, API key setup, and dependency checks.
+
+- See [utils/common](https://github.com/jlevy/kash/tree/main/src/kash/utils/common) the
+  rest of [utils/](https://github.com/jlevy/kash/tree/main/src/kash/utils) for a variety
+  of other general utilities.

kash/exec/__init__.py

@@ -1,6 +1,7 @@
 from kash.exec.action_decorators import kash_action, kash_action_class
 from kash.exec.action_exec import SkipItem, prepare_action_input, run_action_with_shell_context
 from kash.exec.command_registry import kash_command
+from kash.exec.fetch_url_items import fetch_url_item, fetch_url_item_content
 from kash.exec.importing import import_and_register
 from kash.exec.llm_transforms import llm_transform_item, llm_transform_str
 from kash.exec.precondition_registry import kash_precondition
@@ -21,6 +22,8 @@ __all__ = [
     "prepare_action_input",
     "run_action_with_shell_context",
     "kash_command",
+    "fetch_url_item",
+    "fetch_url_item_content",
     "kash_runtime",
     "current_runtime_settings",
     "import_and_register",

kash/exec/action_decorators.py

@@ -105,7 +105,10 @@ def kash_action_class(cls: type[A]) -> type[A]:
 
 
 def _register_dynamic_action(
-    action_cls: type[A], action_name: str, action_description: str, source_path: Path | None
+    action_cls: type[A],
+    action_name: str,
+    action_description: str,
+    source_path: Path | None,
 ) -> type[A]:
     # Set class fields for name and description for convenience.
     action_cls.name = action_name
@@ -206,6 +209,7 @@ def kash_action(
     run_per_item: bool | None = None,
     uses_selection: bool = True,
     interactive_input: bool = False,
+    live_output: bool = False,
     mcp_tool: bool = False,
     title_template: TitleTemplate = TitleTemplate("{title}"),
     llm_options: LLMOptions = LLMOptions(),
@@ -235,13 +239,17 @@ def kash_action(
     def decorator(orig_func: AF) -> AF:
         if hasattr(orig_func, "__action_class__"):
             log.warning(
-                "Function `%s` is already decorated with `@kash_action`", orig_func.__name__
+                "Function `%s` is already decorated with `@kash_action`",
+                orig_func.__name__,
             )
             return orig_func
 
         # Inspect and sanity check the formal params.
         func_params = inspect_function_params(orig_func)
-        if len(func_params) == 0 or func_params[0].effective_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 "
@@ -311,6 +319,7 @@ def kash_action(
                 self.uses_selection = uses_selection
                 self.output_type = output_type
                 self.interactive_input = interactive_input
+                self.live_output = live_output
                 self.mcp_tool = mcp_tool
                 self.title_template = title_template
                 self.llm_options = llm_options
@@ -332,8 +341,14 @@ def kash_action(
                         kw_args[fp.name] = self.get_param(fp.name)
 
                 if self.params:
-                    log.info("Action function param declarations:\n%s", fmt_lines(self.params))
-                    log.info("Action function param values:\n%s", self.param_value_summary_str())
+                    log.info(
+                        "Action function param declarations:\n%s",
+                        fmt_lines(self.params),
+                    )
+                    log.info(
+                        "Action function param values:\n%s",
+                        self.param_value_summary_str(),
+                    )
                 else:
                     log.info("Action function has no declared params")
 

kash/exec/action_exec.py

@@ -43,7 +43,7 @@ def prepare_action_input(*input_args: CommandArg, refetch: bool = False) -> Acti
     URL or file resources, either finding them in the workspace or importing them.
     Also fetches metadata for URLs if they don't already have title and description.
     """
-    from kash.exec.fetch_url_metadata import fetch_url_item_metadata
+    from kash.exec.fetch_url_items import fetch_url_item_content
 
     ws = current_ws()
 
@@ -55,7 +55,7 @@ def prepare_action_input(*input_args: CommandArg, refetch: bool = False) -> Acti
     if input_items:
         log.message("Assembling metadata for input items:\n%s", fmt_lines(input_items))
         input_items = [
-            fetch_url_item_metadata(item, refetch=refetch) if is_url_resource(item) else item
+            fetch_url_item_content(item, refetch=refetch) if is_url_resource(item) else item
             for item in input_items
         ]
 

kash/exec/{fetch_url_metadata.py → fetch_url_items.py}

@@ -11,7 +11,9 @@ from kash.utils.errors import InvalidInput
 log = get_logger(__name__)
 
 
-def fetch_url_metadata(locator: Url | StorePath, refetch: bool = False) -> Item:
+def fetch_url_item(
+    locator: Url | StorePath, *, save_content: bool = True, refetch: bool = False
+) -> Item:
     from kash.workspaces import current_ws
 
     ws = current_ws()
@@ -26,16 +28,23 @@ def fetch_url_metadata(locator: Url | StorePath, refetch: bool = False) -> Item:
     else:
         raise InvalidInput(f"Not a URL or URL resource: {fmt_loc(locator)}")
 
-    return fetch_url_item_metadata(item, refetch=refetch)
+    return fetch_url_item_content(item, save_content=save_content, refetch=refetch)
 
 
-def fetch_url_item_metadata(item: Item, refetch: bool = False) -> Item:
+def fetch_url_item_content(item: Item, *, save_content: bool = True, refetch: bool = False) -> Item:
     """
-    Fetch metadata for a URL using a media service if we recognize the URL,
-    and otherwise fetching and extracting it from the web page HTML.
+    Fetch content and metadata for a URL using a media service if we
+    recognize the URL as a known media service. Otherwise, fetch and extract the
+    metadata and content from the web page and save it to the URL item.
+
+    If `save_content` is true, a copy of the content is also saved as
+    a resource item.
+
+    The content item is returned if content was saved. Otherwise, the updated
+    URL item is returned.
     """
     from kash.web_content.canon_url import canonicalize_url
-    from kash.web_content.web_extract import fetch_extract
+    from kash.web_content.web_extract import fetch_page_content
     from kash.workspaces import current_ws
 
     ws = current_ws()
@@ -54,28 +63,47 @@ def fetch_url_item_metadata(item: Item, refetch: bool = False) -> Item:
     # Prefer fetching metadata from media using the media service if possible.
     # Data is cleaner and YouTube for example often blocks regular scraping.
     media_metadata = get_media_metadata(url)
+    url_item: Item | None = None
+    content_item: Item | None = None
     if media_metadata:
-        fetched_item = Item.from_media_metadata(media_metadata)
+        url_item = Item.from_media_metadata(media_metadata)
         # Preserve and canonicalize any slice suffix on the URL.
         _base_url, slice = parse_url_slice(item.url)
         if slice:
             new_url = add_slice_to_url(media_metadata.url, slice)
             if new_url != item.url:
                 log.message("Updated URL from metadata and added slice: %s", new_url)
-            fetched_item.url = new_url
+            url_item.url = new_url
 
-        fetched_item = item.merged_copy(fetched_item)
+        url_item = item.merged_copy(url_item)
     else:
-        page_data = fetch_extract(url, refetch=refetch)
-        fetched_item = item.new_copy_with(
+        page_data = fetch_page_content(url, refetch=refetch, cache=save_content)
+        url_item = item.new_copy_with(
             title=page_data.title or item.title,
             description=page_data.description or item.description,
             thumbnail_url=page_data.thumbnail_url or item.thumbnail_url,
         )
+        if save_content:
+            assert page_data.saved_content
+            assert page_data.format_info
+            content_item = url_item.new_copy_with(
+                external_path=str(page_data.saved_content),
+                # Use the original filename, not the local cache filename (which has a hash suffix).
+                original_filename=item.get_filename(),
+                format=page_data.format_info.format,
+            )
+            ws.save(content_item)
 
-    if not fetched_item.title:
+    if not url_item.title:
         log.warning("Failed to fetch page data: title is missing: %s", item.url)
 
-    ws.save(fetched_item)
+    # Now save the updated URL item and also the content item if we have one.
+    ws.save(url_item)
+    assert url_item.store_path
+    log.debug("Saved URL item: %s", url_item.fmt_loc())
+    if content_item:
+        ws.save(content_item)
+        assert content_item.store_path
+        log.debug("Saved content item: %s", content_item.fmt_loc())
 
-    return fetched_item
+    return content_item or url_item

kash/exec/llm_transforms.py

@@ -68,7 +68,7 @@ def llm_transform_str(options: LLMOptions, input_str: str, check_no_results: boo
             diff_filter=options.diff_filter,
         ).reassemble()
     else:
-        log.message(
+        log.info(
             "Running simple LLM transform action %s with model %s",
             options.op_name,
             options.model.litellm_name,

kash/exec/shell_callable_action.py

@@ -56,7 +56,7 @@ class ShellCallableAction:
 
             log.info("Action shell args: %s", shell_args)
             explicit_values = RawParamValues(shell_args.options)
-            if not action.interactive_input:
+            if not action.interactive_input and not action.live_output:
                 with get_console().status(f"Running action {action.name}…", spinner=SPINNER):
                     result = run_action_with_shell_context(
                         action_cls,

kash/file_storage/file_store.py

@@ -405,6 +405,7 @@ class FileStore(Workspace):
         # If external path already exists and is within the workspace, the file was
         # already saved (e.g. by an action that wrote the item directly to the store).
         external_path = item.external_path and Path(item.external_path).resolve()
+        skipped_save = False
         if external_path and self._is_in_store(external_path):
             log.info("Item with external_path already saved: %s", fmt_loc(external_path))
             rel_path = external_path.relative_to(self.base_dir)
@@ -480,12 +481,17 @@ class FileStore(Workspace):
                     )
                     os.unlink(full_path)
                     store_path = old_store_path
+                    skipped_save = True
 
         # Update in-memory store_path only after successful save.
         item.store_path = str(store_path)
         self._id_index_item(store_path)
 
-        log.message("%s Saved item: %s", EMOJI_SAVED, fmt_loc(store_path))
+        if not skipped_save:
+            log.message("%s Saved item: %s", EMOJI_SAVED, fmt_loc(store_path))
+        else:
+            log.info("%s Already saved: %s", EMOJI_SAVED, fmt_loc(store_path))
+
         return store_path
 
     @log_calls(level="debug")

kash/file_storage/store_filenames.py

@@ -30,6 +30,10 @@ def folder_for_type(item_type: ItemType) -> Path:
 
 
 def join_suffix(base_slug: str, full_suffix: str) -> str:
+    """
+    Create a store filename by joining a base slug and a full suffix, i.e. a filename
+    extension with or without an item type (`.html` or `.resource.html`, for example).
+    """
     return f"{base_slug}.{full_suffix.lstrip('.')}"
 
 

kash/help/function_param_info.py

@@ -2,9 +2,9 @@ from collections.abc import Callable
 from dataclasses import replace
 from typing import Any
 
-from kash.help.docstring_utils import parse_docstring
 from kash.model.params_model import ALL_COMMON_PARAMS, Param
 from kash.utils.common.function_inspect import FuncParam, inspect_function_params
+from kash.utils.common.parse_docstring import parse_docstring
 
 
 def _look_up_param_docs(func: Callable[..., Any], kw_params: list[FuncParam]) -> list[Param]:

kash/help/help_pages.py

@@ -3,7 +3,6 @@ from rich.text import Text
 from kash.config.logger import get_logger
 from kash.config.text_styles import STYLE_HINT
 from kash.docs.all_docs import DocSelection, all_docs
-from kash.help.docstring_utils import parse_docstring
 from kash.shell.output.shell_formatting import format_name_and_value
 from kash.shell.output.shell_output import (
     PrintHooks,
@@ -12,6 +11,7 @@ from kash.shell.output.shell_output import (
     print_hrule,
     print_markdown,
 )
+from kash.utils.common.parse_docstring import parse_docstring
 
 log = get_logger(__name__)
 

kash/help/help_printing.py

@@ -6,7 +6,6 @@ from kash.docs.all_docs import DocSelection
 from kash.exec.action_registry import look_up_action_class
 from kash.exec.command_registry import CommandFunction, look_up_command
 from kash.help.assistant import assist_preamble, assistance_unstructured
-from kash.help.docstring_utils import parse_docstring
 from kash.help.function_param_info import annotate_param_info
 from kash.help.help_lookups import look_up_faq
 from kash.help.tldr_help import tldr_help
@@ -22,6 +21,7 @@ from kash.shell.output.shell_output import (
     print_help,
     print_markdown,
 )
+from kash.utils.common.parse_docstring import parse_docstring
 from kash.utils.errors import InvalidInput, NoMatch
 from kash.utils.file_formats.chat_format import ChatHistory, ChatMessage, ChatRole
 

kash/llm_utils/llm_completion.py

@@ -173,7 +173,7 @@ def llm_template_completion(
     )
 
     if check_no_results and is_no_results(result.content):
-        log.message("No results for LLM transform, will ignore: %r", result.content)
+        log.info("No results for LLM transform, will ignore: %r", result.content)
         result.content = ""
 
     return result

kash/model/actions_model.py

@@ -270,6 +270,12 @@ class Action(ABC):
     Does this action ask for input interactively?
     """
 
+    live_output: bool = False
+    """
+    Does this action have live output (e.g., progress bars, spinners)?
+    If True, the shell should not show its own status spinner.
+    """
+
     mcp_tool: bool = False
     """
     If True, this action is published as an MCP tool.