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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kash-shell
-Version: 0.3.15
+Version: 0.3.17
 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.17}/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.17}/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.17}/src/kash/commands/base/files_command.py

@@ -64,7 +64,6 @@ def _print_listing_tallies(
             f"{EMOJI_WARN} {file_listing.files_ignored} files and {file_listing.dirs_ignored} dirs were ignored",
             style=COLOR_EXTRA,
         )
-        cprint("(use --no_ignore to show hidden files)", style=STYLE_HINT)
 
     if file_listing.total_skipped > 0:
         cprint(
@@ -72,7 +71,8 @@ def _print_listing_tallies(
             f"at max_files={max_files}, max_depth={max_depth}, max_per_subdir={max_per_subdir}",
             style=COLOR_EXTRA,
         )
-        cprint("(use --no_max to remove cutoff)", style=STYLE_HINT)
+    if file_listing.total_ignored + file_listing.total_skipped > 0:
+        cprint("(use --all to show all files)", style=STYLE_HINT)
 
 
 DEFAULT_MAX_PER_GROUP = 50

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

@@ -133,27 +133,63 @@ web_light_translucent = SimpleNamespace(
     primary=hsl_to_hex("hsl(188, 31%, 41%)"),
     primary_light=hsl_to_hex("hsl(188, 40%, 62%)"),
     secondary=hsl_to_hex("hsl(188, 12%, 28%)"),
+    tertiary=hsl_to_hex("hsl(188, 7%, 64%)"),
     bg=hsl_to_hex("hsla(44, 6%, 100%, 0.75)"),
     bg_solid=hsl_to_hex("hsla(44, 6%, 100%, 1)"),
     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)"),
     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.7)"),
+    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, 7%, 94%, 0.8)"),
+    hover_bg=hsl_to_hex("hsla(188, 12%, 94%, 0.8)"),
     hint=hsl_to_hex("hsl(188, 11%, 65%)"),
+    hint_gentle=hsl_to_hex("hsla(188, 11%, 65%, 0.2)"),
     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, 70%, 37%)"),
+    failure=hsl_to_hex("hsl(7, 70%, 37%)"),
     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%)"),
+    tertiary=hsl_to_hex("hsl(188, 7%, 40%)"),
+    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, 10%, 90%)"),
+    code=hsl_to_hex("hsl(44, 38%, 72%)"),
+    border=hsl_to_hex("hsl(188, 8%, 25%)"),
+    border_hint=hsl_to_hex("hsla(188, 8%, 35%, 0.3)"),
+    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%)"),
+    hint_gentle=hsl_to_hex("hsla(188, 11%, 55%, 0.2)"),
+    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, 52%, 65%)"),
+    success=hsl_to_hex("hsl(134, 72%, 73%)"),
+    failure=hsl_to_hex("hsl(7, 46%, 53%)"),
+    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 +247,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 +267,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 +300,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.17}/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.17}/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.17}/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.17}/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, *formats: 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 in formats)
+
     def has_hints(self) -> bool:
         return bool(
             self.replaces_input or self.skip_duplicates or self.path_ops or self.shell_result