kash-shell 0.3.33__tar.gz → 0.3.34__tar.gz

{kash_shell-0.3.33 → kash_shell-0.3.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kash-shell
-Version: 0.3.33
+Version: 0.3.34
 Summary: The knowledge agent shell (core)
 Project-URL: Repository, https://github.com/jlevy/kash-shell
 Author-email: Joshua Levy <joshua@cal.berkeley.edu>
@@ -20,7 +20,7 @@ Requires-Dist: aiolimiter>=1.2.1
 Requires-Dist: anyio>=4.8.0
 Requires-Dist: audioop-lts>=0.2.1; python_version >= '3.13'
 Requires-Dist: cachetools>=5.5.2
-Requires-Dist: chopdiff>=0.2.5
+Requires-Dist: chopdiff>=0.2.6
 Requires-Dist: clideps>=0.1.4
 Requires-Dist: colour>=0.1.5
 Requires-Dist: cssselect>=1.2.0
@@ -41,7 +41,7 @@ Requires-Dist: litellm>=1.74.15.post1
 Requires-Dist: markdownify>=0.13.1
 Requires-Dist: mcp-proxy>=0.5.0
 Requires-Dist: mcp>=1.6.0
-Requires-Dist: openai>=1.66.3
+Requires-Dist: openai==1.99.9
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: patch-ng>=1.18.1
 Requires-Dist: pathspec>=0.12.1

{kash_shell-0.3.33 → kash_shell-0.3.34}/pyproject.toml

@@ -48,7 +48,7 @@ dependencies = [
     "flowmark>=0.5.3",
     "frontmatter-format>=0.2.3",
     "sidematter-format>=0.0.5",
-    "chopdiff>=0.2.5",
+    "chopdiff>=0.2.6",
     "clideps>=0.1.4",
     "tminify>=0.1.6",
     # Shell and file essentials:
@@ -84,7 +84,7 @@ dependencies = [
     "curl-cffi>=0.11.4",
     # LLM and API essentials:
     "tiktoken>=0.9.0",
-    "openai>=1.66.3",
+    "openai==1.99.9",  # FIXME: Pinning for now due to import errors (ImportError: cannot import name 'ResponseTextConfig' from 'openai.types.responses.response')   
     "litellm>=1.74.15.post1",
     "pyrate-limiter>=3.7.0",
     "aiolimiter>=1.2.1",
@@ -130,6 +130,7 @@ kash-mcp = "kash.mcp.mcp_cli:main"
 
 [tool.uv.sources]
 # For local development:
+# flowmark = { path = "../flowmark", editable = true }
 # clideps = { path = "../clideps", editable = true }
 # tminify = { path = "../tminify", editable = true }
 # chopdiff = { path = "../chopdiff", editable = true }

{kash_shell-0.3.33 → kash_shell-0.3.34}/src/kash/actions/core/markdownify_html.py

@@ -13,9 +13,7 @@ from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
 log = get_logger(__name__)
 
 
-@kash_action(
-    precondition=is_url_resource | has_html_body, output_format=Format.markdown, mcp_tool=True
-)
+@kash_action(precondition=is_url_resource | has_html_body, output_format=Format.markdown)
 def markdownify_html(item: Item) -> Item:
     """
     Converts raw HTML or the URL of an HTML page to Markdown, fetching with the content

{kash_shell-0.3.33 → kash_shell-0.3.34}/src/kash/actions/core/summarize_as_bullets.py

@@ -47,7 +47,7 @@ llm_options = LLMOptions(
 )
 
 
-@kash_action(llm_options=llm_options, params=common_params("model"), mcp_tool=True)
+@kash_action(llm_options=llm_options, params=common_params("model"))
 def summarize_as_bullets(item: Item, model: LLMName = LLM.default_standard) -> Item:
     """
     Summarize text as bullet points.

{kash_shell-0.3.33 → kash_shell-0.3.34}/src/kash/model/actions_model.py

@@ -585,9 +585,9 @@ class Action(ABC):
                 "type": "array",
                 "items": {
                     "type": "string",
-                    "description": "A path to a local file or a URL",
+                    "description": "A URL or S3 URL or a workspace file path, e.g. https://example.com/some/file/path or s3://somebucket/some/file/path or some/file/path",
                 },
-                "description": f"Input items ({self.expected_args.as_str()})",
+                "description": f"A list of paths or URLs of input items ({self.expected_args.as_str()}). Use an array of length one for a single input.",
             }
 
             # Set min/max items.

{kash_shell-0.3.33 → kash_shell-0.3.34}/src/kash/model/items_model.py

@@ -7,6 +7,7 @@ from datetime import UTC, datetime
 from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, NotRequired, TypedDict, TypeVar, Unpack
+from urllib.parse import urlparse
 
 from frontmatter_format import from_yaml_string, new_yaml
 from prettyfmt import (
@@ -570,12 +571,19 @@ class Item:
         from kash.file_storage.store_filenames import parse_item_filename
 
         # Prefer original to external, e.g. if we know the original but the external might
-        # be a cache filename.
-        path = self.store_path or self.original_filename or self.external_path
+        # be a cache filename. Also check
+        path = (
+            self.store_path
+            or self.original_filename
+            or self.external_path
+            or (self.url and urlparse(self.url).path)
+            or ""
+        ).strip()
         if path:
             path_name, _item_type, _format, _file_ext = parse_item_filename(Path(path).name)
         else:
             path_name = None
+
         return path_name
 
     def slug_name(
@@ -607,6 +615,7 @@ class Item:
 
         slug = self.slug_name()
         full_suffix = self.get_full_suffix()
+
         return join_suffix(slug, full_suffix)
 
     def body_heading(self, allowed_tags: tuple[str, ...] = ("h1", "h2")) -> str | None:

kash_shell-0.3.34/src/kash/utils/api_utils/multitask_gather.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar, cast
+
+from strif import abbrev_list
+
+from kash.config.logger import get_logger
+from kash.config.settings import global_settings
+from kash.shell.output.shell_output import multitask_status
+from kash.utils.api_utils.api_retries import RetrySettings
+from kash.utils.api_utils.gather_limited import FuncTask, Limit, gather_limited_sync
+
+T = TypeVar("T")
+
+log = get_logger(name=__name__)
+
+
+@dataclass(frozen=True)
+class MultitaskResult(Generic[T]):
+    """
+    Container for results from multitask_gather preserving original order.
+    Access `.successes` and `.errors` to get partitioned views.
+    """
+
+    raw_results: list[T | BaseException]
+
+    @property
+    def successes_or_none(self) -> list[T | None]:
+        """
+        Return a list of successes or None, aligned with the original order.
+        """
+        return [
+            None if isinstance(item, BaseException) else cast(T, item) for item in self.raw_results
+        ]
+
+    @property
+    def successes(self) -> list[T]:
+        """
+        Return a list of successes only. May be shorter than the original list.
+        """
+        return [cast(T, item) for item in self.raw_results if not isinstance(item, BaseException)]
+
+    @property
+    def errors(self) -> list[BaseException]:
+        """
+        Return a list of errors only. May be shorter than the original list.
+        """
+        return [item for item in self.raw_results if isinstance(item, BaseException)]
+
+
+def _default_labeler(total: int) -> Callable[[int, Any], str]:
+    def labeler(i: int, _spec: Any) -> str:
+        return f"Task {i + 1}/{total}"
+
+    return labeler
+
+
+async def multitask_gather(
+    tasks: Iterable[FuncTask[T]] | Sequence[FuncTask[T]],
+    *,
+    labeler: Callable[[int, Any], str] | None = None,
+    limit: Limit | None = None,
+    bucket_limits: dict[str, Limit] | None = None,
+    retry_settings: RetrySettings | None = None,
+    show_progress: bool = True,
+) -> MultitaskResult[T]:
+    """
+    Run many `FuncTask`s concurrently with shared progress UI and rate limits.
+
+    This wraps the standard pattern of creating a status context, providing a labeler,
+    and calling `gather_limited_sync` with common options.
+
+    - `labeler` can be omitted; a simple "Task X/Y" label will be used.
+    - If `limit` is not provided, defaults are taken from `global_settings()`.
+    - If `show_progress` is False, tasks are run without the status context.
+    - Exceptions are collected (using return_exceptions=True). Use properties on the
+      returned `MultitaskResult` to access `.successes` and `.errors`.
+    """
+
+    # Normalize tasks to a list for length and stable iteration
+    task_list: list[FuncTask[T]] = list(tasks)
+
+    # Provide a default labeler if none is supplied
+    effective_labeler: Callable[[int, Any], str] = (
+        labeler if labeler is not None else _default_labeler(len(task_list))
+    )
+
+    # Provide sensible default rate limits if none are supplied
+    effective_limit: Limit = (
+        limit
+        if limit is not None
+        else Limit(
+            rps=global_settings().limit_rps,
+            concurrency=global_settings().limit_concurrency,
+        )
+    )
+
+    if not show_progress:
+        log.warning("Running %d tasks (progress disabled)…", len(task_list))
+
+    async with multitask_status(enabled=show_progress) as status:
+        raw_results = cast(
+            list[T | BaseException],
+            await gather_limited_sync(
+                *task_list,
+                limit=effective_limit,
+                bucket_limits=bucket_limits,
+                status=status,
+                labeler=effective_labeler,
+                retry_settings=retry_settings,
+                return_exceptions=True,
+            ),
+        )
+
+    result = MultitaskResult[T](raw_results=raw_results)
+
+    if result.errors:
+        log.warning(
+            "multitask_gather: had %d errors (out of %d tasks): %s",
+            len(result.errors),
+            len(task_list),
+            abbrev_list(result.errors),
+        )
+        log.error(
+            "multitask_gather: first error (full traceback):",
+            exc_info=(
+                type(result.errors[0]),
+                result.errors[0],
+                result.errors[0].__traceback__,
+            ),
+        )
+    return result

{kash_shell-0.3.33 → kash_shell-0.3.34}/src/kash/utils/rich_custom/multitask_status.py

@@ -72,6 +72,8 @@ RUNNING_SYMBOL = ""
 DEFAULT_LABEL_WIDTH = 40
 DEFAULT_PROGRESS_WIDTH = 20
 
+MAX_DISPLAY_TASKS = 20
+
 
 # Calculate spinner width to maintain column alignment
 def _get_spinner_width(spinner_name: str) -> int:
@@ -101,6 +103,9 @@ class StatusSettings:
     transient: bool = True
     refresh_per_second: float = 10
     styles: StatusStyles = DEFAULT_STYLES
+    # Maximum number of tasks to keep visible in the live display.
+    # Older completed/skipped/failed tasks beyond this cap will be removed from the live view.
+    max_display_tasks: int = MAX_DISPLAY_TASKS
 
 
 class SpinnerStatusColumn(ProgressColumn):
@@ -298,6 +303,10 @@ class MultiTaskStatus(AbstractAsyncContextManager):
         self._task_info: dict[int, TaskInfo] = {}
         self._next_id: int = 1
         self._rich_task_ids: dict[int, TaskID] = {}  # Map our IDs to Rich Progress IDs
+        # Track order of tasks added to the Progress so we can prune oldest completed ones
+        self._displayed_task_order: list[int] = []
+        # Track tasks pruned from the live display so we don't re-add them later
+        self._pruned_task_ids: set[int] = set()
 
         # Unified live integration
         self._unified_live: Any | None = None  # Reference to the global unified live
@@ -442,6 +451,10 @@ class MultiTaskStatus(AbstractAsyncContextManager):
                 progress_display=None,
             )
             self._rich_task_ids[task_id] = rich_task_id
+            self._displayed_task_order.append(task_id)
+
+            # Prune if too many tasks are visible (prefer removing completed ones)
+            self._prune_completed_tasks_if_needed()
 
     async def set_progress_display(self, task_id: int, display: RenderableType) -> None:
         """
@@ -536,18 +549,31 @@ class MultiTaskStatus(AbstractAsyncContextManager):
 
             # Complete the progress bar and stop spinner
             if rich_task_id is not None:
-                total = self._progress.tasks[rich_task_id].total or 1
+                # Safely find the Task by id; Progress.tasks is a list, not a dict
+                task_obj = next((t for t in self._progress.tasks if t.id == rich_task_id), None)
+                if task_obj is not None and task_obj.total is not None:
+                    total = task_obj.total
+                else:
+                    total = task_info.steps_total or 1
                 self._progress.update(rich_task_id, completed=total, task_info=task_info)
             else:
-                # Task was never started, but we still need to add it to show completion
-                rich_task_id = self._progress.add_task(
-                    "",
-                    total=task_info.steps_total,
-                    label=task_info.label,
-                    completed=task_info.steps_total,
-                    task_info=task_info,
-                )
-                self._rich_task_ids[task_id] = rich_task_id
+                # If this task was pruned from the live display, skip re-adding it
+                if task_id in self._pruned_task_ids:
+                    pass
+                else:
+                    # Task was never started; add a completed row so it appears once
+                    rich_task_id = self._progress.add_task(
+                        "",
+                        total=task_info.steps_total,
+                        label=task_info.label,
+                        completed=task_info.steps_total,
+                        task_info=task_info,
+                    )
+                    self._rich_task_ids[task_id] = rich_task_id
+                    self._displayed_task_order.append(task_id)
+
+            # After finishing, prune completed tasks to respect max visible cap
+            self._prune_completed_tasks_if_needed()
 
     def get_task_info(self, task_id: int) -> TaskInfo | None:
         """Get additional task information."""
@@ -567,6 +593,54 @@ class MultiTaskStatus(AbstractAsyncContextManager):
         """Get console instance for additional output above progress."""
         return self._progress.console
 
+    def _prune_completed_tasks_if_needed(self) -> None:
+        """
+        Ensure at most `max_display_tasks` tasks are visible by removing the oldest
+        completed/skipped/failed tasks first. Running or waiting tasks are never
+        removed by this method.
+        Note: This method assumes it's called under self._lock.
+        """
+        max_visible = self.settings.max_display_tasks
+
+        # Nothing to prune or unlimited
+        if max_visible <= 0:
+            return
+
+        # Count visible tasks (those with a Rich task id present)
+        visible_task_ids = [tid for tid in self._displayed_task_order if tid in self._rich_task_ids]
+        excess = len(visible_task_ids) - max_visible
+        if excess <= 0:
+            return
+
+        # Build list of terminal tasks that can be pruned (oldest first)
+        terminal_tasks = []
+        for tid in self._displayed_task_order:
+            if tid not in self._rich_task_ids:
+                continue
+            info = self._task_info.get(tid)
+            if info and info.state in (
+                TaskState.COMPLETED,
+                TaskState.FAILED,
+                TaskState.SKIPPED,
+            ):
+                terminal_tasks.append(tid)
+
+        # Remove the oldest terminal tasks up to the excess count
+        tasks_to_remove = terminal_tasks[:excess]
+
+        for tid in tasks_to_remove:
+            rich_tid = self._rich_task_ids.pop(tid, None)
+            if rich_tid is not None:
+                # Remove from Rich progress display
+                self._progress.remove_task(rich_tid)
+            # Mark as pruned so we don't re-add on finish
+            self._pruned_task_ids.add(tid)
+
+        # Efficiently rebuild the displayed task order without the removed tasks
+        self._displayed_task_order = [
+            tid for tid in self._displayed_task_order if tid not in tasks_to_remove
+        ]
+
 
 ## Tests
 

{kash_shell-0.3.33 → kash_shell-0.3.34}/src/kash/utils/text_handling/markdown_footnotes.py

@@ -1,48 +1,19 @@
 from __future__ import annotations
 
-import re
 from dataclasses import dataclass, field
 from typing import Any
 
-from flowmark import flowmark_markdown, line_wrap_by_sentence
 from marko import Markdown
+from marko.block import Document
 from marko.ext import footnote
 
-from kash.utils.text_handling.markdown_utils import comprehensive_transform_tree
-
-
-def _normalize_footnotes_in_markdown(content: str) -> str:
-    """
-    Ensure blank lines between consecutive footnote definitions.
-
-    Marko has a bug where consecutive footnotes without blank lines are parsed
-    as a single footnote. This adds blank lines where needed.
-    """
-    lines = content.split("\n")
-    result = []
-    i = 0
-
-    while i < len(lines):
-        line = lines[i]
-        result.append(line)
-
-        # Check if this is a footnote definition
-        if re.match(r"^\[\^[^\]]+\]:", line):
-            # Look ahead to see if the next non-empty line is also a footnote
-            j = i + 1
-            while j < len(lines) and not lines[j].strip():
-                result.append(lines[j])
-                j += 1
-
-            if j < len(lines) and re.match(r"^\[\^[^\]]+\]:", lines[j]):
-                # Next non-empty line is also a footnote, add blank line
-                result.append("")
-
-            i = j
-        else:
-            i += 1
-
-    return "\n".join(result)
+from kash.utils.text_handling.markdown_utils import (
+    MARKDOWN as DEFAULT_MARKDOWN,
+)
+from kash.utils.text_handling.markdown_utils import (
+    comprehensive_transform_tree,
+    normalize_footnotes_in_markdown,
+)
 
 
 @dataclass
@@ -81,15 +52,17 @@ class MarkdownFootnotes:
             MarkdownFootnotes instance with all footnotes indexed by ID
         """
         if markdown_parser is None:
-            markdown_parser = flowmark_markdown(line_wrap_by_sentence(is_markdown=True))
+            markdown_parser = DEFAULT_MARKDOWN
 
         # Normalize to work around marko bug with consecutive footnotes
-        normalized_content = _normalize_footnotes_in_markdown(content)
+        normalized_content = normalize_footnotes_in_markdown(content)
         document = markdown_parser.parse(normalized_content)
         return MarkdownFootnotes.from_document(document, markdown_parser)
 
     @staticmethod
-    def from_document(document: Any, markdown_parser: Markdown | None = None) -> MarkdownFootnotes:
+    def from_document(
+        document: Document, markdown_parser: Markdown | None = None
+    ) -> MarkdownFootnotes:
         """
         Extract all footnotes from a parsed markdown document.
 
@@ -102,7 +75,7 @@ class MarkdownFootnotes:
             MarkdownFootnotes instance with all footnotes indexed by ID
         """
         if markdown_parser is None:
-            markdown_parser = flowmark_markdown(line_wrap_by_sentence(is_markdown=True))
+            markdown_parser = DEFAULT_MARKDOWN
 
         footnotes_dict: dict[str, FootnoteInfo] = {}
 
@@ -206,9 +179,9 @@ def extract_footnote_references(content: str, markdown_parser: Markdown | None =
         List of unique footnote IDs that are referenced (with the ^)
     """
     if markdown_parser is None:
-        markdown_parser = flowmark_markdown(line_wrap_by_sentence(is_markdown=True))
+        markdown_parser = DEFAULT_MARKDOWN
 
-    normalized_content = _normalize_footnotes_in_markdown(content)
+    normalized_content = normalize_footnotes_in_markdown(content)
     document = markdown_parser.parse(normalized_content)
     references: list[str] = []
     seen: set[str] = set()