kash-shell 0.3.22__py3-none-any.whl → 0.3.24__py3-none-any.whl

kash/actions/core/combine_docs.py

@@ -0,0 +1,52 @@
+from chopdiff.html.html_in_md import div_wrapper
+
+from kash.config.logger import get_logger
+from kash.exec import kash_action
+from kash.model import ONE_OR_MORE_ARGS, ActionInput, ActionResult, Param
+from kash.utils.errors import InvalidInput
+
+log = get_logger(__name__)
+
+
+@kash_action(
+    expected_args=ONE_OR_MORE_ARGS,
+    params=(
+        Param(
+            "class_name",
+            "CSS class name to use for wrapping each document in a div.",
+            type=str,
+            default_value="doc",
+        ),
+    ),
+)
+def combine_docs(input: ActionInput, class_name: str = "page") -> ActionResult:
+    """
+    Combine multiple text items into a single document, wrapping each piece
+    in a div with the specified CSS class.
+    """
+    items = input.items
+
+    if not items:
+        raise InvalidInput("No items provided for combination")
+
+    # Create wrapper function
+    wrapper = div_wrapper(class_name=class_name)
+
+    # Collect and wrap all bodies
+    wrapped_bodies = []
+    for item in items:
+        if not item.body:
+            raise InvalidInput(f"Item has no body: {item.store_path}")
+        wrapped_bodies.append(wrapper(item.body))
+
+    # Concatenate with double newlines
+    combined_body = "\n\n".join(wrapped_bodies)
+
+    # Create title
+    count = len(items)
+    title = f"Combined ({count} doc{'s' if count != 1 else ''})"
+
+    # Create result item based on first item
+    result_item = items[0].derived_copy(body=combined_body, title=title, original_filename=None)
+
+    return ActionResult([result_item])

kash/actions/core/concat_docs.py

@@ -0,0 +1,47 @@
+from kash.config.logger import get_logger
+from kash.exec import kash_action
+from kash.model import ONE_OR_MORE_ARGS, ActionInput, ActionResult, Param
+from kash.utils.errors import InvalidInput
+
+log = get_logger(__name__)
+
+
+@kash_action(
+    expected_args=ONE_OR_MORE_ARGS,
+    params=(
+        Param(
+            "separator",
+            "String to use between concatenated items.",
+            type=str,
+            default_value="\n\n",
+        ),
+    ),
+)
+def concat_docs(input: ActionInput, separator: str = "\n\n") -> ActionResult:
+    """
+    Concatenate multiple text items into a single document with the specified
+    separator between each piece.
+    """
+    items = input.items
+
+    if not items:
+        raise InvalidInput("No items provided for concatenation")
+
+    # Collect all bodies
+    bodies = []
+    for item in items:
+        if not item.body:
+            raise InvalidInput(f"Item has no body: {item.store_path}")
+        bodies.append(item.body)
+
+    # Concatenate with the specified separator
+    concat_body = separator.join(bodies)
+
+    # Create title
+    count = len(items)
+    title = f"Concat ({count} doc{'s' if count != 1 else ''})"
+
+    # Create result item based on first item
+    result_item = items[0].derived_copy(body=concat_body, title=title, original_filename=None)
+
+    return ActionResult([result_item])

kash/commands/workspace/workspace_commands.py

@@ -474,8 +474,8 @@ def fetch_url(*files_or_urls: str, refetch: bool = False) -> ShellResult:
     store_paths = []
     for locator in locators:
         try:
-            fetched_item = fetch_url_item(locator, refetch=refetch)
-            store_paths.append(fetched_item.store_path)
+            fetch_result = fetch_url_item(locator, refetch=refetch)
+            store_paths.append(fetch_result.item.store_path)
         except InvalidInput as e:
             log.warning(
                 "Not a URL or URL resource, will not fetch metadata: %s: %s", fmt_loc(locator), e

kash/config/logger.py

@@ -254,9 +254,10 @@ def _do_logging_setup(log_settings: LogSettings):
         _console_handler = basic_stderr_handler(log_settings.log_console_level)
 
     # Manually adjust logging for a few packages, removing previous verbose default handlers.
-
+    # Set root logger to most permissive level so handlers can do the filtering
+    root_level = min(log_settings.log_console_level.value, log_settings.log_file_level.value)
     log_levels = {
-        None: INFO,
+        None: root_level,
         "LiteLLM": INFO,
         "LiteLLM Router": INFO,
         "LiteLLM Proxy": INFO,

kash/config/settings.py

@@ -210,6 +210,12 @@ class Settings:
     use_nerd_icons: bool
     """If true, use Nerd Icons in file listings. Requires a compatible font."""
 
+    limit_rps: float
+    """Default rate limit for API calls."""
+
+    limit_concurrency: int
+    """Default concurrency limit for API calls."""
+
 
 ws_root_dir = Path("~/Kash").expanduser()
 
@@ -276,6 +282,8 @@ def _read_settings():
         mcp_server_port=DEFAULT_MCP_SERVER_PORT,
         use_kerm_codes=False,
         use_nerd_icons=True,
+        limit_rps=5.0,
+        limit_concurrency=10,
     )
 
 

kash/docs/markdown/topics/a2_installation.md

@@ -124,7 +124,7 @@ These are for `kash-media` but you can use a `kash-shell` for a more basic setup
 
 You can use kash from your MCP client (such as Anthropic Desktop or Cursor).
 
-You do this by running the the `kash_mcp` binary to make kash actions available as MCP
+You do this by running the the `kash-mcp` binary to make kash actions available as MCP
 tools.
 
 For Claude Desktop, my config looks like this:
@@ -133,7 +133,7 @@ For Claude Desktop, my config looks like this:
 {
   "mcpServers": {
     "kash": {
-      "command": "/Users/levy/.local/bin/kash_mcp",
+      "command": "/Users/levy/.local/bin/kash-mcp",
       "args": ["--proxy"]
     }
   }

kash/embeddings/embeddings.py

@@ -70,7 +70,7 @@ class Embeddings:
         init_litellm()
 
         data = {}
-        log.message(
+        log.info(
             "Embedding %d texts (model %s, batch size %s)…",
             len(keyvals),
             model.litellm_name,

kash/exec/action_exec.py

@@ -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_content(item, refetch=refetch) if is_url_resource(item) else item
+            fetch_url_item_content(item, refetch=refetch).item if is_url_resource(item) else item
             for item in input_items
         ]
 

kash/exec/fetch_url_items.py

@@ -1,19 +1,42 @@
+from dataclasses import dataclass
+
 from kash.config.logger import get_logger
 from kash.exec.preconditions import is_url_resource
-from kash.media_base.media_services import get_media_metadata
 from kash.model.items_model import Item, ItemType
 from kash.model.paths_model import StorePath
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.common.url import Url, is_url
 from kash.utils.common.url_slice import add_slice_to_url, parse_url_slice
 from kash.utils.errors import InvalidInput
+from kash.web_content.web_page_model import WebPageData
 
 log = get_logger(__name__)
 
 
+@dataclass(frozen=True)
+class FetchItemResult:
+    """
+    Result of fetching a URL item.
+    """
+
+    item: Item
+
+    was_cached: bool
+    """Whether this item was already present in cache (or if we skipped the fetch
+    because we already had the data)."""
+
+    page_data: WebPageData | None = None
+    """If the item was fetched from a URL via the web content cache,
+    this will hold additional metadata whether it was cached."""
+
+
 def fetch_url_item(
-    locator: Url | StorePath, *, save_content: bool = True, refetch: bool = False
-) -> Item:
+    locator: Url | StorePath,
+    *,
+    save_content: bool = True,
+    refetch: bool = False,
+    cache: bool = True,
+) -> FetchItemResult:
     from kash.workspaces import current_ws
 
     ws = current_ws()
@@ -28,44 +51,51 @@ def fetch_url_item(
     else:
         raise InvalidInput(f"Not a URL or URL resource: {fmt_loc(locator)}")
 
-    return fetch_url_item_content(item, save_content=save_content, refetch=refetch)
+    return fetch_url_item_content(item, save_content=save_content, refetch=refetch, cache=cache)
 
 
-def fetch_url_item_content(item: Item, *, save_content: bool = True, refetch: bool = False) -> Item:
+def fetch_url_item_content(
+    item: Item, *, save_content: bool = True, refetch: bool = False, cache: bool = True
+) -> FetchItemResult:
     """
     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.
+    If `save_content` is true, a copy of the content is also saved to the workspace
+    as a resource item.
+
+    If `cache` is true, the content is also cached in the local file cache.
 
     The content item is returned if content was saved. Otherwise, the updated
     URL item is returned.
     """
+    from kash.media_base.media_services import get_media_metadata
     from kash.web_content.canon_url import canonicalize_url
     from kash.web_content.web_extract import fetch_page_content
     from kash.workspaces import current_ws
 
     ws = current_ws()
     if not refetch and item.title and item.description and item.body:
-        log.message(
+        log.info(
             "Already have title, description, and body, will not fetch: %s",
             item.fmt_loc(),
         )
-        return item
+        return FetchItemResult(item, was_cached=True)
 
     if not item.url:
         raise InvalidInput(f"No URL for item: {item.fmt_loc()}")
 
     url = canonicalize_url(item.url)
-    log.message("No metadata for URL, will fetch: %s", url)
+    log.info("No metadata for URL, will fetch: %s", url)
 
     # 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
+    page_data: WebPageData | None = None
+
     if media_metadata:
         url_item = Item.from_media_metadata(media_metadata)
         # Preserve and canonicalize any slice suffix on the URL.
@@ -73,12 +103,12 @@ def fetch_url_item_content(item: Item, *, save_content: bool = True, refetch: bo
         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)
+                log.info("Updated URL from metadata and added slice: %s", new_url)
             url_item.url = new_url
 
         url_item = item.merged_copy(url_item)
     else:
-        page_data = fetch_page_content(url, refetch=refetch, cache=save_content)
+        page_data = fetch_page_content(url, refetch=refetch, cache=cache)
         url_item = item.new_copy_with(
             title=page_data.title or item.title,
             description=page_data.description or item.description,
@@ -93,7 +123,6 @@ def fetch_url_item_content(item: Item, *, save_content: bool = True, refetch: bo
                 original_filename=item.get_filename(),
                 format=page_data.format_info.format,
             )
-            ws.save(content_item)
 
     if not url_item.title:
         log.warning("Failed to fetch page data: title is missing: %s", item.url)
@@ -104,8 +133,15 @@ def fetch_url_item_content(item: Item, *, save_content: bool = True, refetch: bo
     if content_item:
         ws.save(content_item)
         assert content_item.store_path
-        log.info("Saved content item: %s", content_item.fmt_loc())
+        log.info(
+            "Saved both URL and content item: %s, %s",
+            url_item.fmt_loc(),
+            content_item.fmt_loc(),
+        )
     else:
-        log.info("Saved URL item: %s", url_item.fmt_loc())
+        log.info("Saved URL item (no content): %s", url_item.fmt_loc())
 
-    return content_item or url_item
+    was_cached = bool(
+        not page_data or (page_data.cache_result and page_data.cache_result.was_cached)
+    )
+    return FetchItemResult(content_item or url_item, was_cached=was_cached, page_data=page_data)

kash/file_storage/file_store.py

@@ -289,7 +289,7 @@ class FileStore(Workspace):
                 if self.exists(default_path):
                     old_item = self.load(default_path)
                     if old_item.item_id() == item_id:
-                        log.message(
+                        log.info(
                             "Item with the same id already saved (disk check):\n%s",
                             fmt_lines([fmt_loc(default_path), item_id]),
                         )
@@ -297,7 +297,7 @@ class FileStore(Workspace):
                         self.id_map[item_id] = default_path
                         return default_path
             if store_path and self.exists(store_path):
-                log.message(
+                log.info(
                     "Item with the same id already saved (disk check):\n%s",
                     fmt_lines([fmt_loc(store_path), item_id]),
                 )
@@ -536,7 +536,7 @@ class FileStore(Workspace):
             item = Item(item_type, url=url, format=Format.url)
             previous_store_path = self.find_by_id(item)
             if previous_store_path and not reimport:
-                log.message(
+                log.info(
                     "Workspace already has this URL:\n%s",
                     fmt_lines([fmt_loc(previous_store_path), url]),
                 )

kash/llm_utils/llm_completion.py

@@ -107,7 +107,7 @@ def llm_completion(
 
     total_input_len = sum(len(m["content"]) for m in messages)
     speed = len(content) / elapsed
-    log.message(
+    log.info(
         f"{EMOJI_TIMING} LLM completion from {model.litellm_name} in {format_duration(elapsed)}: "
         f"input {total_input_len} chars in {len(messages)} messages, output {len(content)} chars "
         f"({speed:.0f} char/s)"

kash/mcp/mcp_cli.py

@@ -114,10 +114,10 @@ def main():
     args = build_parser().parse_args()
 
     if args.list_tools or args.tool_help:
-        kash_setup(rich_logging=True, level=LogLevel.warning)
+        kash_setup(rich_logging=True, log_level=LogLevel.warning)
         show_tool_info(args.tool_help)
     else:
-        kash_setup(rich_logging=False, level=LogLevel.info)
+        kash_setup(rich_logging=False, log_level=LogLevel.info)
         run_server(args)