kash-shell 0.3.25__py3-none-any.whl → 0.3.27__py3-none-any.whl

kash/exec/shell_callable_action.py

@@ -1,8 +1,9 @@
 from funlog import log_tallies
 
 from kash.config.env_settings import KashEnv
-from kash.config.logger import get_console, get_logger
-from kash.config.text_styles import COLOR_ERROR, SPINNER
+from kash.config.logger import get_logger
+from kash.config.text_styles import COLOR_ERROR
+from kash.config.unified_live import get_unified_live
 from kash.exec.action_exec import run_action_with_shell_context
 from kash.exec.history import record_command
 from kash.exec_model.commands_model import Command
@@ -57,7 +58,7 @@ class ShellCallableAction:
             log.info("Action shell args: %s", shell_args)
             explicit_values = RawParamValues(shell_args.options)
             if not action.interactive_input and not action.live_output:
-                with get_console().status(f"Running action {action.name}…", spinner=SPINNER):
+                with get_unified_live().status(f"Running action {action.name}…"):
                     result = run_action_with_shell_context(
                         action_cls,
                         explicit_values,

kash/help/help_embeddings.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing_extensions import override
 
 from kash.config.logger import get_logger
-from kash.embeddings.embeddings import Embeddings
+from kash.embeddings.embeddings import Embeddings, EmbValue, KeyVal
 from kash.embeddings.text_similarity import rank_by_relatedness
 from kash.help.help_types import HelpDoc, HelpDocType
 from kash.web_content.local_file_cache import Loadable
@@ -59,7 +59,10 @@ class HelpIndex:
         from kash.web_content.file_cache_utils import cache_file
 
         def calculate_and_save_help_embeddings(target_path: Path) -> None:
-            keyvals = [(str(key), doc.embedding_text()) for key, doc in self._docs_by_key()]
+            keyvals = [
+                KeyVal(key=str(key), value=EmbValue(emb_text=doc.embedding_text()))
+                for key, doc in self._docs_by_key()
+            ]
             embeddings = Embeddings.embed(keyvals)
             log.info("Embedded %d help documents, cached at: %s", len(embeddings.data), target_path)
             embeddings.to_npz(target_path)

kash/mcp/mcp_server_sse.py

@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING
 
 from mcp.server.sse import SseServerTransport
 from prettyfmt import fmt_path
-from sse_starlette.sse import AppStatus
 from starlette.applications import Starlette
 from starlette.routing import Mount, Route
 
@@ -72,10 +71,6 @@ class MCPServerSSE:
     def _setup_server(self):
         import uvicorn
 
-        # Reset AppStatus.should_exit_event to None to ensure it's created
-        # in the correct event loop when needed.
-        AppStatus.should_exit_event = None
-
         port = global_settings().mcp_server_port
 
         # Check if the port is available.

kash/model/graph_model.py

@@ -1,5 +1,6 @@
 from collections.abc import Iterable
 from dataclasses import asdict, field
+from typing import Any
 
 from pydantic.dataclasses import dataclass
 from strif import abbrev_list
@@ -18,6 +19,7 @@ class Node:
     body: str | None = None
     url: str | None = None
     thumbnail_url: str | None = None
+    data: dict[str, Any] | None = None
 
 
 @dataclass(frozen=True)

kash/model/items_model.py

@@ -263,7 +263,7 @@ class Item:
     thumbnail_url: Url | None = None
 
     # Optional additional metadata.
-    extra: dict | None = None
+    extra: dict[str, Any] | None = None
 
     # Optional execution context. Useful for letting functions that take only an Item
     # arg get access to context.
@@ -935,8 +935,8 @@ class Item:
                     "type": 64,
                     "format": 64,
                     "title": 40,
-                    "url": 64,
-                    "external_path": 64,
+                    "url": 128,
+                    "external_path": 0,
                 },
             )
             + f"[{len(self.body) if self.body else 0} body chars]"
@@ -961,7 +961,7 @@ class Item:
             + f"[{len(self.body) if self.body else 0} body chars]"
         )
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self.as_str_brief()
 
 

kash/shell/output/shell_output.py

@@ -86,8 +86,8 @@ def multitask_status(
 ) -> MultiTaskStatus | nullcontext:
     """
     Create a `MultiTaskStatus` context manager for displaying multiple task progress
-    using the global shell console. If disabled, returns a null context, so it's convenient
-    to disable status display.
+    using the global shell console with live display conflict prevention. If disabled,
+    returns a null context, so it's convenient to disable status display.
     """
     if not enabled:
         return nullcontext()

kash/shell/shell_main.py

@@ -1,5 +1,5 @@
 """
-Welcome to kash! Main way to run the kash shell.
+Welcome to Kash! This command is the main way to run the kash shell.
 
 Usually this is used to start the kash interactively but you can also pass a single
 command to run non-interactively.
@@ -13,16 +13,16 @@ More information at: github.com/jlevy/kash
 import argparse
 import threading
 
-import xonsh.main
-from clideps.utils.readable_argparse import ReadableColorFormatter
 from strif import quote_if_needed
 
+from kash.config.logger import get_console, get_logger
 from kash.config.setup import kash_setup
 from kash.shell.version import get_full_version_name, get_version
-from kash.xonsh_custom.custom_shell import install_to_xonshrc, start_shell
 
 kash_setup(rich_logging=True)  # Set up logging first.
 
+log = get_logger(__name__)
+
 
 __version__ = get_version()
 
@@ -35,6 +35,10 @@ def run_plain_xonsh():
     xontrib only (in ~/.xonshrc), but the full customizations of prompts, tab
     completion, etc are not available.
     """
+    import xonsh.main
+
+    from kash.xonsh_custom.custom_shell import install_to_xonshrc
+
     install_to_xonshrc()
     xonsh.main.main()
 
@@ -42,25 +46,77 @@ def run_plain_xonsh():
 # Event to monitor loading.
 shell_ready_event = threading.Event()
 
+imports_done_event = threading.Event()
+
 
 def run_shell(single_command: str | None = None):
     """
     Run the kash shell interactively or non-interactively with a single command.
     """
+    from kash.xonsh_custom.custom_shell import start_shell
+
     start_shell(single_command, shell_ready_event)
 
 
 def build_parser() -> argparse.ArgumentParser:
+    from clideps.utils.readable_argparse import ReadableColorFormatter
+
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=ReadableColorFormatter)
 
-    parser.add_argument("--version", action="version", version=get_full_version_name())
+    # Don't call get_full_version_name() here, as it's slow.
+    parser.add_argument("--version", action="store_true", help="show version and exit")
 
     return parser
 
 
+def _import_packages():
+    try:
+        # Slowest packages:
+        import uvicorn.protocols  # noqa: F401
+        import uvicorn.protocols.http.h11_impl  # noqa: F401
+        import uvicorn.protocols.websockets.websockets_impl  # noqa: F401
+        import xonsh.completers.init  # noqa: F401
+        import xonsh.pyghooks  # noqa: F401
+
+        import kash.actions  # noqa: F401
+        import kash.local_server  # noqa: F401
+        import kash.local_server.local_server  # noqa: F401
+        import kash.mcp.mcp_server_sse  # noqa: F401
+    except ImportError as e:
+        log.warning(f"Error pre-importing packages: {e}")
+
+    imports_done_event.set()
+
+
+def import_with_status_if_slow(min_time: float = 1.0):
+    """
+    Not required, but imports can be remarkably slow the first time, so this shows a status message.
+    """
+
+    # Start imports in background thread
+    import_thread = threading.Thread(target=_import_packages, daemon=True)
+    import_thread.start()
+
+    # Wait for imports to complete, with a short timeout
+    if not imports_done_event.wait(timeout=min_time):
+        # If imports aren't done quickly, show status message
+        if get_console().is_terminal:
+            with get_console().status(
+                "Importing packages (this is a bit slow the first time) …", spinner="line"
+            ):
+                import_thread.join()
+    else:
+        import_thread.join()
+
+
 def main():
     parser = build_parser()
-    _args, unknown = parser.parse_known_args()
+
+    args, unknown = parser.parse_known_args()
+
+    if args.version:
+        print(get_full_version_name(with_kits=True))
+        return
 
     # Join remaining arguments to pass as a single command to kash.
     # Use Python-style quoting only if needed for xonsh.
@@ -68,6 +124,8 @@ def main():
     if unknown:
         single_command = " ".join(quote_if_needed(arg) for arg in unknown)
 
+    import_with_status_if_slow()
+
     run_shell(single_command)
 
 

kash/shell/version.py

@@ -28,8 +28,24 @@ def get_version_tag():
     return f"v{get_version()}"
 
 
-def get_full_version_name():
-    return f"{PACKAGE_NAME} {get_version_tag()}"
+def get_full_version_name(with_kits: bool = False):
+    """
+    Get the full version name, including the version number and any loaded kits.
+
+    If `with_kits` is True, will also import `kash.kits` packages and get those versions,
+    but be careful as this can be much slower due to imports!
+    """
+
+    version_items = [f"{PACKAGE_NAME} {get_version_tag()}"]
+    if with_kits:
+        from kash.actions import get_loaded_kits
+
+        kits = get_loaded_kits()
+        for kit in kits.values():
+            if kit.version:
+                version_items.append(f"{kit.distribution_name} v{kit.version}")
+
+    return ", ".join(version_items)
 
 
 if __name__ == "__main__":

kash/utils/file_utils/csv_utils.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+from typing import NamedTuple
+
+
+class CsvMetadata(NamedTuple):
+    """
+    Result of CSV analysis, containing skip rows, metadata, and dialect.
+    """
+
+    skip_rows: int
+    metadata: dict[str, str]
+    dialect: type[csv.Dialect]
+
+
+def sniff_csv_metadata(
+    file_path: Path,
+    *,
+    max_scan_lines: int = 500,
+    threshold_ratio: float = 0.8,
+    min_columns: int = 3,
+    sample_size: int = 32768,
+) -> CsvMetadata:
+    """
+    Detect CSV metadata and where the table data starts by finding the first row that looks
+    like proper headers.
+
+    This function handles various CSV formats:
+    - Normal CSV files: returns skip_rows=0 (no rows to skip)
+    - Files with metadata: detects the first row with multiple columns that looks like headers
+    - Survey exports: handles key-value metadata followed by proper CSV structure
+
+    Args:
+        file_path: Path to the CSV file to analyze
+        max_scan_lines: Maximum number of lines to scan before giving up
+        threshold_ratio: Minimum ratio of max columns a row must have to be considered headers
+        min_columns: Minimum number of columns required to be considered headers
+        sample_size: Number of bytes to read for dialect detection
+
+    Returns:
+        CsvMetadata with skip_rows, metadata dict, and detected dialect
+    """
+    # Read sample for dialect detection
+    sample_text = file_path.read_text(encoding="utf-8", errors="replace")[:sample_size]
+
+    # Detect CSV dialect
+    try:
+        dialect = csv.Sniffer().sniff(sample_text)
+    except csv.Error:
+        # Fall back to default dialect if detection fails
+        dialect = csv.excel
+
+    # Analyze file structure
+    with open(file_path, encoding="utf-8", errors="replace") as file:
+        reader = csv.reader(file, dialect=dialect)
+
+        max_columns = 0
+        header_candidates = []
+        metadata = {}
+
+        for line_num, row in enumerate(reader):
+            # Stop scanning if we've looked at too many lines
+            if line_num >= max_scan_lines:
+                break
+
+            # Skip completely empty rows
+            non_empty_cells = [cell.strip() for cell in row if cell.strip()]
+            if not non_empty_cells:
+                continue
+
+            column_count = len(non_empty_cells)
+
+            # Track the maximum number of columns seen
+            if column_count > max_columns:
+                max_columns = column_count
+
+            # Collect potential key-value metadata (exactly 2 columns)
+            # Only collect metadata before we find any header candidates with min_columns
+            if column_count == 2 and not any(hc[1] >= min_columns for hc in header_candidates):
+                key, value = non_empty_cells[0], non_empty_cells[1]
+                # Simple heuristic: if it looks like a key-value pair, store it
+                if not key.isdigit() and not value.replace(".", "").replace(",", "").isdigit():
+                    metadata[key] = value
+
+            # Consider this a potential header if it has minimum required columns
+            if column_count >= min_columns:
+                header_candidates.append((line_num, column_count, row))
+
+    # If no multi-column rows found, assume it's a normal CSV starting at line 0
+    if not header_candidates:
+        return CsvMetadata(skip_rows=0, metadata=metadata, dialect=dialect)
+
+    # Look for the first row that has close to the maximum number of columns
+    # This helps distinguish metadata (usually fewer columns) from real headers (many columns)
+    threshold = max(min_columns, max_columns * threshold_ratio)
+
+    for line_num, column_count, _row in header_candidates:
+        if column_count >= threshold:
+            return CsvMetadata(skip_rows=line_num, metadata=metadata, dialect=dialect)
+
+    # If no clear header found but we have candidates, return the first multi-column row
+    first_candidate_line = header_candidates[0][0]
+    return CsvMetadata(skip_rows=first_candidate_line, metadata=metadata, dialect=dialect)

kash/utils/rich_custom/multitask_status.py

@@ -4,7 +4,7 @@ import asyncio
 from contextlib import AbstractAsyncContextManager
 from dataclasses import dataclass
 from types import TracebackType
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from strif import abbrev_str, single_line
 from typing_extensions import override
@@ -17,6 +17,7 @@ from rich.progress import BarColumn, Progress, ProgressColumn, Task, TaskID
 from rich.spinner import Spinner
 from rich.text import Text
 
+from kash.config.unified_live import get_unified_live
 from kash.utils.api_utils.progress_protocol import (
     EMOJI_FAILURE,
     EMOJI_RETRY,
@@ -229,7 +230,7 @@ class TruncatedLabelColumn(ProgressColumn):
     def __init__(self, console_width: int):
         super().__init__()
         # Reserve half the console width for labels/status messages
-        self.max_label_width = console_width // 2
+        self.max_label_width: int = console_width // 2
 
     @override
     def render(self, task: Task) -> Text:
@@ -298,6 +299,9 @@ class MultiTaskStatus(AbstractAsyncContextManager):
         self._next_id: int = 1
         self._rich_task_ids: dict[int, TaskID] = {}  # Map our IDs to Rich Progress IDs
 
+        # Unified live integration
+        self._unified_live: Any | None = None  # Reference to the global unified live
+
         # Calculate spinner width for consistent spacing
         self._spinner_width = _get_spinner_width(SPINNER_NAME)
 
@@ -367,7 +371,13 @@ class MultiTaskStatus(AbstractAsyncContextManager):
     @override
     async def __aenter__(self) -> MultiTaskStatus:
         """Start the live display."""
-        self._progress.__enter__()
+        # Try to integrate with unified live display
+
+        # Always integrate with unified live display (auto-initialized)
+        unified_live = get_unified_live()
+        self._unified_live = unified_live
+        # Register our progress display with the unified live
+        unified_live.set_multitask_display(self._progress)
         return self
 
     @override
@@ -378,9 +388,13 @@ class MultiTaskStatus(AbstractAsyncContextManager):
         exc_tb: TracebackType | None,
     ) -> None:
         """Stop the live display and show automatic summary if enabled."""
-        self._progress.__exit__(exc_type, exc_val, exc_tb)
+        # Always clean up unified live integration
+        if self._unified_live is not None:
+            # Remove our display from the unified live
+            self._unified_live.set_multitask_display(None)
+            self._unified_live = None
 
-        # Show automatic summary if enabled
+        # Show automatic summary if enabled (always print to console now)
         if self.auto_summary:
             summary = self.get_summary()
             self.console.print(summary)