kash-shell 0.3.10__py3-none-any.whl → 0.3.11__py3-none-any.whl

kash/actions/core/format_markdown_template.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import is_markdown
-from kash.model import ONE_OR_MORE_ARGS, ActionInput, ActionResult, ItemType, Param
+from kash.model import ONE_OR_MORE_ARGS, ActionInput, ActionResult, Param
 from kash.utils.common.type_utils import not_none
 from kash.utils.errors import InvalidInput
 
@@ -84,9 +84,6 @@ def format_markdown_template(
     # Format the body using the mapped items.
     body = template.format(**item_map)
 
-    result_item = items[0].derived_copy(
-        type=ItemType.doc,
-        body=body,
-    )
+    result_item = items[0].derived_copy(body=body)
 
     return ActionResult([result_item])

kash/actions/core/markdownify.py

@@ -1,7 +1,7 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import has_html_body, is_url_item
-from kash.model import Format, Item, ItemType
+from kash.model import Format, Item
 from kash.model.params_model import common_params
 from kash.web_content.file_cache_utils import get_url_html
 from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
@@ -26,7 +26,5 @@ def markdownify(item: Item, refetch: bool = False) -> Item:
     page_data = extract_text_readabilipy(url, html_content)
     markdown_content = markdownify_convert(page_data.clean_html)
 
-    output_item = item.derived_copy(
-        type=ItemType.doc, format=Format.markdown, body=markdown_content
-    )
+    output_item = item.derived_copy(format=Format.markdown, body=markdown_content)
     return output_item

kash/actions/core/readability.py

@@ -1,7 +1,7 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import has_html_body, is_url_item
-from kash.model import Format, Item, ItemType
+from kash.model import Format, Item
 from kash.model.params_model import common_params
 from kash.web_content.file_cache_utils import get_url_html
 from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
@@ -23,8 +23,6 @@ def readability(item: Item, refetch: bool = False) -> Item:
     url, html_content = get_url_html(item, expiration_sec=expiration_sec)
     page_data = extract_text_readabilipy(url, html_content)
 
-    output_item = item.derived_copy(
-        type=ItemType.doc, format=Format.html, body=page_data.clean_html
-    )
+    output_item = item.derived_copy(format=Format.html, body=page_data.clean_html)
 
     return output_item

kash/actions/core/render_as_html.py

@@ -1,18 +1,37 @@
-from kash.actions.core.webpage_config import webpage_config
-from kash.actions.core.webpage_generate import webpage_generate
+from kash.actions.core.tabbed_webpage_config import tabbed_webpage_config
+from kash.actions.core.tabbed_webpage_generate import tabbed_webpage_generate
 from kash.exec import kash_action
-from kash.exec.preconditions import has_text_body, is_html
-from kash.model import ActionInput, ActionResult
+from kash.exec.preconditions import has_full_html_page_body, has_text_body, is_html
+from kash.exec_model.args_model import ONE_OR_MORE_ARGS
+from kash.model import ActionInput, ActionResult, Param
+from kash.model.items_model import ItemType
+from kash.utils.file_utils.file_formats_model import Format
+from kash.web_gen.simple_webpage import simple_webpage_render
 
 
 @kash_action(
-    precondition=is_html | has_text_body,
+    expected_args=ONE_OR_MORE_ARGS,
+    precondition=(is_html | has_text_body) & ~has_full_html_page_body,
+    params=(Param("add_title", "Add a title to the page body.", type=bool),),
 )
-def render_as_html(input: ActionInput) -> ActionResult:
+def render_as_html(input: ActionInput, add_title: bool = False) -> ActionResult:
     """
-    Convert text, Markdown, or HTML to pretty, formatted HTML using the kash default
-    page template.
+    Convert text, Markdown, or HTML to pretty, formatted HTML using a clean
+    and simple page template. Supports GFM-flavored Markdown tables and footnotes.
+
+    If it's a single input, the output is a simple HTML page.
+    If it's multiple inputs, the output is a tabbed HTML page.
+
+    This adds a header, footer, etc. so should be used on a plain document or HTML basic
+    page, not a full HTML page with header and body already present.
     """
-    config_result = webpage_config(input)
-    result = webpage_generate(ActionInput(items=config_result.items))
-    return result
+    if len(input.items) == 1:
+        input_item = input.items[0]
+        html_body = simple_webpage_render(input_item, add_title_h1=add_title)
+        result_item = input_item.derived_copy(
+            type=ItemType.export, format=Format.html, body=html_body
+        )
+        return ActionResult([result_item])
+    else:
+        config_result = tabbed_webpage_config(input)
+        return tabbed_webpage_generate(ActionInput(items=config_result.items), add_title=add_title)

kash/actions/core/show_webpage.py

@@ -1,27 +1,22 @@
-from kash.actions.core.webpage_config import webpage_config
-from kash.actions.core.webpage_generate import webpage_generate
+from kash.actions.core.render_as_html import render_as_html
 from kash.commands.base.show_command import show
-from kash.config.logger import get_logger
 from kash.exec import kash_action
-from kash.exec.preconditions import has_text_body, is_html
+from kash.exec.preconditions import has_full_html_page_body, has_text_body, is_html
+from kash.exec_model.args_model import ONE_OR_MORE_ARGS
 from kash.exec_model.commands_model import Command
 from kash.exec_model.shell_model import ShellResult
 from kash.model import ActionInput, ActionResult
 
-log = get_logger(__name__)
-
 
 @kash_action(
-    precondition=is_html | has_text_body,
+    expected_args=ONE_OR_MORE_ARGS,
+    precondition=(is_html | has_text_body) & ~has_full_html_page_body,
 )
 def show_webpage(input: ActionInput) -> ActionResult:
     """
     Show text, Markdown, or HTML as a nicely formatted webpage.
     """
-    config_result = webpage_config(input)
-
-    log.message("Configured web page: %s", config_result)
-    result = webpage_generate(ActionInput(items=config_result.items))
+    result = render_as_html(input)
 
     # Automatically show the result.
     result.shell_result = ShellResult(display_command=Command.assemble(show))

kash/actions/core/strip_html.py

@@ -1,7 +1,7 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import has_html_body, has_text_body
-from kash.model import Format, Item, ItemType
+from kash.model import Format, Item
 from kash.utils.common.format_utils import html_to_plaintext
 from kash.utils.errors import InvalidInput
 
@@ -19,10 +19,6 @@ def strip_html(item: Item) -> Item:
         raise InvalidInput("Item must have a body")
 
     clean_body = html_to_plaintext(item.body)
-    output_item = item.derived_copy(
-        type=ItemType.doc,
-        format=Format.markdown,
-        body=clean_body,
-    )
+    output_item = item.derived_copy(format=Format.markdown, body=clean_body)
 
     return output_item

kash/actions/core/{webpage_config.py → tabbed_webpage_config.py}

@@ -1,5 +1,6 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
+from kash.exec_model.args_model import ONE_OR_MORE_ARGS
 from kash.model import ActionInput, ActionResult, Param
 from kash.utils.errors import InvalidInput
 from kash.web_gen import tabbed_webpage
@@ -8,15 +9,16 @@ log = get_logger(__name__)
 
 
 @kash_action(
+    expected_args=ONE_OR_MORE_ARGS,
     params=(
         Param(
             name="clean_headings",
             type=bool,
             description="Use an LLM to clean up headings.",
         ),
-    )
+    ),
 )
-def webpage_config(input: ActionInput, clean_headings: bool = False) -> ActionResult:
+def tabbed_webpage_config(input: ActionInput, clean_headings: bool = False) -> ActionResult:
     """
     Set up a web page config with optional tabs for each page of content. Uses first item as the page title.
     """
@@ -24,6 +26,6 @@ def webpage_config(input: ActionInput, clean_headings: bool = False) -> ActionRe
         if not item.body:
             raise InvalidInput(f"Item must have a body: {item}")
 
-    config_item = tabbed_webpage.webpage_config(input.items, clean_headings)
+    config_item = tabbed_webpage.tabbed_webpage_config(input.items, clean_headings)
 
     return ActionResult([config_item])

kash/actions/core/{webpage_generate.py → tabbed_webpage_generate.py}

@@ -1,7 +1,7 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import is_config
-from kash.model import ONE_ARG, ActionInput, ActionResult, FileExt, Format, Item, ItemType
+from kash.model import ONE_ARG, ActionInput, ActionResult, FileExt, Format, Item, ItemType, Param
 from kash.web_gen import tabbed_webpage
 
 log = get_logger(__name__)
@@ -10,13 +10,14 @@ log = get_logger(__name__)
 @kash_action(
     expected_args=ONE_ARG,
     precondition=is_config,
+    params=(Param("add_title", "Add a title to the page body.", type=bool),),
 )
-def webpage_generate(input: ActionInput) -> ActionResult:
+def tabbed_webpage_generate(input: ActionInput, add_title: bool = False) -> ActionResult:
     """
-    Generate a web page from a configured web page item.
+    Generate a tabbed web page from a config item for the tabbed template.
     """
     config_item = input.items[0]
-    html = tabbed_webpage.webpage_generate(config_item)
+    html = tabbed_webpage.tabbed_webpage_generate(config_item, add_title_h1=add_title)
 
     webpage_item = Item(
         title=config_item.title,

kash/commands/base/files_command.py

@@ -75,6 +75,9 @@ def _print_listing_tallies(
         cprint("(use --no_max to remove cutoff)", style=STYLE_HINT)
 
 
+DEFAULT_MAX_PG = 100
+
+
 @kash_command
 def files(
     *paths: str,
@@ -108,9 +111,11 @@ def files(
     and grouping.
 
     :param overview: Recurse a couple levels and show files, but not too many.
-        Same as `--groupby=parent --depth=2 --max_per_group=10 --omit_dirs`.
+        Same as `--groupby=parent --depth=2 --max_per_group=100 --omit_dirs`
+        except also scales down `max_per_group` to 25 or 50 if there are many files.
     :param recent: Only shows the most recently modified files in each directory.
-        Same as `--sort=modified --reverse --groupby=parent --max_per_group=10`.
+        Same as `--sort=modified --reverse --groupby=parent --max_per_group=100`
+        except also scales down `max_per_group` to 25 or 50 if there are many files.
     :param recursive: List all files recursively. Same as `--depth=-1`.
     :param flat: Show files in a flat list, rather than grouped by parent directory.
         Same as `--groupby=flat`.
@@ -179,16 +184,17 @@ def files(
         # Within workspaces, we show more files by default since they are always in
         # subdirectories.
         overview = True  # Handled next.
+    cap_per_group = False
     if overview:
-        max_per_group = 10 if max_per_group <= 0 else max_per_group
         groupby = GroupByOption.parent if groupby is None else groupby
         depth = 2 if depth is None else depth
+        cap_per_group = True
         omit_dirs = True
     if recent:
-        max_per_group = 10 if max_per_group <= 0 else max_per_group
         groupby = GroupByOption.parent if groupby is None else groupby
         depth = 2 if depth is None else depth
         sort = SortOption.modified if sort is None else sort
+        cap_per_group = True
         reverse = True
     if flat:
         groupby = GroupByOption.flat
@@ -291,6 +297,18 @@ def files(
 
         return ShellResult(show_selection=True)
 
+    # Unless max_per_group is explicit, use heuristics to limit per group if
+    # there are lots of groups and lots of files per group.
+    # Default is max 100 per group but if we have 4 * 100 items, cut to 25.
+    # If we have 2 * 100 items, cut to 50.
+    final_max_pg = DEFAULT_MAX_PG if cap_per_group else max_per_group
+    max_pg_explicit = max_per_group > 0
+    if not max_pg_explicit:
+        group_lens = [len(group_df) for group_df in grouped]
+        for ratio in [2, 4]:
+            if sum(group_lens) > ratio * DEFAULT_MAX_PG:
+                final_max_pg = int(DEFAULT_MAX_PG / ratio)
+
     total_displayed = 0
     total_displayed_size = 0
     now = datetime.now(UTC)
@@ -312,8 +330,8 @@ def files(
                         text_wrap=Wrap.NONE,
                     )
 
-                if max_per_group > 0:
-                    display_df = group_df.head(max_per_group)
+                if final_max_pg > 0:
+                    display_df = group_df.head(final_max_pg)
                 else:
                     display_df = group_df
 
@@ -378,9 +396,9 @@ def files(
                     total_displayed_size += row.size
 
                 # Indicate if items are omitted.
-                if groupby and max_per_group > 0 and len(group_df) > max_per_group:
+                if groupby and final_max_pg > 0 and len(group_df) > final_max_pg:
                     cprint(
-                        f"{indent}… and {len(group_df) - max_per_group} more files",
+                        f"{indent}… and {len(group_df) - final_max_pg} more files",
                         style=COLOR_EXTRA,
                         text_wrap=Wrap.NONE,
                     )
@@ -388,9 +406,9 @@ def files(
                 if group_name:
                     PrintHooks.spacer()
 
-            if not groupby and max_per_group > 0 and items_matching > max_per_group:
+            if not groupby and final_max_pg > 0 and items_matching > final_max_pg:
                 cprint(
-                    f"{indent}… and {items_matching - max_per_group} more files",
+                    f"{indent}… and {items_matching - final_max_pg} more files",
                     style=COLOR_EXTRA,
                     text_wrap=Wrap.NONE,
                 )

kash/commands/workspace/workspace_commands.py

@@ -285,7 +285,7 @@ def init_workspace(path: str | None = None) -> None:
 @kash_command
 def workspace(workspace_name: str | None = None) -> None:
     """
-    If no args are given, change directory to the current workspace.
+    If no args are given, show current workspace info.
     If a workspace name is given, change to that workspace, creating it if it doesn't exist.
     """
     if workspace_name:
@@ -302,7 +302,6 @@ def workspace(workspace_name: str | None = None) -> None:
         ws.log_workspace_info()
     else:
         ws = current_ws(silent=True)
-        os.chdir(ws.base_dir)
         ws.log_workspace_info()
 
 

kash/config/colors.py

@@ -136,8 +136,8 @@ web_light_translucent = SimpleNamespace(
     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(44, 28%, 90%, 0.3)"),
-    bg_alt_solid=hsl_to_hex("hsla(44, 28%, 97%, 1)"),
+    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%)"),
     border=hsl_to_hex("hsl(188, 8%, 50%)"),
     border_hint=hsl_to_hex("hsla(188, 8%, 72%, 0.7)"),

kash/exec/action_decorators.py

@@ -174,7 +174,7 @@ def _merge_param_declarations(
             merged_params[fp.name] = Param(
                 name=fp.name,
                 description=None,
-                type=fp.type or str,
+                type=fp.effective_type or str,
                 default_value=fp.default if fp.has_default else None,
                 is_explicit=not fp.has_default,
             )
@@ -248,13 +248,13 @@ def kash_action(
 
         # Inspect and sanity check the formal params.
         func_params = inspect_function_params(orig_func)
-        if len(func_params) == 0 or func_params[0].type not in (ActionInput, Item):
+        if len(func_params) == 0 or func_params[0].effective_type not in (ActionInput, Item):
             raise InvalidDefinition(
                 f"Decorator `@kash_action` requires exactly one positional parameter, "
                 f"`input` of type `ActionInput` or `Item` on function `{orig_func.__name__}` but "
                 f"got params: {func_params}"
             )
-        if any(fp.is_positional for fp in func_params[1:]):
+        if any(fp.is_pure_positional for fp in func_params[1:]):
             raise InvalidDefinition(
                 "Decorator `@kash_action` requires all parameters after the first positional "
                 f"parameter to be keyword parameters on function `{orig_func.__name__}` but "
@@ -265,7 +265,7 @@ def kash_action(
         context_param = next((fp for fp in func_params if fp.name == "context"), None)
         if context_param:
             func_params.remove(context_param)
-        if context_param and context_param.is_positional:
+        if context_param and context_param.is_pure_positional:
             raise InvalidDefinition(
                 "Decorator `@kash_action` requires the `context` parameter to be a keyword "
                 "parameter, not positional, on function `{func.__name__}`"
@@ -273,7 +273,7 @@ def kash_action(
 
         # If the original function is a simple action function (processes a single item),
         # wrap it to convert to an ActionFunction.
-        is_simple_func = func_params[0].type == Item
+        is_simple_func = func_params[0].effective_type == Item
         action_func: ActionFunction
         if is_simple_func:
             simple_func = cast(SimpleActionFunction, orig_func)
@@ -333,7 +333,7 @@ def kash_action(
                 if context_param:
                     kw_args["context"] = context
                 for fp in func_params[1:]:
-                    if fp.is_positional:
+                    if fp.is_pure_positional:
                         pos_args.append(self.get_param(fp.name))
                     else:
                         kw_args[fp.name] = self.get_param(fp.name)

kash/exec/llm_transforms.py

@@ -12,7 +12,8 @@ from kash.llm_utils.fuzzy_parsing import strip_markdown_fence
 from kash.llm_utils.llm_completion import llm_template_completion
 from kash.llm_utils.llm_messages import Message, MessageTemplate
 from kash.model.actions_model import LLMOptions
-from kash.model.items_model import Item, ItemType
+from kash.model.items_model import Item
+from kash.text_handling.doc_normalization import normalize_formatting_ansi
 from kash.utils.errors import InvalidInput
 from kash.utils.file_utils.file_formats_model import Format
 
@@ -90,6 +91,7 @@ def llm_transform_item(
     normalize: bool = True,
     strip_fence: bool = True,
     check_no_results: bool = True,
+    format: Format | None = None,
 ) -> Item:
     """
     Main function for running an LLM action on an item.
@@ -110,12 +112,13 @@ def llm_transform_item(
     log.message("LLM transform from action `%s` on item: %s", action.name, item)
     log.message("LLM options: %s", action.llm_options)
 
-    result_item = item.derived_copy(type=ItemType.doc, body=None, format=Format.markdown)
+    format = format or item.format or Format.markdown
+    result_item = item.derived_copy(body=None, format=format)
     result_str = llm_transform_str(llm_options, item.body, check_no_results=check_no_results)
     if strip_fence:
         result_str = strip_markdown_fence(result_str)
     if normalize:
-        result_str = fill_markdown(result_str)
+        result_str = normalize_formatting_ansi(result_str, format=format)
 
     result_item.body = result_str
     return result_item

kash/exec/preconditions.py

@@ -8,6 +8,7 @@ from chopdiff.html import has_timestamp
 from kash.exec.precondition_registry import kash_precondition
 from kash.model.items_model import Item, ItemType
 from kash.text_handling.markdown_utils import extract_bullet_points
+from kash.utils.file_utils.file_formats import is_full_html_page
 from kash.utils.file_utils.file_formats_model import Format
 
 
@@ -93,6 +94,11 @@ def has_html_body(item: Item) -> bool:
     return has_body(item) and item.format in (Format.html, Format.md_html)
 
 
+@kash_precondition
+def has_full_html_page_body(item: Item) -> bool:
+    return bool(has_html_body(item) and item.body and is_full_html_page(item.body))
+
+
 @kash_precondition
 def is_plaintext(item: Item) -> bool:
     return has_body(item) and item.format == Format.plaintext

kash/exec/resolve_args.py

@@ -105,6 +105,10 @@ def assemble_action_args(
 
 
 def resolvable_paths(paths: Sequence[StorePath | Path]) -> list[StorePath]:
+    """
+    Return which of the given StorePaths are resolvable (exist) in the
+    current workspace.
+    """
     ws = current_ws()
     resolvable = list(filter(None, (ws.resolve_path(p) for p in paths)))
     return resolvable

kash/file_storage/file_store.py

@@ -450,19 +450,11 @@ class FileStore(Workspace):
             if not path.exists():
                 raise FileNotFound(f"File not found: {fmt_loc(path)}")
 
-            # It's a path outside the store, so copy it in.
-            _name, filename_item_type, format, _file_ext = parse_item_filename(path)
-
-            # Best guesses on item types if not specified.
-            item_type = as_type
-            if not item_type and filename_item_type:
-                item_type = filename_item_type
-            if not item_type and format:
-                item_type = ItemType.for_format(format)
-            if not item_type:
-                item_type = ItemType.resource
-
-            if format and format.supports_frontmatter:
+            # First treat it as an external file to analyze file type and format.
+            item = Item.from_external_path(path)
+
+            # If it's a text/frontmatter-friendly, read it fully.
+            if item.format and item.format.supports_frontmatter:
                 log.message("Importing text file: %s", fmt_loc(path))
                 # This will read the file with or without frontmatter.
                 # We are importing so we want to drop the external path so we save the body.
@@ -486,15 +478,25 @@ class FileStore(Workspace):
                 log.message("Importing non-text file: %s", fmt_loc(path))
                 # Binary or other files we just copy over as-is, preserving the name.
                 # We know the extension is recognized.
-                item = Item.from_external_path(path)
-                store_path, _found, _prev = self.store_path_for(item)
+                store_path, _found, old_store_path = self.store_path_for(item)
                 if self.exists(store_path):
                     raise FileExists(f"Resource already in store: {fmt_loc(store_path)}")
 
-                item.type = item_type
-
-                log.message("Importing resource: %s -> %s", fmt_loc(path), fmt_loc(store_path))
+                log.message("Importing resource: %s", fmt_loc(path))
                 copyfile_atomic(path, self.base_dir / store_path, make_parents=True)
+
+                # Optimization: Don't import an identical file twice.
+                if old_store_path:
+                    old_hash = self.hash(old_store_path)
+                    new_hash = self.hash(store_path)
+                    if old_hash == new_hash:
+                        log.message(
+                            "Imported resource is identical to the previous import: %s",
+                            fmt_loc(old_store_path),
+                        )
+                        os.unlink(self.base_dir / store_path)
+                        store_path = old_store_path
+                log.message("Imported resource: %s", fmt_loc(store_path))
             return store_path
 
     def import_items(

kash/help/function_param_info.py

@@ -12,7 +12,7 @@ def _look_up_param_docs(func: Callable[..., Any], kw_params: list[FuncParam]) ->
         name = func_param.name
         param = ALL_COMMON_PARAMS.get(name)
         if not param:
-            param = Param(name, description=None, type=func_param.type or str)
+            param = Param(name, description=None, type=func_param.effective_type or str)
 
         # Also check the docstring for a description of this parameter.
         docstring = parse_docstring(func.__doc__ or "")

kash/local_server/local_server_routes.py

@@ -18,7 +18,6 @@ from kash.shell.file_icons.nerd_icons import icon_for_file
 from kash.shell.output.shell_output import Wrap
 from kash.utils.common.type_utils import not_none
 from kash.utils.errors import FileNotFound, InvalidFilename
-from kash.web_gen import base_templates_dir
 from kash.web_gen.template_render import render_web_template
 from kash.workspaces.workspace_output import print_file_info
 
@@ -140,14 +139,11 @@ def explain(text: str):
 
     return HTMLResponse(
         render_web_template(
-            base_templates_dir,
             "base_webpage.html.jinja",
             {
                 "title": f"Help: {text}",
                 "content": render_web_template(
-                    base_templates_dir,
-                    "explain_view.html.jinja",
-                    {"help_html": help_html, "page_url": page_url},
+                    "explain_view.html.jinja", {"help_html": help_html, "page_url": page_url}
                 ),
             },
         )
@@ -270,12 +266,10 @@ def _serve_item(
 
         return HTMLResponse(
             render_web_template(
-                base_templates_dir,
                 "base_webpage.html.jinja",
                 {
                     "title": display_title,
                     "content": render_web_template(
-                        base_templates_dir,
                         "item_view.html.jinja",
                         {
                             "item": item,