kash-shell 0.3.28__py3-none-any.whl → 0.3.30__py3-none-any.whl

kash/model/items_model.py

@@ -17,7 +17,7 @@ from prettyfmt import (
     slugify_snake,
 )
 from pydantic.dataclasses import dataclass
-from strif import abbrev_str, format_iso_timestamp
+from strif import abbrev_str, format_iso_timestamp, single_line
 
 from kash.config.logger import get_logger
 from kash.model.concept_model import canonicalize_concept
@@ -34,7 +34,9 @@ from kash.utils.text_handling.markdown_render import markdown_to_html
 from kash.utils.text_handling.markdown_utils import first_heading
 
 if TYPE_CHECKING:
-    from kash.model.exec_model import ExecContext
+    from sidematter_format import ResolvedSidematter
+
+    from kash.model.exec_model import ActionContext
     from kash.workspaces import Workspace
 
 log = get_logger(__name__)
@@ -68,7 +70,15 @@ class ItemType(Enum):
         """
         Resources don't have a body. On concepts it's optional.
         """
-        return self.value not in [ItemType.resource.value, ItemType.concept.value]
+        return self.value not in (ItemType.resource.value, ItemType.concept.value)
+
+    @property
+    def allows_op_suffix(self) -> bool:
+        """
+        Whether it makes sense to have an operation suffix for this item type
+        (docs often should, but concepts or resources can have cleaner naming conventions).
+        """
+        return self not in (ItemType.concept, ItemType.resource, ItemType.export)
 
     @staticmethod
     def for_format(format: Format) -> ItemType:
@@ -100,6 +110,7 @@ class ItemType(Enum):
             Format.mp3: ItemType.resource,
             Format.m4a: ItemType.resource,
             Format.mp4: ItemType.resource,
+            Format.zip: ItemType.resource,
         }
         return format_to_item_type.get(format, ItemType.resource)
 
@@ -267,7 +278,7 @@ class Item:
 
     # Optional execution context. Useful for letting functions that take only an Item
     # arg get access to context.
-    context: ExecContext | None = field(default=None, metadata={"exclude": True})
+    context: ActionContext | None = field(default=None, metadata={"exclude": True})
 
     # These fields we don't want in YAML frontmatter.
     # We don't include store_path as it's redundant with the filename.
@@ -369,9 +380,9 @@ class Item:
         item_type: ItemType | None = None,
         *,
         title: str | None = None,
-        original_filename: str | None = None,
         url: Url | None = None,
         mime_type: MimeType | None = None,
+        preserve_filename: bool = True,
     ) -> Item:
         """
         Create a resource Item for a file with a format inferred from the file extension
@@ -400,9 +411,10 @@ class Item:
         if not file_ext:
             file_ext = format_info.suggested_file_ext
 
+        original_filename = Path(path).name if preserve_filename else None
         item = cls(
             type=item_type,
-            title=title,
+            title=single_line(title) if title else None,  # Avoid multiline titles.
             file_ext=file_ext,
             format=format,
             external_path=str(path),
@@ -428,7 +440,7 @@ class Item:
         return cls(
             type=ItemType.resource,
             format=Format.url,
-            title=media_metadata.title,
+            title=single_line(media_metadata.title),  # Avoid multiline titles.
             url=media_metadata.url,
             description=media_metadata.description,
             thumbnail_url=media_metadata.thumbnail_url,
@@ -453,7 +465,7 @@ class Item:
         if self.type.expects_body and self.format.has_body and not self.body:
             raise ValueError(f"Item type `{self.type.value}` is text but has no body: {self}")
 
-    def absolute_path(self, ws: Workspace | None = None) -> Path:
+    def absolute_path(self, ws: Path | Workspace | None = None) -> Path:
         """
         Get the absolute path to the item. Throws `ValueError` if the item has no
         store path. If no workspace is provided, uses the current workspace.
@@ -462,8 +474,11 @@ class Item:
 
         if not self.store_path:
             raise ValueError("Item has no store path")
-        if not ws:
+        elif isinstance(ws, Path):
+            return ws / self.store_path
+        elif not ws:
             ws = current_ws()
+
         return ws.base_dir / self.store_path
 
     @property
@@ -485,7 +500,7 @@ class Item:
             raise ValueError("Cannot get doc id for an item that has not been saved")
         return str(self.store_path)
 
-    def metadata(self, datetime_as_str: bool = False) -> dict[str, Any]:
+    def metadata(self, *, datetime_as_str: bool = False) -> dict[str, Any]:
         """
         Metadata is all relevant non-None fields in easy-to-serialize form.
         Optional fields are omitted unless they are set.
@@ -529,6 +544,15 @@ class Item:
 
         return item_dict
 
+    def sidematter(self, ws: Path | Workspace | None = None) -> ResolvedSidematter:
+        """
+        Get the sidematter for this item, if present, by looking at the files
+        in the specified workspace (or the current workspace if not specified).
+        """
+        from sidematter_format import Sidematter
+
+        return Sidematter(self.absolute_path(ws)).resolve()
+
     def filename_stem(self) -> str | None:
         """
         If the item has an existing or previous filename, return its stem,
@@ -545,16 +569,25 @@ class Item:
             path_name = None
         return path_name
 
-    def slug_name(self, max_len: int = SLUG_MAX_LEN, prefer_title: bool = False) -> str:
+    def slug_name(
+        self,
+        max_len: int = SLUG_MAX_LEN,
+        prefer_title: bool = False,
+        add_ops_suffix: bool = True,
+    ) -> str:
         """
         Get a readable slugified name for this item, either from a previous filename
-        or from slugifying the title or content. May not be unique.
+        or from slugifying the title or content. Adds the last operation suffix if requested
+        and available in item history.
         """
-        filename_stem = self.filename_stem()
-        if filename_stem and not prefer_title:
-            return slugify_snake(filename_stem)
+        base_title = self.filename_stem()
+        if prefer_title or not base_title:
+            base_title = self.pick_title(max_len=max_len, add_ops_suffix=add_ops_suffix)
         else:
-            return slugify_snake(self.pick_title(max_len=max_len, add_ops_suffix=True))
+            base_title = self.pick_title(
+                base_title=base_title, max_len=max_len, add_ops_suffix=add_ops_suffix
+            )
+        return slugify_snake(base_title)
 
     def default_filename(self) -> str:
         """
@@ -578,6 +611,7 @@ class Item:
 
     def pick_title(
         self,
+        base_title: str | None = None,
         *,
         max_len: int = 100,
         add_ops_suffix: bool = False,
@@ -590,35 +624,31 @@ class Item:
         """
         # First special case: if we are pulling the title from the body header, check
         # that.
-        if not self.title and pull_body_heading:
-            heading = self.body_heading()
-            if heading:
-                return heading
-
-        # Next special case: URLs with no title use the url itself.
-        if not self.title and self.url:
-            return abbrev_str(self.url, max_len)
-
-        filename_stem = self.filename_stem()
-
-        # Use the title or the path if possible, falling back to description or even body text.
-        title_raw_text = (
-            self.title
-            or filename_stem
-            or self.description
-            or (not self.is_binary and self.abbrev_body(max_len))
-            or UNTITLED
-        )
+        if not base_title:
+            if not base_title and pull_body_heading:
+                heading = self.body_heading()
+                base_title = heading
+
+            # Next special case: URLs with no title use the url itself.
+            if not self.title and self.url:
+                return abbrev_str(self.url, max_len)
+
+            filename_stem = self.filename_stem()
+
+            # Use the title or the path if possible, falling back to description or even body text.
+            base_title = (
+                self.title
+                or filename_stem
+                or self.description
+                or (not self.is_binary and self.abbrev_body(max_len))
+                or UNTITLED
+            )
 
-        suffix = ""
         # For docs, etc but not for concepts/resources/exports, add a parenthical note
         # indicating the last operation, if there was one. This makes filename slugs
         # more readable.
-        if add_ops_suffix and self.type not in [
-            ItemType.concept,
-            ItemType.resource,
-            ItemType.export,
-        ]:
+        suffix = ""
+        if add_ops_suffix and self.type.allows_op_suffix:
             last_op = self.history and self.history[-1].action_name
             if last_op:
                 step_num = len(self.history) + 1 if self.history else 1
@@ -626,7 +656,7 @@ class Item:
 
         shorter_len = min(max_len, max(max_len - len(suffix), 20))
         clean_text = sanitize_title(
-            abbrev_phrase_in_middle(html_to_plaintext(title_raw_text), shorter_len)
+            abbrev_phrase_in_middle(html_to_plaintext(base_title), shorter_len)
         )
 
         final_text = clean_text
@@ -670,8 +700,6 @@ class Item:
         """
         If it is a data Item, return the parsed YAML.
         """
-        if not self.type == ItemType.data:
-            raise FileFormatError(f"Item is not a data item: {self}")
         if not self.body:
             raise FileFormatError(f"Data item has no body: {self}")
         if self.format != Format.yaml:
@@ -795,15 +823,22 @@ class Item:
         merged_fields = self._copy_and_update(other, update_timestamp=False)
         return Item(**merged_fields)
 
-    def derived_copy(self, **updates: Unpack[ItemUpdateOptions]) -> Item:
+    def derived_copy(
+        self,
+        action_context: ActionContext | None = None,
+        output_num: int = 0,
+        **updates: Unpack[ItemUpdateOptions],
+    ) -> Item:
         """
         Copy item with the given field updates. Resets `store_path` and `source` to None
         since those should be set explicitly later. Preserves other fields, including
-        the body.
+        the type and the body.
 
         Same as `new_copy_with` but also updates the `derived_from` relation. If we also
         have an action context, then use the `title_template` to derive a new title.
         """
+
+        # Get derived_from relation if possible.
         if not self.store_path:
             if self.relations.derived_from:
                 log.message(
@@ -830,30 +865,40 @@ class Item:
             assert updates["format"] is not None
             updates["file_ext"] = updates["format"].file_ext
 
-        # External resource paths only make sense for resources, so clear them out if new item
-        # is not a resource.
-        new_type = updates.get("type") or self.type
-        if "external_path" not in updates and new_type != ItemType.resource:
+        # External resource paths should not be preserved.
+        if "external_path" not in updates:
             updates["external_path"] = None
 
         new_item = self.new_copy_with(update_timestamp=True, **updates)
         if derived_from:
             new_item.update_relations(derived_from=derived_from)
 
+        action_context = action_context or self.context
+
+        # Record the history.
+        if action_context:
+            self.source = Source(
+                operation=action_context.operation,
+                output_num=output_num,
+                cacheable=action_context.action.cacheable,
+            )
+            self.add_to_history(self.source.operation.summary())
+            action = action_context.action
+        else:
+            action = None
+
         # Fall back to action title template if we have it and title wasn't explicitly set.
         if "title" not in updates:
             prev_title = self.title or (Path(self.store_path).stem if self.store_path else UNTITLED)
-            if self.context:
-                action = self.context.action
-                new_item.title = action.title_template.format(
-                    title=prev_title, action_name=action.name
-                )
+
+            if action:
+                new_item.title = action.format_title(prev_title)
             else:
-                log.warning(
+                log.info(
                     "Deriving an item without action context so keeping previous title: %s",
                     self,
                 )
-                new_item.title = f"{prev_title} (derived copy)"
+                new_item.title = prev_title
 
         return new_item
 
@@ -906,6 +951,17 @@ class Item:
         if not self.history or self.history[-1] != operation_summary:
             self.history.append(operation_summary)
 
+    def mark_as_saved(self, external_path: Path) -> None:
+        """
+        Mark the item as saved at an external or internal path. If this item is saved to a
+        workspace and the path is inside the workspace, the save will be short-circuited.
+        If it's outside the workspace, the item will be copied to the workspace.
+        Having this method makes it quick to catch bugs where the file is missing.
+        """
+        if not external_path.exists():
+            raise FileNotFoundError(f"Provided path not found: {fmt_loc(external_path)}")
+        self.external_path = str(external_path)
+
     def fmt_loc(self) -> str:
         """
         Formatted store path, external path, URL, or title. Use for logging etc.
@@ -949,6 +1005,7 @@ class Item:
                 key_filter={
                     "store_path": 0,
                     "external_path": 64,
+                    "original_filename": 64,
                     "type": 64,
                     "format": 64,
                     "state": 64,

kash/model/params_model.py

@@ -206,10 +206,10 @@ A list of parameter declarations, possibly with default values.
 
 # These are the default models for typical use cases.
 # The user may override them with parameters.
-DEFAULT_CAREFUL_LLM = LLM.o3
-DEFAULT_STRUCTURED_LLM = LLM.gpt_4o
-DEFAULT_STANDARD_LLM = LLM.claude_4_sonnet
-DEFAULT_FAST_LLM = LLM.gpt_4o
+DEFAULT_CAREFUL_LLM = LLM.gpt_5
+DEFAULT_STRUCTURED_LLM = LLM.gpt_5
+DEFAULT_STANDARD_LLM = LLM.gpt_5
+DEFAULT_FAST_LLM = LLM.gpt_5_mini
 
 
 # Parameters set globally such as in the workspace.

kash/shell/output/shell_output.py

@@ -10,7 +10,6 @@ from enum import Enum, auto
 import rich
 import rich.style
 from flowmark import Wrap, fill_text
-from flowmark.text_filling import DEFAULT_INDENT
 from rich.console import Group, OverflowMethod, RenderableType
 from rich.rule import Rule
 from rich.style import Style
@@ -50,7 +49,7 @@ def print_style(pad_style: PadStyle):
     Context manager for print styles.
     """
     if pad_style == PadStyle.INDENT:
-        token = print_context_var.set(DEFAULT_INDENT)
+        token = print_context_var.set("    ")
         try:
             yield
         finally:

kash/utils/file_formats/chat_format.py

@@ -93,7 +93,6 @@ content: |
 
 from __future__ import annotations
 
-import json
 from dataclasses import field
 from enum import Enum
 from io import StringIO
@@ -104,6 +103,7 @@ from typing import Any
 from frontmatter_format import from_yaml_string, new_yaml, to_yaml_string
 from prettyfmt import abbrev_obj, custom_key_sort, fmt_size_human
 from pydantic.dataclasses import dataclass
+from sidematter_format import to_json_string
 
 
 class ChatRole(str, Enum):
@@ -161,9 +161,12 @@ class ChatMessage:
         Convert to a format that can be used as a standard chat completion, with
         the content field holding JSON-serialized data if it is structured.
         """
+
         return {
             "role": self.role.value,
-            "content": json.dumps(self.content) if isinstance(self.content, dict) else self.content,
+            "content": to_json_string(self.content)
+            if isinstance(self.content, dict)
+            else self.content,
         }
 
     @classmethod
@@ -174,7 +177,7 @@ class ChatMessage:
         return to_yaml_string(self.as_dict(), key_sort=_custom_key_sort)
 
     def to_json(self) -> str:
-        return json.dumps(self.as_dict())
+        return to_json_string(self.as_dict())
 
     def as_str(self) -> str:
         return self.to_yaml()
@@ -222,7 +225,7 @@ class ChatHistory:
         return stream.getvalue()
 
     def to_json(self) -> str:
-        return json.dumps([message.as_dict() for message in self.messages])
+        return to_json_string([message.as_dict() for message in self.messages], indent=None)
 
     def size_summary(self) -> str:
         role_counts = {}

kash/utils/file_utils/file_ext.py

@@ -37,6 +37,7 @@ class FileExt(Enum):
     mp4 = "mp4"
     pptx = "pptx"
     epub = "epub"
+    zip = "zip"
 
     @property
     def dot_ext(self) -> str:

kash/utils/file_utils/file_formats.py

@@ -16,7 +16,7 @@ def is_fullpage_html(content: str) -> bool:
     A full HTML document that is a full page (headers, footers, etc.) and
     so probably best rendered in a browser.
     """
-    return bool(re.search(r"<!DOCTYPE html>|<html>|<body>|<head>", content, re.IGNORECASE))
+    return bool(re.search(r"<!DOCTYPE html>|<html.*?>|<body>|<head>", content, re.IGNORECASE))
 
 
 _yaml_header_pattern = re.compile(r"^---\n\w+:", re.MULTILINE)
@@ -35,7 +35,9 @@ def is_html(content: str) -> bool:
     """
     return bool(
         re.search(
-            r"<!DOCTYPE html>|<html>|<body>|<head>|<div>|<p>|<img |<a href", content, re.IGNORECASE
+            r"<!DOCTYPE html>|<html.*?>|<body>|<head>|<div>|<p>|<img |<a href",
+            content,
+            re.IGNORECASE,
         )
     )
 

kash/utils/file_utils/file_formats_model.py

@@ -72,6 +72,9 @@ class Format(Enum):
     mp3 = "mp3"
     m4a = "m4a"
     mp4 = "mp4"
+
+    # Binary formats.
+    zip = "zip"
     binary = "binary"
     """Catch-all format for binary files that are unrecognized."""
 
@@ -167,6 +170,10 @@ class Format(Enum):
     def is_data(self) -> bool:
         return self in [self.csv, self.xlsx, self.npz]
 
+    @property
+    def is_zip(self) -> bool:
+        return self in [self.zip]
+
     @property
     def is_binary(self) -> bool:
         return self.has_body and not self.is_text
@@ -257,6 +264,7 @@ class Format(Enum):
             FileExt.m4a.value: Format.m4a,
             FileExt.mp4.value: Format.mp4,
             FileExt.epub.value: Format.epub,
+            FileExt.zip.value: Format.zip,
         }
         return ext_to_format.get(file_ext.value, None)
 
@@ -292,6 +300,7 @@ class Format(Enum):
             Format.mp3: FileExt.mp3,
             Format.m4a: FileExt.m4a,
             Format.mp4: FileExt.mp4,
+            Format.zip: FileExt.zip,
         }
 
         return format_to_file_ext.get(self, None)
@@ -329,6 +338,9 @@ class Format(Enum):
             "audio/mp3": Format.mp3,
             "audio/mp4": Format.m4a,
             "video/mp4": Format.mp4,
+            "application/zip": Format.zip,
+            "application/x-zip": Format.zip,
+            "application/x-zip-compressed": Format.zip,
             "application/octet-stream": Format.binary,
         }
 

kash/utils/text_handling/doc_normalization.py

@@ -75,7 +75,7 @@ def normalize_text_file(
 
 def test_osc8_link():
     from clideps.terminal.osc_utils import osc8_link
-    from flowmark.text_wrapping import wrap_paragraph
+    from flowmark import wrap_paragraph
 
     link = osc8_link("https://example.com/" + "x" * 50, "Example")
     assert ansi_cell_len(link) == 7