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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kash-shell
-Version: 0.3.14
+Version: 0.3.15
 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.14 → kash_shell-0.3.15}/src/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_shell-0.3.14 → kash_shell-0.3.15}/src/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_shell-0.3.14 → kash_shell-0.3.15}/src/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_shell-0.3.14 → kash_shell-0.3.15}/src/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_shell-0.3.14 → kash_shell-0.3.15}/src/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_shell-0.3.14 → kash_shell-0.3.15}/src/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
 
 

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

@@ -182,7 +182,7 @@ class FileStore(Workspace):
         except (FileNotFoundError, InvalidFilename):
             pass
 
-    def resolve_path(self, path: Path | StorePath) -> StorePath | None:
+    def resolve_to_store_path(self, path: Path | StorePath) -> StorePath | None:
         """
         Return a StorePath if the given path is within the store, otherwise None.
         If it is already a StorePath, return it unchanged.
@@ -195,6 +195,21 @@ class FileStore(Workspace):
         else:
             return None
 
+    def resolve_to_abs_path(self, path: Path | StorePath) -> Path:
+        """
+        Return an absolute path, resolving any store paths to within the store
+        and resolving other paths like regular `Path.resolve()`.
+        """
+        store_path = self.resolve_to_store_path(path)
+        if store_path:
+            return self.base_dir / store_path
+        elif path.is_absolute():
+            return path
+        else:
+            # Unspecified relative paths resolved to cwd.
+            # TODO: Consider if such paths might be store paths.
+            return path.resolve()
+
     def exists(self, store_path: StorePath) -> bool:
         """
         Check given store path refers to an existing file.

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

@@ -628,7 +628,7 @@ class Item:
         if not display_title and self.store_path:
             display_title = Path(self.store_path).name
         if not display_title:
-            display_title = self.abbrev_title()
+            display_title = self.abbrev_title(pull_body_heading=True)
         return display_title
 
     def abbrev_description(self, max_len: int = 1000) -> str:

{kash_shell-0.3.14 → kash_shell-0.3.15}/src/kash/utils/file_utils/file_formats_model.py

@@ -143,17 +143,23 @@ class Format(Enum):
 
     @property
     def is_markdown(self) -> bool:
-        """Is in pure Markdown (no HTML)."""
+        """Is this pure Markdown? Does not include Markdown mixed with HTML."""
         return self in [self.markdown]
 
     @property
     def is_markdown_with_html(self) -> bool:
-        """Is in Markdown with HTML."""
+        """Is this Markdown mixed with HTML?"""
         return self in [self.md_html]
 
     @property
     def is_html(self) -> bool:
-        return self in [self.html, self.md_html]
+        """Is this format HTML? Does not include Markdown mixed with HTML."""
+        return self in [self.html]
+
+    @property
+    def is_html_compatible(self) -> bool:
+        """Is this format directly compatible with HTML (any combination of text, markdown, or HTML)?"""
+        return self in [self.plaintext, self.markdown, self.md_html, self.html]
 
     @property
     def is_data(self) -> bool:

{kash_shell-0.3.14 → kash_shell-0.3.15}/src/kash/utils/text_handling/doc_normalization.py

@@ -9,6 +9,13 @@ from kash.utils.file_utils.file_formats_model import Format, detect_file_format
 from kash.utils.rich_custom.ansi_cell_len import ansi_cell_len
 
 
+def can_normalize(format: Format) -> bool:
+    """
+    True for Markdown (the only format we currently normalize).
+    """
+    return format == Format.markdown or format == Format.md_html
+
+
 def normalize_formatting(
     text: str,
     format: Format | None,

{kash_shell-0.3.14 → kash_shell-0.3.15}/src/kash/web_gen/templates/base_styles.css.jinja

@@ -121,13 +121,17 @@ h1 {
 
 h2 {
   font-size: 1.4rem;
-  margin-top: 1.5rem;
+  margin-top: 2rem;
   margin-bottom: 1rem;
 }
 
+h1 + h2 {
+  margin-top: 2rem;
+}
+
 h3 {
   font-size: 1.03rem;
-  margin-top: 1.5rem;
+  margin-top: 1.6rem;
   margin-bottom: 0.5rem;
 }
 
@@ -340,7 +344,7 @@ tbody tr:nth-child(even) {
   left: 50%;
   transform: translateX(-50%);
   box-sizing: border-box;
-  margin-bottom: 1rem;
+  margin: 2rem 0;
   background-color: var(--color-bg-solid);
 }
 {% endblock table_styles %}