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

kash/actions/__init__.py

@@ -1,16 +1,16 @@
 from dataclasses import dataclass
 from pathlib import Path
 
+from strif import AtomicVar
+
 from kash.config.logger import get_logger
 from kash.config.settings import APP_NAME
-from kash.exec import import_action_subdirs
-from kash.utils.common.atomic_var import AtomicVar
+from kash.exec import import_and_register
 from kash.utils.common.import_utils import import_namespace_modules
 
 log = get_logger(__name__)
 
-# This hook can be used for auto-registering actions from any module.
-import_action_subdirs(["core", "meta"], __package__, Path(__file__).parent)
+import_and_register(__package__, Path(__file__).parent, ["core", "meta"])
 
 
 @dataclass(frozen=True)

kash/actions/core/markdownify.py

@@ -2,6 +2,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.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
 
@@ -10,16 +11,18 @@ log = get_logger(__name__)
 
 @kash_action(
     precondition=is_url_item | has_html_body,
+    params=common_params("refetch"),
     mcp_tool=True,
 )
-def markdownify(item: Item) -> Item:
+def markdownify(item: Item, refetch: bool = False) -> Item:
     """
     Converts a URL or raw HTML item to Markdown, fetching with the content
     cache if needed. Also uses readability to clean up the HTML.
     """
     from markdownify import markdownify as markdownify_convert
 
-    url, html_content = get_url_html(item)
+    expiration_sec = 0 if refetch else None
+    url, html_content = get_url_html(item, expiration_sec=expiration_sec)
     page_data = extract_text_readabilipy(url, html_content)
     markdown_content = markdownify_convert(page_data.clean_html)
 

kash/actions/core/readability.py

@@ -2,6 +2,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.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
 
@@ -10,14 +11,16 @@ log = get_logger(__name__)
 
 @kash_action(
     precondition=is_url_item | has_html_body,
+    params=common_params("refetch"),
     mcp_tool=True,
 )
-def readability(item: Item) -> Item:
+def readability(item: Item, refetch: bool = False) -> Item:
     """
     Extracts clean HTML from a raw HTML item.
     See `markdownify` to also convert to Markdown.
     """
-    url, html_content = get_url_html(item)
+    expiration_sec = 0 if refetch else None
+    url, html_content = get_url_html(item, expiration_sec=expiration_sec)
     page_data = extract_text_readabilipy(url, html_content)
 
     output_item = item.derived_copy(

kash/actions/core/render_as_html.py

@@ -0,0 +1,18 @@
+from kash.actions.core.webpage_config import webpage_config
+from kash.actions.core.webpage_generate import webpage_generate
+from kash.exec import kash_action
+from kash.exec.preconditions import has_text_body, is_html
+from kash.model import ActionInput, ActionResult
+
+
+@kash_action(
+    precondition=is_html | has_text_body,
+)
+def render_as_html(input: ActionInput) -> ActionResult:
+    """
+    Convert text, Markdown, or HTML to pretty, formatted HTML using the kash default
+    page template.
+    """
+    config_result = webpage_config(input)
+    result = webpage_generate(ActionInput(items=config_result.items))
+    return result

kash/actions/core/webpage_config.py

@@ -1,14 +1,22 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
-from kash.model import ActionInput, ActionResult
+from kash.model import ActionInput, ActionResult, Param
 from kash.utils.errors import InvalidInput
 from kash.web_gen import tabbed_webpage
 
 log = get_logger(__name__)
 
 
-@kash_action()
-def webpage_config(input: ActionInput) -> ActionResult:
+@kash_action(
+    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:
     """
     Set up a web page config with optional tabs for each page of content. Uses first item as the page title.
     """
@@ -16,6 +24,6 @@ def webpage_config(input: ActionInput) -> ActionResult:
         if not item.body:
             raise InvalidInput(f"Item must have a body: {item}")
 
-    config_item = tabbed_webpage.webpage_config(input.items)
+    config_item = tabbed_webpage.webpage_config(input.items, clean_headings)
 
     return ActionResult([config_item])

kash/commands/__init__.py

@@ -1,21 +1,9 @@
-# Import all command modules to ensure commands are registered.
+from pathlib import Path
 
-import kash.commands.base.basic_file_commands  # noqa: F401
-import kash.commands.base.browser_commands  # noqa: F401
-import kash.commands.base.debug_commands  # noqa: F401
-import kash.commands.base.diff_commands  # noqa: F401
-import kash.commands.base.files_command  # noqa: F401
-import kash.commands.base.general_commands  # noqa: F401
-import kash.commands.base.logs_commands  # noqa: F401
-import kash.commands.base.model_commands  # noqa: F401
-import kash.commands.base.reformat_command  # noqa: F401
-import kash.commands.base.search_command  # noqa: F401
-import kash.commands.base.show_command  # noqa: F401
-import kash.commands.extras.utils_commands  # noqa: F401
-import kash.commands.help.assistant_commands  # noqa: F401  # noqa: F401
-import kash.commands.help.doc_commands  # noqa: F401
-import kash.commands.help.help_commands  # noqa: F401
-import kash.commands.workspace.selection_commands  # noqa: F401
-import kash.commands.workspace.workspace_commands  # noqa: F401
-import kash.local_server.local_server_commands  # noqa: F401
-import kash.mcp.mcp_server_commands  # noqa: F401
+from kash.exec.importing import import_and_register
+
+import_and_register(
+    __package__,
+    Path(__file__).parent,
+    ["base", "extras", "help", "workspace"],
+)

kash/commands/base/basic_file_commands.py

@@ -7,6 +7,7 @@ from strif import copyfile_atomic
 from kash.config.logger import get_logger
 from kash.config.text_styles import STYLE_EMPH
 from kash.exec import assemble_path_args, kash_command, resolve_path_arg
+from kash.model.paths_model import StorePath
 from kash.shell.output.shell_output import (
     PadStyle,
     PrintHooks,
@@ -21,6 +22,7 @@ from kash.utils.common.format_utils import fmt_loc
 from kash.utils.errors import InvalidInput
 from kash.utils.file_utils.file_formats_model import detect_file_format
 from kash.workspaces.workspace_output import print_file_info
+from kash.workspaces.workspaces import current_ws
 
 log = get_logger(__name__)
 
@@ -149,7 +151,20 @@ def trash(*paths: str) -> None:
     """
 
     resolved_paths = assemble_path_args(*paths)
+
+    ws = current_ws()
+    affected_store_paths = [
+        p for p in resolved_paths if isinstance(p, StorePath) and (ws.base_dir / p).exists()
+    ]
+
     native_trash(*resolved_paths)
+
+    if affected_store_paths:
+        log.info(
+            "Refreshing current selection due to deleted store paths: %s", affected_store_paths
+        )
+        ws.selections.refresh_current(ws.base_dir)
+
     print_status(f"Deleted (check trash or recycling bin to recover):\n{fmt_lines(resolved_paths)}")
 
 

kash/commands/base/debug_commands.py

@@ -179,7 +179,7 @@ def reload_system() -> None:
     the local the local server. Not perfect! But sometimes useful for development.
     """
     import kash
-    from kash.local_server.local_server import restart_local_server
+    from kash.local_server.local_server import restart_ui_server
     from kash.utils.common.import_utils import recursive_reload
 
     module = kash
@@ -197,7 +197,7 @@ def reload_system() -> None:
     log.info("Reloaded modules: %s", ", ".join(package_names))
     log.message("Reloaded %s modules from %s.", len(package_names), module.__name__)
 
-    restart_local_server()
+    restart_ui_server()
 
     # TODO Re-register commands and actions.
 
@@ -213,3 +213,16 @@ def reload_commands_and_actions() -> None:
 
     reload_shell_commands_and_actions()
     log_command_action_info()
+
+
+@kash_command
+def debug_exception() -> None:
+    """
+    Useful to debug exception handling/printing in xonsh.
+    """
+
+    def raise_exception():
+        cprint("Raising an unexpected exception to test the exception handler.")
+        raise Exception("This is a test exception.")
+
+    raise_exception()

kash/commands/base/general_commands.py

@@ -1,7 +1,15 @@
+from clideps.env_vars.dotenv_setup import interactive_dotenv_setup
+from clideps.env_vars.dotenv_utils import load_dotenv_paths
+from clideps.env_vars.env_check import format_dotenv_check, format_env_var_check, print_env_check
+from clideps.env_vars.env_names import get_all_common_env_names
+from clideps.pkgs.pkg_check import pkg_check
+from clideps.terminal.terminal_features import terminal_check
+from flowmark import Wrap
+from rich.text import Text
+
 from kash.commands.base.model_commands import list_apis, list_models
-from kash.commands.workspace.workspace_commands import list_params
 from kash.config.logger import get_logger
-from kash.config.settings import RECOMMENDED_API_KEYS
+from kash.config.settings import RECOMMENDED_API_KEYS, global_settings
 from kash.docs.all_docs import all_docs
 from kash.exec import kash_command
 from kash.help.tldr_help import tldr_refresh_cache
@@ -12,14 +20,6 @@ from kash.model.params_model import (
     DEFAULT_STANDARD_LLM,
     DEFAULT_STRUCTURED_LLM,
 )
-from kash.shell.clideps.api_keys import (
-    ApiEnvKey,
-    load_dotenv_paths,
-    print_api_key_setup,
-)
-from kash.shell.clideps.dotenv_setup import interactive_dotenv_setup
-from kash.shell.clideps.pkg_deps import pkg_check
-from kash.shell.clideps.terminal_features import terminal_check
 from kash.shell.input.input_prompts import input_choice
 from kash.shell.output.shell_formatting import format_name_and_value
 from kash.shell.output.shell_output import (
@@ -48,8 +48,13 @@ def self_check(brief: bool = False) -> None:
     Self-check kash setup, including termal settings, tools, and API keys.
     """
     if brief:
-        terminal_check().print_term_info()
-        print_api_key_setup(recommended_keys=RECOMMENDED_API_KEYS, once=False)
+        cprint(terminal_check().formatted())
+        cprint(Text.assemble("Dotenv files: ", format_dotenv_check()))
+        cprint(
+            Text.assemble(
+                "Env vars: ", format_env_var_check(env_vars=RECOMMENDED_API_KEYS, one_line=True)
+            )
+        )
         check_system_tools(brief=brief)
         tldr_refresh_cache()
         try:
@@ -61,7 +66,7 @@ def self_check(brief: bool = False) -> None:
     else:
         version()
         cprint()
-        terminal_check().print_term_info()
+        cprint(terminal_check().formatted())
         cprint()
         list_apis()
         cprint()
@@ -86,9 +91,10 @@ def self_configure(all: bool = False, update: bool = False) -> None:
     """
     Interactively configure API keys and preferred models.
     """
+    from kash.commands.workspace.workspace_commands import params as list_params
 
     if all:
-        api_keys = [key.value for key in ApiEnvKey]
+        api_keys = list(set(get_all_common_env_names() + RECOMMENDED_API_KEYS))
     else:
         api_keys = RECOMMENDED_API_KEYS
     # Show APIs before starting.
@@ -175,10 +181,11 @@ def reload_env() -> None:
     Reload the environment variables from the .env file.
     """
 
-    env_paths = load_dotenv_paths()
+    env_paths = load_dotenv_paths(True, True, global_settings().system_config_dir)
     if env_paths:
         cprint("Reloaded environment variables")
-        print_api_key_setup(RECOMMENDED_API_KEYS)
+
+        print_env_check(RECOMMENDED_API_KEYS)
     else:
         raise InvalidState("No .env file found")
 
@@ -197,7 +204,9 @@ def kits() -> None:
     else:
         cprint("Currently imported kits:")
         for kit in get_loaded_kits().values():
-            cprint(format_name_and_value(f"{kit.name} kit", str(kit.path or "")))
+            cprint(
+                format_name_and_value(f"{kit.name} kit", str(kit.path or ""), text_wrap=Wrap.NONE)
+            )
 
 
 @kash_command
@@ -210,5 +219,5 @@ def settings() -> None:
     settings = global_settings()
     print_h2("Global Settings")
     for field, value in settings.__dict__.items():
-        cprint(format_name_and_value(field, str(value)))
+        cprint(format_name_and_value(field, str(value), text_wrap=Wrap.NONE))
     PrintHooks.spacer()

kash/commands/base/logs_commands.py

@@ -8,7 +8,6 @@ from kash.config.settings import (
     LogLevel,
     atomic_global_settings,
     global_settings,
-    server_log_file_path,
 )
 from kash.exec import kash_command
 from kash.shell.output.shell_formatting import format_name_and_value
@@ -87,7 +86,5 @@ def log_settings() -> None:
     cprint(format_name_and_value("log_file_level", settings.log_file_level.name))
     cprint(format_name_and_value("log_console_level", settings.log_console_level.name))
     cprint(
-        format_name_and_value(
-            "server_log_file", str(server_log_file_path(global_settings().local_server_port))
-        )
+        format_name_and_value("server_log_file_path", str(global_settings().local_server_log_path))
     )

kash/commands/base/model_commands.py

@@ -1,10 +1,10 @@
+from clideps.env_vars.dotenv_utils import env_var_is_set
 from flowmark import Wrap
 from rich.text import Text
 
+from kash.config.settings import get_all_common_api_env_vars
 from kash.exec.command_registry import kash_command
 from kash.llm_utils import LLM, api_for_model
-from kash.shell.clideps.api_keys import ApiEnvKey
-from kash.shell.clideps.dotenv_utils import env_var_is_set
 from kash.shell.output.shell_formatting import (
     format_failure,
     format_name_and_value,
@@ -48,11 +48,11 @@ def list_apis() -> None:
     List and check configuration for all APIs.
     """
     print_h2("API keys")
-    for api in ApiEnvKey:
-        emoji = format_success_emoji(env_var_is_set(api.value))
+    for env_var in get_all_common_api_env_vars():
+        emoji = format_success_emoji(env_var_is_set(env_var))
         message = (
-            f"API key {api.value} found"
-            if env_var_is_set(api.value)
-            else f"API key {api.value} not found"
+            f"API key {env_var} found"
+            if env_var_is_set(env_var)
+            else f"API key {env_var} not found"
         )
-        cprint(Text.assemble(emoji, format_name_and_value(api.name, message)))
+        cprint(Text.assemble(emoji, format_name_and_value(env_var, message)))

kash/commands/base/search_command.py

@@ -1,9 +1,10 @@
 from pathlib import Path
 
+from clideps.pkgs.pkg_check import pkg_check
+
 from kash.config.logger import get_logger
 from kash.exec import assemble_path_args, kash_command
 from kash.exec_model.shell_model import ShellResult
-from kash.shell.clideps.pkg_deps import Pkg, pkg_check
 from kash.shell.output.shell_output import cprint
 from kash.utils.common.parse_shell_args import shell_quote
 from kash.utils.errors import InvalidState
@@ -33,7 +34,7 @@ def search(
     :param ignore_case: Ignore case when searching.
     :param verbose: Also print the ripgrep command line.
     """
-    pkg_check().require(Pkg.ripgrep)
+    pkg_check().require("ripgrep")
     from ripgrepy import RipGrepNotFound, Ripgrepy
 
     resolved_paths = assemble_path_args(*paths)

kash/commands/base/show_command.py

@@ -18,6 +18,7 @@ def show(
     native: bool = False,
     thumbnail: bool = False,
     browser: bool = False,
+    plain: bool = False,
 ) -> None:
     """
     Show the contents of a file if one is given, or the first file if multiple files
@@ -31,10 +32,11 @@ def show(
     :param native: Force display with a native app (depending on your system configuration).
     :param thumbnail: If there is a thumbnail image, show it too.
     :param browser: Force display with your default web browser.
+    :param plain: Use plain view in the console (this is `bat`'s `plain` style).
     """
     view_mode = (
         ViewMode.console
-        if console
+        if console or plain
         else ViewMode.browser
         if browser
         else ViewMode.native
@@ -58,9 +60,9 @@ def show(
                         log.info("Had trouble showing thumbnail image (will skip): %s", e)
                         cprint(f"[Image: {item.thumbnail_url}]", style=STYLE_HINT)
 
-            view_file_native(ws.base_dir / input_path, view_mode=view_mode)
+            view_file_native(ws.base_dir / input_path, view_mode=view_mode, plain=plain)
         else:
-            view_file_native(input_path, view_mode=view_mode)
+            view_file_native(input_path, view_mode=view_mode, plain=plain)
     except (InvalidInput, InvalidState):
         if path:
             # If path is absolute or we couldbn't get a selection, just show the file.

kash/commands/extras/parse_uv_lock.py

@@ -0,0 +1,186 @@
+import subprocess
+import tomllib
+from pathlib import Path
+
+import pandas as pd
+from packaging.tags import Tag, sys_tags
+from packaging.utils import parse_wheel_filename
+from prettyfmt import fmt_size_dual
+from strif import atomic_output_file
+
+from kash.config.logger import get_logger
+from kash.config.text_styles import COLOR_STATUS
+from kash.exec import kash_command
+from kash.shell.output.shell_output import cprint
+
+log = get_logger(__name__)
+
+
+def choose_wheel(wheels: list[dict], allowed: list[Tag]) -> dict | None:
+    """
+    Pick the first wheel whose tag set intersects `allowed`
+    (highest priority wins).
+    """
+    priority = {tag: idx for idx, tag in enumerate(allowed)}
+    best: dict | None = None
+    best_rank = float("inf")
+
+    for meta in wheels:
+        url = meta.get("url", "")
+        filename = Path(url).name if url else ""
+        if not filename:
+            raise ValueError(f"No filename found for {url}")
+        tags = parse_wheel_filename(filename)[-1]
+
+        for tag in tags:
+            rank = priority.get(tag)
+            if rank is not None and rank < best_rank:
+                best = meta
+                best_rank = rank
+                break
+
+    return best
+
+
+def get_platform() -> str:
+    """
+    Get the most-specific platform tag your interpreter supports.
+    """
+    return next(sys_tags()).platform
+
+
+def parse_uv_lock(lock_path: Path) -> pd.DataFrame:
+    """
+    Return one row per package from a uv.lock file, selecting the best
+    matching wheel for the current interpreter or falling back to the sdist.
+
+    Columns: name, version, registry, file_type, url, hash, size, filename.
+    """
+    with open(lock_path, "rb") as f:
+        data = tomllib.load(f)
+
+    rows: list[dict] = []
+    for pkg in data.get("package", []):
+        name = pkg.get("name")
+        version = pkg.get("version")
+        registry = pkg.get("source", {}).get("registry")
+
+        wheels = pkg.get("wheels", [])
+        selected = choose_wheel(wheels, list(sys_tags()))
+        if selected:
+            meta = selected
+            file_type = "wheel"
+        else:
+            meta = pkg.get("sdist", {})
+            file_type = "sdist"
+
+        url = meta.get("url")
+        rows.append(
+            {
+                "name": name,
+                "version": version,
+                "registry": registry,
+                "file_type": file_type,
+                "url": url,
+                "hash": meta.get("hash"),
+                "size": meta.get("size"),
+                "filename": Path(url).name if url else None,
+            }
+        )
+
+    return pd.DataFrame(rows)
+
+
+def uv_runtime_packages(
+    project_dir: str | Path = ".", no_dev: bool = False, uv_executable: str = "uv"
+) -> list[str]:
+    """
+    Return the *runtime* (non-dev) package names that would be installed for the
+    given project, as resolved by uv.
+    """
+    cmd = [
+        uv_executable,
+        "export",
+        "--format",
+        "requirements-txt",
+        "--no-header",
+        "--no-annotate",
+        "--no-hashes",
+    ]
+    if no_dev:
+        cmd.append("--no-dev")
+
+    result = subprocess.run(
+        cmd,
+        cwd=Path(project_dir),
+        check=True,
+        text=True,
+        capture_output=True,
+    )
+
+    packages: list[str] = []
+    for line in result.stdout.splitlines():
+        line = line.strip()
+        if "==" not in line:  # skip “-e .” and blank lines
+            continue
+        pkg_name, _ = line.split("==", maxsplit=1)
+        packages.append(pkg_name.strip())
+
+    return packages
+
+
+@kash_command
+def uv_dep_info(
+    uv_lock: str = "uv.lock",
+    pyproject: str = "pyproject.toml",
+    save: str | None = None,
+    sort_by: str = "size",
+) -> None:
+    """
+    Parse a uv.lock file and print information about the packages.
+    By default, filters to show only 'main' dependencies from pyproject.toml.
+    Helpful for looking at sizes of dependencies.
+    """
+    uv_lock_path = Path(uv_lock)
+    pyproject_path = Path(pyproject)
+
+    main_deps: list[str] | None = None
+    all_deps: list[str] = []
+    if pyproject_path.exists():
+        cprint("Reading main dependencies from with uv", style=COLOR_STATUS)
+        main_deps = uv_runtime_packages(no_dev=True)
+        all_deps = uv_runtime_packages(no_dev=False)
+    else:
+        log.warning("pyproject.toml not found: %s", pyproject_path)
+
+    cprint(f"Parsing lock file: {uv_lock_path}", style=COLOR_STATUS)
+
+    df = parse_uv_lock(uv_lock_path)
+    df = df.sort_values(by=sort_by)
+
+    if main_deps:
+        cprint(
+            f"Filtering lock file entries to include only {len(main_deps)} of {len(all_deps)} dependencies.",
+            style=COLOR_STATUS,
+        )
+        df = df[df["name"].isin(main_deps)]
+    else:
+        cprint("Showing all packages from lock file.", style=COLOR_STATUS)
+    cprint()
+
+    # Show only selected columns and full output
+    cols = ["name", "version", "file_type", "size", "filename"]
+    print(df.loc[:, cols].to_string(max_rows=None))
+    cprint()  # Add a newline for separation
+
+    # Calculate and print summary stats
+    num_deps = len(df)
+    total_size = pd.Series(pd.to_numeric(df["size"], errors="coerce")).fillna(0).sum()
+
+    cprint(f"Packages listed: {num_deps}", style=COLOR_STATUS)
+    cprint(f"Total size: {fmt_size_dual(int(total_size))}", style=COLOR_STATUS)
+
+    if save:
+        with atomic_output_file(save) as temp_name:
+            df.to_csv(temp_name, index=False)  # Added index=False for cleaner CSV
+        cprint(f"Saved to {save}", style=COLOR_STATUS)

kash/commands/help/doc_commands.py

@@ -1,42 +1,13 @@
-from rich.box import SQUARE
-from rich.console import Group
-from rich.panel import Panel
-
-from kash.commands.help.logo import branded_box
+from kash.commands.help.welcome import welcome
 from kash.config.logger import get_logger
-from kash.config.text_styles import (
-    COLOR_HINT,
-)
 from kash.docs.all_docs import DocSelection, all_docs
 from kash.exec import kash_command
 from kash.help.help_pages import print_see_also
-from kash.shell.output.shell_output import PrintHooks, console_pager, cprint, print_markdown
-from kash.shell.version import get_full_version_name
-from kash.utils.rich_custom.rich_markdown_fork import Markdown
+from kash.shell.output.shell_output import console_pager, print_markdown
 
 log = get_logger(__name__)
 
 
-@kash_command
-def welcome() -> None:
-    """
-    Print a welcome message.
-    """
-
-    help_topics = all_docs.help_topics
-    version = get_full_version_name()
-    # Create header with logo and right-justified version
-
-    PrintHooks.before_welcome()
-    cprint(
-        branded_box(
-            Group(Markdown(help_topics.welcome)),
-            version,
-        )
-    )
-    cprint(Panel(Markdown(help_topics.warning), box=SQUARE, border_style=COLOR_HINT))
-
-
 @kash_command
 def manual(no_pager: bool = False, doc_selection: DocSelection = DocSelection.full) -> None:
     """