kash-shell 0.3.15__tar.gz → 0.3.16__tar.gz

{kash_shell-0.3.15 → kash_shell-0.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kash-shell
-Version: 0.3.15
+Version: 0.3.16
 Summary: The knowledge agent shell (core)
 Project-URL: Repository, https://github.com/jlevy/kash-shell
 Author-email: Joshua Levy <joshua@cal.berkeley.edu>

{kash_shell-0.3.15 → kash_shell-0.3.16}/src/kash/actions/core/render_as_html.py

@@ -27,7 +27,9 @@ def render_as_html(input: ActionInput, no_title: bool = False) -> ActionResult:
     """
     if len(input.items) == 1:
         input_item = input.items[0]
-        html_body = simple_webpage_render(input_item, add_title_h1=not no_title)
+        html_body = simple_webpage_render(
+            input_item, add_title_h1=not no_title, show_theme_toggle=True
+        )
         result_item = input_item.derived_copy(
             type=ItemType.export, format=Format.html, body=html_body
         )

{kash_shell-0.3.15 → kash_shell-0.3.16}/src/kash/actions/core/tabbed_webpage_generate.py

@@ -17,7 +17,9 @@ def tabbed_webpage_generate(input: ActionInput, add_title: bool = False) -> Acti
     Generate a tabbed web page from a config item for the tabbed template.
     """
     config_item = input.items[0]
-    html = tabbed_webpage.tabbed_webpage_generate(config_item, add_title_h1=add_title)
+    html = tabbed_webpage.tabbed_webpage_generate(
+        config_item, add_title_h1=add_title, show_theme_toggle=True
+    )
 
     webpage_item = Item(
         title=config_item.title,

{kash_shell-0.3.15 → kash_shell-0.3.16}/src/kash/config/colors.py

@@ -148,12 +148,40 @@ web_light_translucent = SimpleNamespace(
     tooltip_bg=hsl_to_hex("hsla(188, 6%, 37%, 0.7)"),
     popover_bg=hsl_to_hex("hsla(188, 6%, 37%, 0.7)"),
     bright=hsl_to_hex("hsl(134, 43%, 60%)"),
+    success=hsl_to_hex("hsl(134, 43%, 60%)"),
     selection="hsla(225, 61%, 82%, 0.80)",
     scrollbar=hsl_to_hex("hsla(189, 12%, 55%, 0.9)"),
     scrollbar_hover=hsl_to_hex("hsla(190, 12%, 38%, 0.9)"),
 )
 
 
+# Web dark colors
+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%)"),
+    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%)"),
+    text=hsl_to_hex("hsl(188, 20%, 90%)"),
+    border=hsl_to_hex("hsl(188, 8%, 25%)"),
+    border_hint=hsl_to_hex("hsla(188, 8%, 35%, 0.7)"),
+    border_accent=hsl_to_hex("hsla(305, 30%, 55%, 0.85)"),
+    hover=hsl_to_hex("hsl(188, 12%, 35%)"),
+    hover_bg=hsl_to_hex("hsla(188, 20%, 25%, 0.4)"),
+    hint=hsl_to_hex("hsl(188, 11%, 55%)"),
+    tooltip_bg=hsl_to_hex("hsla(188, 6%, 20%, 0.9)"),
+    popover_bg=hsl_to_hex("hsla(188, 6%, 20%, 0.9)"),
+    bright=hsl_to_hex("hsl(134, 43%, 60%)"),
+    success=hsl_to_hex("hsl(134, 43%, 60%)"),
+    selection=hsl_to_hex("hsla(225, 61%, 40%, 0.40)"),
+    scrollbar=hsl_to_hex("hsla(189, 12%, 35%, 0.9)"),
+    scrollbar_hover=hsl_to_hex("hsla(190, 12%, 50%, 0.9)"),
+)
+
+
 rich_terminal_dark = TerminalTheme(
     hex_to_int(terminal_dark.background),
     hex_to_int(terminal_dark.foreground),
@@ -211,9 +239,6 @@ rich_terminal_light = TerminalTheme(
 # We default to light colors for Rich content in HTML.
 rich_terminal = rich_terminal_light
 
-# Only support light web colors for now.
-web = web_light_translucent
-
 # Logical colors
 logical = SimpleNamespace(
     concept_dark=terminal.green_dark,
@@ -234,18 +259,23 @@ logical = SimpleNamespace(
 )
 
 
-def consolidate_color_vars(overrides: dict[str, str] | None = None) -> dict[str, str]:
+def consolidate_color_vars(
+    overrides: dict[str, str] | None = None, web_colors: SimpleNamespace | None = None
+) -> dict[str, str]:
     """
     Consolidate all color variables into a single dictionary with appropriate prefixes.
     Terminal variables have no prefix, while web and logical variables have "color-" prefix.
     """
     if overrides is None:
         overrides = {}
+    if web_colors is None:
+        web_colors = web_light_translucent
+
     return {
         # Terminal variables (no prefix)
         **terminal.__dict__,
         # Web and logical variables with "color-" prefix
-        **{f"color-{k}": v for k, v in web.__dict__.items()},
+        **{f"color-{k}": v for k, v in web_colors.__dict__.items()},
         **{f"color-{k}": v for k, v in logical.__dict__.items()},
         # Overrides take precedence (assume they already have correct prefixes)
         **overrides,
@@ -262,19 +292,63 @@ def normalize_var_names(variables: dict[str, str]) -> dict[str, str]:
 
 def generate_css_vars(overrides: dict[str, str] | None = None) -> str:
     """
-    Generate CSS variables for the terminal and web colors.
+    Generate CSS variables for terminal and both light and dark themes.
     """
     if overrides is None:
         overrides = {}
-    normalized_vars = normalize_var_names(consolidate_color_vars(overrides))
 
-    # Generate the CSS.
-    css_variables = ":root {\n"
-    for name, value in normalized_vars.items():
-        css_variables += f"  --{name}: {value};\n"
-    css_variables += "}"
+    # Get base variables (terminal colors stay the same)
+    base_vars = normalize_var_names({k: v for k, v in terminal.__dict__.items()})
+
+    # Get light theme color variables
+    light_color_vars = normalize_var_names(
+        {f"color-{k}": v for k, v in web_light_translucent.__dict__.items()}
+    )
+    light_color_vars.update(
+        normalize_var_names({f"color-{k}": v for k, v in logical.__dict__.items()})
+    )
+
+    # Get dark theme color variables
+    dark_color_vars = normalize_var_names(
+        {f"color-{k}": v for k, v in web_dark_translucent.__dict__.items()}
+    )
+    dark_color_vars.update(
+        normalize_var_names({f"color-{k}": v for k, v in logical.__dict__.items()})
+    )
 
-    return css_variables
+    # Apply overrides
+    if overrides:
+        normalized_overrides = normalize_var_names(overrides)
+        light_color_vars.update(normalized_overrides)
+        dark_color_vars.update(normalized_overrides)
+
+    # Generate CSS
+    css_parts = []
+
+    # Root with all variables (defaults to light)
+    css_parts.append(":root {")
+    css_parts.extend(f"  --{k}: {v};" for k, v in base_vars.items())
+    css_parts.extend(f"  --{k}: {v};" for k, v in light_color_vars.items())
+    css_parts.append("}\n")
+
+    # Light theme (only color- variables)
+    css_parts.append('[data-theme="light"] {')
+    css_parts.extend(f"  --{k}: {v};" for k, v in light_color_vars.items())
+    css_parts.append("}\n")
+
+    # Dark theme (only color- variables)
+    css_parts.append('[data-theme="dark"] {')
+    css_parts.extend(f"  --{k}: {v};" for k, v in dark_color_vars.items())
+    css_parts.append("}\n")
+
+    # Print media
+    css_parts.append("@media print {")
+    css_parts.append('  :root, [data-theme="dark"] {')
+    css_parts.extend(f"    --{k}: {v} !important;" for k, v in light_color_vars.items())
+    css_parts.append("  }")
+    css_parts.append("}")
+
+    return "\n".join(css_parts)
 
 
 if __name__ == "__main__":

{kash_shell-0.3.15 → kash_shell-0.3.16}/src/kash/file_storage/file_store.py

@@ -16,7 +16,11 @@ from kash.config.logger import get_log_settings, get_logger
 from kash.config.text_styles import EMOJI_SAVED
 from kash.file_storage.item_file_format import read_item, write_item
 from kash.file_storage.metadata_dirs import MetadataDirs
-from kash.file_storage.store_filenames import folder_for_type, join_suffix, parse_item_filename
+from kash.file_storage.store_filenames import (
+    folder_for_type,
+    join_suffix,
+    parse_item_filename,
+)
 from kash.model.items_model import Item, ItemId, ItemType
 from kash.model.paths_model import StorePath
 from kash.shell.output.shell_output import PrintHooks
@@ -39,7 +43,9 @@ T = TypeVar("T")
 P = ParamSpec("P")
 
 
-def synchronized(method: Callable[Concatenate[SelfT, P], T]) -> Callable[Concatenate[SelfT, P], T]:
+def synchronized(
+    method: Callable[Concatenate[SelfT, P], T],
+) -> Callable[Concatenate[SelfT, P], T]:
     """
     Simple way to synchronize a few methods.
     """
@@ -142,7 +148,10 @@ class FileStore(Workspace):
         """
         name, item_type, _format, file_ext = parse_item_filename(store_path)
         if not file_ext:
-            log.debug("Skipping file with unrecognized name or extension: %s", fmt_path(store_path))
+            log.debug(
+                "Skipping file with unrecognized name or extension: %s",
+                fmt_path(store_path),
+            )
             return None
 
         full_suffix = join_suffix(item_type.name, file_ext.name) if item_type else file_ext.name
@@ -158,11 +167,17 @@ class FileStore(Workspace):
                 if old_path and old_path != store_path:
                     dup_path = old_path
                     log.info(
-                        "Duplicate items (%s):\n%s", item_id, fmt_lines([old_path, store_path])
+                        "Duplicate items (%s):\n%s",
+                        item_id,
+                        fmt_lines([old_path, store_path]),
                     )
                 self.id_map[item_id] = store_path
-        except SkippableError as e:
-            log.warning("Could not read file, skipping: %s: %s", fmt_path(store_path), e)
+        except (ValueError, SkippableError) as e:
+            log.warning(
+                "Could not load file, skipping from store index: %s: %s",
+                fmt_path(store_path),
+                e,
+            )
 
         return dup_path
 
@@ -219,13 +234,17 @@ class FileStore(Workspace):
     @synchronized
     def _pick_filename_for(self, item: Item, *, overwrite: bool = False) -> tuple[str, str | None]:
         """
-        Get a suitable filename for this item.
-        If `overwrite` is true, use the the slugified title.
-        If it is false, use the slugified title with a suffix to make it unique
-        and in this case returns the old filename for this item, if it is different.
+        Get a suitable filename for this item. If `overwrite` is true, use the the slugified
+        title, regardless of whether it is already in the store.
+        If `overwrite` is false, use the slugified title with a suffix to make it unique
+        (and in this case also return the old filename for this item).
         """
         if overwrite:
-            log.info("Picked default filename: %s for item: %s", item.default_filename(), item)
+            log.info(
+                "Picked default filename: %s for item: %s",
+                item.default_filename(),
+                item,
+            )
             return item.default_filename(), None
 
         slug = item.slug_name()
@@ -283,14 +302,13 @@ class FileStore(Workspace):
     @synchronized
     def store_path_for(
         self, item: Item, *, as_tmp: bool = False, overwrite: bool = False
-    ) -> tuple[StorePath, bool, StorePath | None]:
+    ) -> tuple[StorePath, StorePath | None]:
         """
         Return the store path for an item. If the item already has a `store_path`, we use that.
         Otherwise we need to find the store path or generate a new one that seems suitable.
 
-        Returns `store_path, found, old_store_path` where `found` indicates whether the path was
-        already found (in the item or in the store by checking for identity) and `old_store_path`
-        is the previous similarly named item with a different identity (or None there is none).
+        Returns `store_path, old_store_path` where `old_store_path` is the previous similarly
+        named item with a different identity (or None there is none).
 
         If `as_tmp` is true, will return a path from the temporary directory in the store.
         Normally an item is always saved to a unique store path but if `overwrite` is true,
@@ -299,17 +317,17 @@ class FileStore(Workspace):
         item_id = item.item_id()
         old_filename = None
         if as_tmp:
-            return self._tmp_path_for(item), False, None
+            return self._tmp_path_for(item), None
         elif item.store_path:
-            return StorePath(item.store_path), True, None
+            return StorePath(item.store_path), None
         elif item_id in self.id_map and self.exists(self.id_map[item_id]):
             # If this item has an identity and we've saved under that id before, use the same store path.
             store_path = self.id_map[item_id]
             log.info(
-                "Found existing item with same id:\n%s",
+                "When picking a store path, found an existing item with same id:\n%s",
                 fmt_lines([fmt_loc(store_path), item_id]),
             )
-            return store_path, True, None
+            return store_path, None
         else:
             # We need to pick the path and filename.
             folder_path = folder_for_type(item.type)
@@ -320,14 +338,14 @@ class FileStore(Workspace):
             if old_filename and Path(self.base_dir / folder_path / old_filename).exists():
                 old_store_path = StorePath(folder_path / old_filename)
 
-            return StorePath(store_path), False, old_store_path
+            return StorePath(store_path), old_store_path
 
     def _tmp_path_for(self, item: Item) -> StorePath:
         """
         Find a path for an item in the tmp directory.
         """
         if not item.store_path:
-            store_path, _found, _old = self.store_path_for(item, as_tmp=False)
+            store_path, _old = self.store_path_for(item, as_tmp=False)
             return StorePath(self.dirs.tmp_dir / store_path)
         elif (self.base_dir / item.store_path).is_relative_to(self.dirs.tmp_dir):
             return StorePath(item.store_path)
@@ -346,14 +364,14 @@ class FileStore(Workspace):
         item: Item,
         *,
         overwrite: bool = False,
-        skip_dup_names: bool = False,
         as_tmp: bool = False,
         no_format: bool = False,
         no_frontmatter: bool = False,
     ) -> StorePath:
         """
         Save the item. Uses the `store_path` if it's already set or generates a new one.
-        Updates `item.store_path`.
+        Updates `item.store_path`. An existing file can be added by having the item's
+        `external_path` set to a location (inside or outside the store).
 
         Unless `no_format` is true, also normalizes body text formatting (for Markdown)
         and updates the item's body to match.
@@ -363,65 +381,62 @@ class FileStore(Workspace):
         If `overwrite` is true, will overwrite a file that has the same path.
 
         If `as_tmp` is true, will save the item to a temporary file.
-
-        If `skip_dup_names` is true, will skip saving if an item if an item with a
-        matching path (based on its title) already exists.
         """
-        if overwrite and skip_dup_names:
-            raise ValueError("Cannot both overwrite and skip duplicate names.")
         if overwrite and as_tmp:
             raise ValueError("Cannot both overwrite and save to a temporary file.")
 
-        # If external file already exists within the workspace, the file is already saved (without metadata).
+        # 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()
         if external_path and self._is_in_store(external_path):
-            log.message("External file already saved: %s", fmt_loc(external_path))
+            log.info("Item with external_path already saved: %s", fmt_loc(external_path))
             rel_path = external_path.relative_to(self.base_dir)
-            # Indicate this is really an item with a store path, not an external path.
+            # Indicate this is an item with a store path, not an external path.
+            # Keep external_path set so we know body is in that file.
             item.store_path = str(rel_path)
-            item.external_path = None
             return StorePath(rel_path)
         else:
             # Otherwise it's still in memory or in a file outside the workspace and we need to save it.
-            store_path, found, old_store_path = self.store_path_for(
+            store_path, old_store_path = self.store_path_for(
                 item, as_tmp=as_tmp, overwrite=overwrite
             )
 
-            if skip_dup_names and found:
-                log.message(
-                    "Skipping save because an item of the same name already exists: %s",
-                    fmt_loc(store_path),
-                )
-                item.store_path = str(store_path)
-                return store_path
-
             full_path = self.base_dir / store_path
 
-            log.info("Saving item to %s: %s", fmt_loc(full_path), item)
+            supports_frontmatter = item.format and item.format.supports_frontmatter
+            log.info(
+                "Saving item in format %s (supports_frontmatter=%s) to %s: %s",
+                item.format,
+                supports_frontmatter,
+                fmt_loc(full_path),
+                item,
+            )
 
-            # If we're overwriting an existing file, archive it first.
+            # If we're overwriting an existing file, archive it first so it is in the archive, not lost.
             if full_path.exists():
                 try:
+                    log.info(
+                        "Previous file exists so will archive it: %s",
+                        fmt_loc(store_path),
+                    )
                     self.archive(store_path, quiet=True)
                 except Exception as e:
                     log.info("Exception archiving existing file: %s", e)
 
             # Now save the new item.
             try:
-                supports_frontmatter = item.format and item.format.supports_frontmatter
-                # For binary or unknown formats or if we're not adding frontmatter, copy the file exactly.
+                # For binary or unknown formats or if we're not adding frontmatter, copy the file.
                 if item.external_path and (no_frontmatter or not supports_frontmatter):
+                    log.info(
+                        "Path is an external path, so copying: %s -> %s",
+                        fmt_path(item.external_path),
+                        fmt_path(full_path),
+                    )
                     copyfile_atomic(item.external_path, full_path, make_parents=True)
                 else:
                     # Save as a text item with frontmatter.
                     if item.external_path:
                         item.body = Path(item.external_path).read_text()
-                    if overwrite and full_path.exists():
-                        log.info(
-                            "Overwrite is enabled and a previous file exists so will archive it: %s",
-                            fmt_loc(store_path),
-                        )
-                        self.archive(store_path, quiet=True)
                     write_item(item, full_path, normalize=not no_format)
             except OSError as e:
                 log.error("Error saving item: %s", e)
@@ -545,7 +560,7 @@ class FileStore(Workspace):
             else:
                 # Binary or other files we just copy over as-is, preserving the name.
                 # We know the extension is recognized.
-                store_path, _found, old_store_path = self.store_path_for(item)
+                store_path, old_store_path = self.store_path_for(item)
                 if self.exists(store_path):
                     raise FileExists(f"Resource already in store: {fmt_loc(store_path)}")
 
@@ -690,7 +705,10 @@ class FileStore(Workspace):
         for warning in self.warnings:
             log.warning("%s", warning)
 
-        log.info("File store startup took %s.", format_duration(self.end_time - self.start_time))
+        log.info(
+            "File store startup took %s.",
+            format_duration(self.end_time - self.start_time),
+        )
         # TODO: Log more info like number of items by type.
         return True
 

{kash_shell-0.3.15 → kash_shell-0.3.16}/src/kash/file_storage/item_file_format.py

@@ -28,8 +28,6 @@ def write_item(item: Item, path: Path, normalize: bool = True):
     By default normalizes formatting of the body text and updates the item's body.
     """
     item.validate()
-    if item.is_binary:
-        raise ValueError(f"Binary items should be external files: {item}")
     if item.format and not item.format.supports_frontmatter:
         raise ValueError(f"Item format `{item.format.value}` does not support frontmatter: {item}")
 

{kash_shell-0.3.15 → kash_shell-0.3.16}/src/kash/local_server/local_server_routes.py

@@ -244,7 +244,7 @@ def _serve_item(
             media_type=mime_type,
         )
     else:
-        display_title = item.display_title() if item else str(path)
+        display_title = item.pick_title() if item else str(path)
 
         # For HEAD requests, return header with mime type only.
         if request.method == "HEAD":

{kash_shell-0.3.15 → kash_shell-0.3.16}/src/kash/model/actions_model.py

@@ -22,7 +22,7 @@ from kash.exec_model.shell_model import ShellResult
 from kash.llm_utils import LLM, LLMName
 from kash.llm_utils.llm_messages import Message, MessageTemplate
 from kash.model.exec_model import ExecContext
-from kash.model.items_model import UNTITLED, Item, ItemType
+from kash.model.items_model import UNTITLED, Format, Item, ItemType
 from kash.model.operations_model import Operation, Source
 from kash.model.params_model import (
     ALL_COMMON_PARAMS,
@@ -102,6 +102,10 @@ class ActionResult:
     shell_result: ShellResult | None = None
     """Customize control of how the action's result is displayed in the shell."""
 
+    def get_by_format(self, format: Format) -> Item:
+        """Convenience method to get an item for actions that return multiple formats."""
+        return next(item for item in self.items if item.format == format)
+
     def has_hints(self) -> bool:
         return bool(
             self.replaces_input or self.skip_duplicates or self.path_ops or self.shell_result

{kash_shell-0.3.15 → kash_shell-0.3.16}/src/kash/model/items_model.py

@@ -219,6 +219,12 @@ class Item:
     a text document, PDF or other resource, URL, etc.
     """
 
+    # TODO: A few cleanups:
+    # - Consider adding aliases and tags. See also Obsidian frontmatter format:
+    #   https://help.obsidian.md/Editing+and+formatting/Properties#Default%20properties
+    # - Can eliminate context here as we now have ExectContext in a contextvar.
+    # - Change store_path and external_path to a StorePath and Path instead of a str.
+
     type: ItemType
     state: State = State.draft
     title: str | None = None
@@ -230,17 +236,15 @@ class Item:
     created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
     modified_at: datetime | None = None
 
-    # TODO: Consider adding aliases and tags. See also Obsidian frontmatter format:
-    # https://help.obsidian.md/Editing+and+formatting/Properties#Default%20properties
-
     # Content of the item.
     # Text items are in body. Large or binary items may be stored externally.
+    # The external_path if present should always hold the current body of the content
+    # (and body will not be set). This is necessary for large or binary files.
     body: str | None = None
     external_path: str | None = None
     original_filename: str | None = None
 
     # Path to the item in the store, if it has been saved.
-    # TODO: Migrate this to StorePath.
     store_path: str | None = None
 
     # Optionally, relations to other items, including any time this item is derived from.
@@ -547,7 +551,7 @@ class Item:
         if filename_stem and not prefer_title:
             return slugify_snake(filename_stem)
         else:
-            return slugify_snake(self.abbrev_title(max_len=max_len, add_ops_suffix=True))
+            return slugify_snake(self.pick_title(max_len=max_len, add_ops_suffix=True))
 
     def default_filename(self) -> str:
         """
@@ -560,7 +564,16 @@ class Item:
         full_suffix = self.get_full_suffix()
         return join_suffix(slug, full_suffix)
 
-    def abbrev_title(
+    def body_heading(self, allowed_tags: tuple[str, ...] = ("h1", "h2")) -> str | None:
+        """
+        Get the first heading (by default h1 or h2) from the body text, if present.
+        """
+        if self.format in [Format.markdown, Format.md_html]:
+            return first_heading(self.body_text(), allowed_tags=allowed_tags)
+        # TODO: Support HTML <h1> and <h2> as well.
+        return None
+
+    def pick_title(
         self,
         *,
         max_len: int = 100,
@@ -619,41 +632,20 @@ class Item:
 
         return final_text
 
-    def display_title(self) -> str:
-        """
-        A display title for this item. Same as abbrev_title() but will fall back
-        to the filename if it is available.
-        """
-        display_title = self.title
-        if not display_title and self.store_path:
-            display_title = Path(self.store_path).name
-        if not display_title:
-            display_title = self.abbrev_title(pull_body_heading=True)
-        return display_title
-
-    def abbrev_description(self, max_len: int = 1000) -> str:
+    def pick_description(self, max_len: int = 1000) -> str:
         """
         Get or infer description.
         """
         return abbrev_on_words(html_to_plaintext(self.description or self.body or ""), max_len)
 
-    def body_heading(self) -> str | None:
-        """
-        Get the first h1 or h2 heading from the body text, if present.
-        """
-        if self.format in [Format.markdown, Format.md_html]:
-            return first_heading(self.body_text(), allowed_tags=("h1", "h2"))
-        # TODO: Support HTML <h1> and <h2> as well.
-        return None
-
     def abbrev_body(self, max_len: int) -> str:
         """
         Get an abbreviated version of the body text. Must not be a binary Item.
         Abbreviates YAML bodies like {"role": "user", "content": "Hello"} to "user Hello".
         """
-        body_text = self.body_text()[:max_len]
+        body_text = abbrev_str(self.body_text(), max_len)
 
-        # Just for aesthetics especially for titles of chat files.
+        # Just for aesthetics, especially for titles of chat files.
         if self.type in [ItemType.chat, ItemType.config] or self.format == Format.yaml:
             try:
                 yaml_obj = list(new_yaml().load_all(self.body_text()))
@@ -662,7 +654,7 @@ class Item:
             except Exception as e:
                 log.info("Error parsing YAML body: %s", e)
 
-        return body_text[:max_len]
+        return abbrev_str(body_text, max_len)
 
     @property
     def has_body(self) -> bool:
@@ -745,9 +737,14 @@ class Item:
         self,
         other: Item | None = None,
         update_timestamp: bool = False,
+        clear_fields=(
+            "store_path",  # Will be set at save time.
+            "source",  # Should be cleared so the ItemId of a copy is not the same as the original.
+            "modified_at",
+        ),
         **other_updates: Unpack[ItemUpdateOptions],
     ) -> dict[str, Any]:
-        overrides: dict[str, Any] = {"store_path": None, "modified_at": None}
+        overrides: dict[str, Any] = {f: None for f in clear_fields}
         if update_timestamp:
             overrides["created_at"] = datetime.now()
 
@@ -767,8 +764,9 @@ class Item:
         self, update_timestamp: bool = True, **other_updates: Unpack[ItemUpdateOptions]
     ) -> Item:
         """
-        Copy item with the given field updates. Resets `store_path` to None but preserves
-        other fields, including the body. Updates created time if requested.
+        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.
         """
         new_fields = self._copy_and_update(update_timestamp=update_timestamp, **other_updates)
         return Item(**new_fields)
@@ -783,9 +781,12 @@ class Item:
 
     def derived_copy(self, **updates: Unpack[ItemUpdateOptions]) -> Item:
         """
-        Same as `new_copy_with()`, but also makes any other updates and updates the
-        `derived_from` relation. If we also have an action context, then use the
-        `title_template` to derive a new title.
+        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.
+
+        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.
         """
         if not self.store_path:
             if self.relations.derived_from:
@@ -898,7 +899,7 @@ class Item:
         elif self.external_path:
             return fmt_loc(self.external_path)
         else:
-            return repr(self.abbrev_title())
+            return repr(self.pick_title())
 
     def as_chat_history(self) -> ChatHistory:
         if self.type != ItemType.chat:

{kash_shell-0.3.15 → kash_shell-0.3.16}/src/kash/shell/completions/shell_completions.py

@@ -270,7 +270,7 @@ def get_item_completions(
                 f"{fmt_store_path(not_none(item.store_path))}",
                 COMPLETION_DISPLAY_MAX_LEN,
             ),
-            description=item.abbrev_title(),
+            description=item.pick_title(),
             append_space=True,
             score=score,
         )