kash-shell 0.3.14__py3-none-any.whl → 0.3.16__py3-none-any.whl

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/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/commands/workspace/selection_commands.py

@@ -7,6 +7,7 @@ from strif import copyfile_atomic
 
 from kash.config.logger import get_logger
 from kash.exec import kash_command
+from kash.exec.resolve_args import assemble_path_args
 from kash.exec_model.shell_model import ShellResult
 from kash.model.paths_model import StorePath
 from kash.shell.ui.shell_results import shell_print_selection_history
@@ -30,6 +31,7 @@ def select(
     clear_all: bool = False,
     clear_future: bool = False,
     refresh: bool = False,
+    no_check: bool = False,
 ) -> ShellResult:
     """
     Set or show the current selection.
@@ -51,6 +53,7 @@ def select(
     :param clear_all: Clear the full selection history.
     :param clear_future: Clear all selections from history after the current one.
     :param refresh: Refresh the current selection to drop any paths that no longer exist.
+    :param no_check: Do not check if the paths exist.
     """
     ws = current_ws()
 
@@ -68,6 +71,10 @@ def select(
         raise InvalidInput("Cannot combine multiple flags")
     if paths and any(exclusive_flags):
         raise InvalidInput("Cannot combine paths with other flags")
+    if not no_check:
+        for path in paths:
+            if not Path(ws.base_dir / path).exists():
+                raise InvalidInput(f"Path does not exist: {fmt_loc(path)}")
 
     if paths:
         store_paths = [StorePath(path) for path in paths]
@@ -203,3 +210,18 @@ def save(parent: str | None = None, to: str | None = None, no_frontmatter: bool
         for store_path in store_paths:
             target_path = target_dir / basename(store_path)
             copy_file(store_path, target_path)
+
+
+@kash_command
+def show_parent_dir(*paths: str) -> None:
+    """
+    Show the parent directory of the first item in the current selection.
+    """
+    from kash.commands.base.show_command import show
+
+    input_paths = assemble_path_args(*paths)
+    if not input_paths:
+        raise InvalidInput("No paths provided")
+
+    input_path = current_ws().resolve_to_abs_path(input_paths[0])
+    show(input_path.parent)

kash/commands/workspace/workspace_commands.py

@@ -59,6 +59,7 @@ from kash.utils.errors import InvalidInput
 from kash.utils.file_formats.chat_format import tail_chat_history
 from kash.utils.file_utils.dir_info import is_nonempty_dir
 from kash.utils.file_utils.file_formats_model import Format
+from kash.utils.text_handling.doc_normalization import can_normalize
 from kash.web_content.file_cache_utils import cache_file
 from kash.workspaces import (
     current_ws,
@@ -189,11 +190,13 @@ def cache_content(*urls_or_paths: str, refetch: bool = False) -> None:
 
 
 @kash_command
-def download(*urls_or_paths: str, refetch: bool = False) -> ShellResult:
+def download(*urls_or_paths: str, refetch: bool = False, no_format: bool = False) -> ShellResult:
     """
     Download a URL or resource. Uses cached content if available, unless `refetch` is true.
     Inputs can be URLs or paths to URL resources.
     Creates both resource and document versions for text content.
+
+    :param no_format: If true, do not also normalize Markdown content.
     """
     ws = current_ws()
     saved_paths = []
@@ -236,11 +239,13 @@ def download(*urls_or_paths: str, refetch: bool = False) -> ShellResult:
                 mime_type=mime_type,
                 original_filename=original_filename,
             )
+            # For initial content, do not format or add frontmatter.
             store_path = ws.save(resource_item, no_frontmatter=True, no_format=True)
             saved_paths.append(store_path)
+            select(store_path)
 
-            # Also create a doc version for text content
-            if resource_item.format and resource_item.format.supports_frontmatter:
+            # Also create a doc version for text content if we want to normalize formatting.
+            if resource_item.format and can_normalize(resource_item.format) and not no_format:
                 doc_item = Item.from_external_path(
                     cache_result.content.path,
                     ItemType.doc,
@@ -248,8 +253,10 @@ def download(*urls_or_paths: str, refetch: bool = False) -> ShellResult:
                     mime_type=mime_type,
                     original_filename=original_filename,
                 )
-                doc_store_path = ws.save(doc_item, no_frontmatter=False, no_format=False)
+                # Now use default formatting and frontmatter.
+                doc_store_path = ws.save(doc_item)
                 saved_paths.append(doc_store_path)
+                select(doc_store_path)
 
     print_status(
         "Downloaded %s %s:\n%s",
@@ -257,7 +264,6 @@ def download(*urls_or_paths: str, refetch: bool = False) -> ShellResult:
         plural("item", len(saved_paths)),
         fmt_lines(saved_paths),
     )
-    select(*saved_paths)
 
     return ShellResult(show_selection=True)
 

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/exec/action_exec.py

@@ -1,7 +1,8 @@
 import time
 from dataclasses import replace
+from pathlib import Path
 
-from prettyfmt import fmt_lines, plural
+from prettyfmt import fmt_lines, fmt_path, plural
 
 from kash.config.logger import get_logger
 from kash.config.text_styles import (
@@ -287,6 +288,14 @@ def save_action_result(
     Save the result of an action to the workspace. Handles skipping duplicates and
     archiving old inputs, if appropriate, based on hints in the ActionResult.
     """
+    # If an action returned an external path, we should confirm it exists or it is probably
+    # a bug in the action.
+    for item in result.items:
+        if item.external_path and not Path(item.external_path).exists():
+            raise InvalidOutput(
+                f"External path returned by action does not exist: {fmt_path(item.external_path)}"
+            )
+
     input_items = action_input.items
 
     skipped_paths = []
@@ -377,7 +386,11 @@ def run_action_with_caching(
         # Run it!
         result = run_action_operation(context, action_input, operation)
         result_store_paths, archived_store_paths = save_action_result(
-            ws, result, action_input, as_tmp=settings.tmp_output, no_format=settings.no_format
+            ws,
+            result,
+            action_input,
+            as_tmp=settings.tmp_output,
+            no_format=settings.no_format,
         )
 
         PrintHooks.before_done_message()
@@ -448,13 +461,19 @@ def run_action_with_shell_context(
 
     # As a special case for convenience, if the action expects no args, ignore any pre-selected inputs.
     if action.expected_args == NO_ARGS and from_selection:
-        log.message("Not using current selection since action `%s` expects no args.", action_name)
+        log.message(
+            "Not using current selection since action `%s` expects no args.",
+            action_name,
+        )
         args.clear()
 
     if args:
         source_str = "provided args" if provided_args else "selection"
         log.message(
-            "Using %s as inputs to action `%s`:\n%s", source_str, action_name, fmt_lines(args)
+            "Using %s as inputs to action `%s`:\n%s",
+            source_str,
+            action_name,
+            fmt_lines(args),
         )
 
     # Get items for each input arg.

kash/exec/precondition_registry.py

@@ -16,11 +16,13 @@ def kash_precondition(func: Callable[[Item], bool]) -> Precondition:
     """
     Decorator to register a function as a Precondition.
     The function should return a bool and/or raise `PreconditionFailure`.
+    Returns an actual Precondition object, not the function, so that it's possible to
+    do precondition algebra, e.g. `is_file & has_body`.
 
     Example:
-        @register_precondition
-        def is_file(item: Item) -> bool:
-            return item.is_file()
+        @kash_precondition
+        def has_body(item: Item) -> bool:
+            return item.has_body()
     """
     precondition = Precondition(func)
 

kash/exec/preconditions.py

@@ -104,6 +104,11 @@ def has_html_body(item: Item) -> bool:
     return bool(has_body(item) and item.format and item.format.is_html)
 
 
+@kash_precondition
+def has_html_compatible_body(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_html_compatible)
+
+
 @kash_precondition
 def has_markdown_body(item: Item) -> bool:
     return bool(has_body(item) and item.format and item.format.is_markdown)
@@ -136,14 +141,14 @@ def is_markdown_with_html(item: Item) -> bool:
 
 @kash_precondition
 def is_markdown_template(item: Item) -> bool:
-    return is_markdown(item) and contains_curly_vars(item)
+    return has_markdown_body(item) and contains_curly_vars(item)
 
 
 @kash_precondition
 def is_markdown_list(item: Item) -> bool:
     try:
         return (
-            is_markdown(item)
+            has_markdown_body(item)
             and item.body is not None
             and len(extract_bullet_points(item.body)) >= 2
         )

kash/exec/resolve_args.py

@@ -42,7 +42,7 @@ def resolve_path_arg(path_str: UnresolvedPath) -> Path | StorePath:
         return path
     else:
         try:
-            store_path = current_ws().resolve_path(path)
+            store_path = current_ws().resolve_to_store_path(path)
             if store_path:
                 return store_path
             else:
@@ -110,7 +110,7 @@ def resolvable_paths(paths: Sequence[StorePath | Path]) -> list[StorePath]:
     current workspace.
     """
     ws = current_ws()
-    resolvable = list(filter(None, (ws.resolve_path(p) for p in paths)))
+    resolvable = list(filter(None, (ws.resolve_to_store_path(p) for p in paths)))
     return resolvable