kash-shell 0.3.24__py3-none-any.whl → 0.3.26__py3-none-any.whl

kash/model/params_model.py

@@ -209,7 +209,7 @@ A list of parameter declarations, possibly with default values.
 DEFAULT_CAREFUL_LLM = LLM.o3
 DEFAULT_STRUCTURED_LLM = LLM.gpt_4o
 DEFAULT_STANDARD_LLM = LLM.claude_4_sonnet
-DEFAULT_FAST_LLM = LLM.o1_mini
+DEFAULT_FAST_LLM = LLM.gpt_4o
 
 
 # Parameters set globally such as in the workspace.

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/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)

kash/utils/text_handling/doc_normalization.py

@@ -21,6 +21,7 @@ def normalize_formatting(
     format: Format | None,
     support_ansi: bool = True,
     cleanups: bool = True,
+    smartquotes: bool = True,
 ) -> str:
     """
     Normalize formatting. Currently only normalizes Markdown and leaves plaintext
@@ -35,6 +36,7 @@ def normalize_formatting(
             text,
             line_wrapper=line_wrap_by_sentence(len_fn=len_fn, is_markdown=True),
             cleanups=cleanups,
+            smartquotes=smartquotes,
         )
     elif format == Format.plaintext:
         # Consider plaintext a raw format and don't normalize.