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

kash/actions/__init__.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from importlib import metadata
 from pathlib import Path
 
 from strif import AtomicVar
@@ -15,9 +16,11 @@ import_and_register(__package__, Path(__file__).parent, ["core", "meta"])
 
 @dataclass(frozen=True)
 class Kit:
-    name: str
+    module_name: str
+    distribution_name: str
     full_module_name: str
     path: Path | None
+    version: str | None = None
 
 
 _kits: AtomicVar[dict[str, Kit]] = AtomicVar(initial_value={})
@@ -30,6 +33,44 @@ def get_loaded_kits() -> dict[str, Kit]:
     return _kits.copy()
 
 
+def get_kit_distribution_name(module_name: str) -> str | None:
+    """
+    Guess the distribution name for a kit module using naming conventions.
+    Assumes kits follow patterns like:
+    - kash.kits.example_kit -> kash-example-kit
+    """
+    if not module_name.startswith("kash.kits."):
+        return None
+
+    kit_name = module_name.removeprefix("kash.kits.")
+
+    # Try common naming patterns
+    candidates = [
+        f"kash-{kit_name}",
+        f"kash-{kit_name.replace('_', '-')}",
+    ]
+
+    for candidate in candidates:
+        try:
+            metadata.version(candidate)
+            return candidate
+        except metadata.PackageNotFoundError:
+            continue
+
+    return None
+
+
+def get_distribution_version(module_name: str) -> str | None:
+    """
+    Get the version of a module that can be used with `metadata.version()`.
+    """
+    try:
+        dist_name = get_kit_distribution_name(module_name)
+        return metadata.version(dist_name) if dist_name else None
+    except Exception:
+        return None
+
+
 def load_kits() -> dict[str, Kit]:
     """
     Import all kits (modules within `kash.kits`) by inspecting the namespace.
@@ -38,11 +79,15 @@ def load_kits() -> dict[str, Kit]:
     new_kits = {}
     try:
         imported = import_namespace_modules(kits_namespace)
-        for name, module in imported.items():
-            new_kits[name] = Kit(
-                name,
-                module.__name__,
-                Path(module.__file__) if module.__file__ else None,
+        for module_name, module in imported.items():
+            dist_name = get_kit_distribution_name(module.__name__) or module.__name__
+
+            new_kits[module_name] = Kit(
+                module_name=module_name,
+                distribution_name=dist_name,
+                full_module_name=module.__name__,
+                path=Path(module.__file__) if module.__file__ else None,
+                version=metadata.version(dist_name),
             )
     except ImportError:
         log.info("No kits found in namespace `%s`", kits_namespace)

kash/actions/core/minify_html.py

@@ -22,7 +22,7 @@ def minify_html(item: Item) -> Item:
     The terser minification seems a bit slower but more robust than
     [minify-html](https://github.com/wilsonzlin/minify-html).
     """
-    from minify_tw_html import minify_tw_html
+    from tminify.main import tminify
 
     if not item.store_path:
         raise InvalidInput(f"Missing store path: {item}")
@@ -33,7 +33,7 @@ def minify_html(item: Item) -> Item:
     output_item = item.derived_copy(format=Format.html, body=None)
     output_path = ws.target_path_for(output_item)
 
-    minify_tw_html(input_path, output_path)
+    tminify(input_path, output_path)
 
     output_item.body = output_path.read_text()
     output_item.external_path = str(output_path)  # Indicate item is already saved.

kash/commands/base/general_commands.py

@@ -39,7 +39,7 @@ def version() -> None:
     """
     Show the version of kash.
     """
-    cprint(get_full_version_name())
+    cprint(get_full_version_name(with_kits=True))
 
 
 @kash_command
@@ -205,7 +205,9 @@ def kits() -> None:
         cprint("Currently imported kits:")
         for kit in get_loaded_kits().values():
             cprint(
-                format_name_and_value(f"{kit.name} kit", str(kit.path or ""), text_wrap=Wrap.NONE)
+                format_name_and_value(
+                    f"{kit.distribution_name} kit", str(kit.path or ""), text_wrap=Wrap.NONE
+                )
             )
 
 

kash/commands/help/assistant_commands.py

@@ -1,7 +1,8 @@
 from kash.commands.base.basic_file_commands import trash
 from kash.commands.workspace.selection_commands import select
-from kash.config.logger import get_console, get_logger
-from kash.config.text_styles import PROMPT_ASSIST, SPINNER
+from kash.config.logger import get_logger
+from kash.config.text_styles import PROMPT_ASSIST
+from kash.config.unified_live import get_unified_live
 from kash.docs.all_docs import DocSelection
 from kash.exec import kash_command
 from kash.exec_model.shell_model import ShellResult
@@ -43,7 +44,7 @@ def assist(
             help()
             return
 
-    with get_console().status("Thinking…", spinner=SPINNER):  # noqa: F821
+    with get_unified_live().status("Thinking…"):
         shell_context_assistance(input, model=model, assistance_type=type)
 
 

kash/commands/help/welcome.py

@@ -31,4 +31,4 @@ def welcome() -> None:
         )
     )
     cprint(Panel(Markdown(help_topics.warning), box=SQUARE, border_style=COLOR_HINT))
-    cprint("%s", get_full_version_name())
+    cprint("%s", get_full_version_name(with_kits=True))

kash/config/colors.py

@@ -135,15 +135,17 @@ web_light_translucent = SimpleNamespace(
     secondary=hsl_to_hex("hsl(188, 12%, 28%)"),
     tertiary=hsl_to_hex("hsl(188, 7%, 64%)"),
     bg=hsl_to_hex("hsla(44, 6%, 100%, 0.75)"),
-    bg_solid=hsl_to_hex("hsla(44, 6%, 100%, 1)"),
+    bg_solid=hsl_to_hex("hsl(44, 6%, 100%)"),
     bg_header=hsl_to_hex("hsla(188, 42%, 70%, 0.2)"),
     bg_alt=hsl_to_hex("hsla(39, 24%, 90%, 0.3)"),
-    bg_alt_solid=hsl_to_hex("hsla(39, 24%, 97%, 1)"),
-    bg_meta_solid=hsl_to_hex("hsla(39, 24%, 94%, 1)"),
+    bg_alt_solid=hsl_to_hex("hsl(39, 24%, 97%)"),
+    bg_meta_solid=hsl_to_hex("hsl(39, 24%, 94%)"),
+    bg_strong_solid=hsl_to_hex("hsl(39, 8%, 90%)"),
     bg_selected=hsl_to_hex("hsla(188, 21%, 94%, 0.9)"),
     text=hsl_to_hex("hsl(188, 39%, 11%)"),
     code=hsl_to_hex("hsl(44, 38%, 23%)"),
     border=hsl_to_hex("hsl(188, 8%, 50%)"),
+    border_hairline=hsl_to_hex("hsl(188, 2%, 34%)"),
     border_hint=hsl_to_hex("hsla(188, 8%, 72%, 0.3)"),
     border_accent=hsl_to_hex("hsla(305, 18%, 65%, 0.85)"),
     hover=hsl_to_hex("hsl(188, 12%, 84%)"),
@@ -174,10 +176,12 @@ web_dark_translucent = SimpleNamespace(
     bg_alt=hsl_to_hex("hsla(220, 14%, 12%, 0.5)"),
     bg_alt_solid=hsl_to_hex("hsl(220, 15%, 16%)"),
     bg_meta_solid=hsl_to_hex("hsl(220, 14%, 25%)"),
+    bg_strong_solid=hsl_to_hex("hsl(220, 14%, 35%)"),
     bg_selected=hsl_to_hex("hsla(188, 13%, 33%, 0.95)"),
     text=hsl_to_hex("hsl(188, 10%, 90%)"),
     code=hsl_to_hex("hsl(44, 38%, 72%)"),
     border=hsl_to_hex("hsl(188, 8%, 25%)"),
+    border_hairline=hsl_to_hex("hsl(188, 2%, 80%)"),
     border_hint=hsl_to_hex("hsla(188, 8%, 35%, 0.3)"),
     border_accent=hsl_to_hex("hsla(305, 30%, 55%, 0.85)"),
     hover=hsl_to_hex("hsl(188, 12%, 35%)"),

kash/config/logger.py

@@ -170,6 +170,7 @@ def reset_rich_logging(
     the `.log` extension. If `log_path` is provided, it will be used to infer
     the log root and name.
     """
+    _init_rich_logging()
     if log_path:
         if not log_path.parent.exists():
             log_path.parent.mkdir(parents=True, exist_ok=True)
@@ -206,6 +207,9 @@ def reload_rich_logging_setup():
 
 @cache
 def _init_rich_logging():
+    """
+    One-time idempotent setup of rich logging.
+    """
     rich.reconfigure(theme=get_theme(), highlighter=get_highlighter())
 
     logging.setLoggerClass(CustomLogger)

kash/config/text_styles.py

@@ -57,6 +57,7 @@ COLOR_PLAIN = "default"
 COLOR_LINK = "cyan"
 COLOR_SUCCESS = "green"
 COLOR_FAILURE = "bright_red"
+COLOR_SPINNER = "bright_cyan"
 COLOR_WARN = "bright_red"
 COLOR_ERROR = "bright_red"
 COLOR_EXTRA = "bright_blue"

kash/config/unified_live.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+import atexit
+import threading
+from collections.abc import Generator
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+
+from rich.console import Console, Group, RenderableType
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.text import Text
+from strif import AtomicVar
+
+from kash.config.logger import get_console
+from kash.config.text_styles import COLOR_SPINNER, SPINNER
+
+
+@dataclass
+class LiveContent:
+    """
+    Container for different types of live-updating status content.
+    """
+
+    current_status: str | None = None  # Single current status message
+    multitask_display: RenderableType | None = None
+    custom_content: list[RenderableType] = field(default_factory=list)
+
+
+class UnifiedLive:
+    """
+    Unified live display manager that handles all Rich live content in a single Live container.
+
+    This eliminates Rich's one-live-display-at-a-time limitation by
+    providing a single Live that all other components render into.
+
+    Layout structure:
+    - Status message at the top (single spinner and message)
+    - MultiTask progress displays in the middle
+    - Custom live content at the bottom
+    """
+
+    def __init__(
+        self,
+        *,
+        console: Console | None = None,
+        transient: bool = True,
+        refresh_per_second: float = 10,
+    ):
+        self.console = console or get_console()
+        self._content = LiveContent()
+        self._live = Live(
+            console=self.console,
+            transient=transient,
+            refresh_per_second=refresh_per_second,
+        )
+        self._is_active = False
+        self._lock = threading.RLock()  # Thread safety for mutable state
+        self._usage_count = 0  # Track how many things are using this live display
+
+    def start(self) -> None:
+        """Start the unified live display."""
+        with self._lock:
+            if self._is_active:
+                return
+
+            try:
+                self._live.__enter__()
+                self._is_active = True
+                self._update_display()
+            except Exception:
+                # If starting fails, ensure we're in a clean state
+                self._is_active = False
+                raise
+
+    def stop(self) -> None:
+        """Stop the unified live display and restore terminal state."""
+        with self._lock:
+            if not self._is_active:
+                return
+
+            self._is_active = False
+            try:
+                self._live.__exit__(None, None, None)
+            except Exception:
+                # Always try to restore terminal state even if Live cleanup fails
+                pass
+            finally:
+                # Force terminal state restoration
+                try:
+                    # Ensure cursor is visible and terminal is in normal state
+                    self.console.show_cursor()
+                    if hasattr(self.console, "_buffer"):
+                        self.console._buffer.clear()
+                except Exception:
+                    pass
+
+    def _increment_usage(self) -> None:
+        """Increment usage counter (called when entering a context)."""
+        with self._lock:
+            self._usage_count += 1
+
+    def _decrement_usage(self) -> None:
+        """Decrement usage counter and stop if unused (called when exiting a context)."""
+        with self._lock:
+            self._usage_count = max(0, self._usage_count - 1)
+            # Auto-stop if nothing is using it and it has content that would be cleared anyway
+            if self._usage_count == 0 and self._content.current_status is None:
+                self.stop()
+
+    def set_status(self, message: str | None) -> None:
+        """Set the current status message (or None to clear it)."""
+        with self._lock:
+            self._content.current_status = message
+            self._update_display()
+
+    @contextmanager
+    def status(self, message: str, *, spinner: str = SPINNER) -> Generator[None, None, None]:  # pyright: ignore[reportUnusedParameter]
+        """
+        Context manager for showing a status message in this unified live display.
+
+        Args:
+            message: Status message to display
+            spinner: Spinner type (for future animation support)
+        """
+        self._increment_usage()
+        self.set_status(message)
+        try:
+            yield
+        finally:
+            self.set_status(None)
+            self._decrement_usage()
+
+    def set_multitask_display(self, display: RenderableType | None) -> None:
+        """Set the multitask progress display content."""
+        with self._lock:
+            self._content.multitask_display = display
+            self._update_display()
+
+    def add_custom_content(self, content: RenderableType) -> int:
+        """Add custom live content. Returns an ID for later removal."""
+        with self._lock:
+            self._content.custom_content.append(content)
+            self._update_display()
+            return len(self._content.custom_content) - 1
+
+    def remove_custom_content(self, content_id: int) -> None:
+        """Remove custom content by ID."""
+        with self._lock:
+            if 0 <= content_id < len(self._content.custom_content):
+                del self._content.custom_content[content_id]
+                self._update_display()
+
+    def _update_display(self) -> None:
+        """Update the live display with current content. Must be called with lock held."""
+        if not self._is_active:
+            return
+
+        renderables: list[RenderableType] = []
+
+        # Add multitask display at the top
+        if self._content.multitask_display is not None:
+            renderables.append(self._content.multitask_display)
+
+        # Add custom content in the middle
+        renderables.extend(self._content.custom_content)
+
+        # Add current status message with animated spinner at the bottom
+        if self._content.current_status is not None:
+            from rich.columns import Columns
+
+            spinner = Spinner(SPINNER, style=COLOR_SPINNER)
+            status_text = Text(self._content.current_status)
+
+            # Use Columns to display spinner and message side by side
+            status_line = Columns([spinner, status_text], padding=(0, 1))
+            renderables.append(status_line)
+
+        # Update the live display - use Group to stack vertically
+        if renderables:
+            self._live.update(Group(*renderables))
+        else:
+            # Show empty space if no content
+            self._live.update("")
+
+    @property
+    def is_active(self) -> bool:
+        """Check if this unified live is currently active."""
+        with self._lock:
+            return self._is_active
+
+
+# Global unified live instance, auto-initialized on first access (thread-safe)
+_global_unified_live = AtomicVar[UnifiedLive | None](None)
+
+
+def _cleanup_unified_live() -> None:
+    """Clean up the global unified live display on process exit."""
+    current = _global_unified_live.value
+    if current is not None:
+        current.stop()
+
+
+# Register cleanup handler for normal exit only
+atexit.register(_cleanup_unified_live)
+
+
+def get_unified_live() -> UnifiedLive:
+    """
+    Get the global unified live display, auto-initializing if needed.
+
+    Always returns a valid UnifiedLive instance. Creates and starts one
+    automatically if none exists yet. Thread-safe using AtomicVar.
+    """
+    with _global_unified_live.lock:
+        if not _global_unified_live:
+            live = UnifiedLive()
+            live.start()
+            _global_unified_live.set(live)
+
+    result = _global_unified_live.value
+    assert result
+    return result
+
+
+def has_unified_live() -> bool:
+    """Check if there's currently an active unified live display."""
+    current = _global_unified_live.value
+    return current is not None and current.is_active
+
+
+@contextmanager
+def unified_live_context(
+    console: Console | None = None,
+) -> Generator[UnifiedLive, None, None]:
+    """
+    Context manager for working with the unified live display.
+
+    Returns the global unified live instance, creating and starting it if needed.
+    The live display continues running after this context exits.
+    """
+    # Always return the global instance, creating if needed
+    live = get_unified_live()
+
+    # Update settings if this is a new instance
+    if console is not None:
+        live.console = console
+
+    yield live

kash/docs/markdown/assistant_instructions_template.md

@@ -5,7 +5,7 @@ organizing knowledge.
 Kash can be used as a shell, with access to common commands like `ps` and `cd`, but has
 far more capabilities and can generate and manipulate text documents, videos, and more.
 
-Kash is written in Python, runs on a user's own computer.
+Kash is written in Python, runs on a user’s own computer.
 It can connect to the web to download or read content or use LLM-based tools and APIs
 such as ones from OpenAI or Anthropic.
 It saves all content and state to files.
@@ -69,7 +69,7 @@ necessary.
 
 Always follow these guidelines:
 
-- If you're unsure of what command might help, simply say "I'm not sure how to help with
+- If you’re unsure of what command might help, simply say "I’m not sure how to help with
   that. Run `help` for more about kash.`" Suggest the user run `help` to get more
   information themselves.
 
@@ -81,7 +81,7 @@ Always follow these guidelines:
 
 - If there is more than one command that might be relevant, mention all the commands
   that might be of interest.
-  Don't repeatedly mention the same command.
+  Don’t repeatedly mention the same command.
   Be brief!
 
 - If they ask for a task that is not covered by the current set of actions, you may

kash/docs/markdown/topics/a1_what_is_kash.md

@@ -8,15 +8,15 @@ exploratory, and flexible using Python and current AI tools.
 
 The philosophy behind kash is similar to Unix shell tools: simple commands that can be
 combined in flexible and powerful ways.
-It operates on "items" such as URLs, files, or Markdown notes within a workspace
+It operates on “items” such as URLs, files, or Markdown notes within a workspace
 directory.
 
 You can use Kash as an **interactive, AI-native command-line** shell for practical
-knowledge tasks. It's also **a Python library** that lets you convert a simple Python
+knowledge tasks. It’s also **a Python library** that lets you convert a simple Python
 function into a command and an MCP tool, so it integrates with other tools like
 Anthropic Desktop or Cursor.
 
-It's new and still has some rough edges, but it's now working well enough it is feeling
+It’s new and still has some rough edges, but it’s now working well enough it is feeling
 quite powerful. It now serves as a replacement for my usual shell (previously bash or
 zsh). I use it routinely to remix, combine, and interactively explore and then gradually
 automate complex tasks by composing AI tools, APIs, and libraries.
@@ -48,19 +48,20 @@ quick to install via uv.
   context of a **workspace**. A workspace is just a directory of files that have a few
   conventions to make it easier to maintain context and perform actions.
   A bit like how Git repos work, it has a `.kash/` directory that holds metadata and
-  cached content. The rest can be anything, but is typically directories of resources
-  (like .docx or .pdf or links to web pages) or content, typically Markdown files with
-  YAML frontmatter. All text files use
-  [frontmatter-format](https://github.com/jlevy/frontmatter-format) so have easy-to-read
-  YAML metadata that includes not just title or description, but also the names of the
-  actions that created it.
+  cached content. The rest can be anything, but is typically directories of content and
+  resources (often Markdown or HTML but also .docx or .pdf or links to web pages).
+  All text files use [frontmatter-format](https://github.com/jlevy/frontmatter-format)
+  so have YAML metadata that includes not just title or description, but also how it was
+  created. All Markdown files are auto-formatted with
+  [flowmark](https://github.com/jlevy/flowmark), which makes documents much easier to
+  diff and version control (and prettier to read and edit).
 
 - **Compositionality:** An action is composable with other actions simply as a Python
   function, so complex operations (for example, transcribing and annotating a video and
   publishing it on a website) actions can be built from simpler actions (say downloading
   and caching a YouTube video, identifying the speakers in a transcript, formatting it
-  as pretty HTML, etc.). The goal is to reduce the "interstitial complexity" of
-  combining tools, so it's easy for you (or an LLM!) to combine tools in flexible and
+  as pretty HTML, etc.). The goal is to reduce the “interstitial complexity” of
+  combining tools, so it’s easy for you (or an LLM!) to combine tools in flexible and
   powerful ways.
 
 - **Command-line usage:** In addition to using the function in other libraries and
@@ -87,16 +88,16 @@ transcripts and notes, write blog posts, extract or visualize concepts, check ci
 convert notes to PDFs or beautifully formatted HTML, or perform numerous other
 content-related tasks possible by orchestrating AI tools in the right ways.
 
-As I've been building kash over the past couple months, I found I've found it's not only
+As I’ve been building kash over the past couple months, I found I’ve found it’s not only
 faster to do complex things, but that it has also become replacement for my usual shell.
-It's the power-tool I want to use alongside Cursor and ChatGPT/Claude.
+It’s the power-tool I want to use alongside Cursor and ChatGPT/Claude.
 We all know and trust shells like bash, zsh, and fish, but now I find this is much more
 powerful for everyday usage.
 It has little niceties, like you can just type `files` for a better listing of files or
 `show` and it will show you a file the right way, no matter what kind of file it is.
-You can also type something like "? find md files" and press tab and it will list you I
+You can also type something like “? find md files” and press tab and it will list you I
 find it is much more powerful for local usage than than bash/zsh/fish.
-If you're a command-line nerd, you might like it a lot.
+If you’re a command-line nerd, you might like it a lot.
 
 But my hope is that with these enhancements, the shell is also far more friendly and
 usable by anyone reasonably technical, and does not feel so esoteric as a typical Unix
@@ -105,16 +106,17 @@ shell.
 Finally, one more thing: Kash is also my way of experimenting with something else new: a
 **terminal GUI support** that adds GUI features terminal like clickable text, buttons,
 tooltips, and popovers in the terminal.
-I've separately built a new desktop terminal app, Kerm, which adds support for a simple
-"Kerm codes" protocol for such visual components, encoded as OSC codes then rendered in
+I’ve separately built a new desktop terminal app, Kerm, which adds support for a simple
+“Kerm codes” protocol for such visual components, encoded as OSC codes then rendered in
 the terminal. Because Kash supports these codes, as this develops you will get the
 visuals of a web app layered on the flexibility of a text-based terminal.
 
 ### Is Kash Mature?
 
-No. :) It's the result of a couple months of coding and experimentation, and it's very
-much in progress. Please help me make it better by sharing your ideas and feedback!
-It's easiest to DM me at [twitter.com/ojoshe](https://x.com/ojoshe).
+It’s the result of a couple months of coding and experimentation, and it’s still in
+progress and has rough edges.
+Please help me make it better by sharing your ideas and feedback!
+It’s easiest to DM me at [twitter.com/ojoshe](https://x.com/ojoshe).
 My contact info is at [github.com/jlevy](https://github.com/jlevy).
 
 [**Please follow or DM me**](https://x.com/ojoshe) for future updates or if you have

kash/docs/markdown/topics/a2_installation.md

@@ -4,7 +4,7 @@
 
 Kash offers a shell environment based on [xonsh](https://xon.sh/) augmented with a bunch
 of enhanced commands and customizations.
-If you've used a bash or Python shell before, it should be very intuitive.
+If you’ve used a bash or Python shell before, it should be very intuitive.
 
 Within the kash shell, you get a full environment with all actions and commands.
 You also get intelligent auto-complete, a built-in assistant to help you perform tasks,
@@ -13,7 +13,7 @@ and enhanced tab completion.
 The shell is an easy way to use Kash actions, simply calling them like other shell
 commands from the command line.
 
-But remember that's just one way to use actions; you can also use them directly in
+But remember that’s just one way to use actions; you can also use them directly in
 Python or from an MCP client.
 
 ### Current Kash Packages
@@ -23,7 +23,7 @@ However, some use cases require additional libraries, like video downloading too
 handling, etc.
 
 To keep kash dependencies more manageable, these additional utilities and actions are
-packaged additional "kits".
+packaged additional “kits”.
 
 The examples below use video transcription from YouTube as an example.
 To start with more full examples, I suggest starting with the `kash-media` kit.
@@ -38,7 +38,7 @@ These are for `kash-media` but you can use a `kash-shell` for a more basic setup
    Kash is easiest to use via [**uv**](https://docs.astral.sh/uv/), the new package
    manager for Python. `uv` replaces traditional use of `pyenv`, `pipx`, `poetry`, `pip`,
    etc. Installing `uv` also ensures you get a compatible version of Python.
-   See [uv's docs](https://docs.astral.sh/uv/getting-started/installation/) for other
+   See [uv’s docs](https://docs.astral.sh/uv/getting-started/installation/) for other
    installation methods and platforms.
    Usually you just want to run:
    ```shell
@@ -47,7 +47,7 @@ These are for `kash-media` but you can use a `kash-shell` for a more basic setup
 
 2. **Install additional command-line tools:**
 
-   In addition to Python, it's highly recommended to install a few other dependencies to
+   In addition to Python, it’s highly recommended to install a few other dependencies to
    make more tools and commands work.
    For macOS, you can again use brew:
 
@@ -104,7 +104,7 @@ These are for `kash-media` but you can use a `kash-shell` for a more basic setup
    ```
 
    These keys should go in the `.env` file in your current work directory or a parent or
-   your home directory (recommended if you'll be working in several directories, as with
+   your home directory (recommended if you’ll be working in several directories, as with
    a typical shell).
 
 5. **Run kash:**
@@ -144,14 +144,14 @@ If you add the `--proxy` arg, it will run an MCP stdio server but connect to the
 server you are running in the kash shell, by default at `localhost:4440`.
 
 Then if you run `start_mcp_server` from the shell, your client will connect to your
-shell, and you can actually use any "published" kash action as an MCP tool.
+shell, and you can actually use any “published” kash action as an MCP tool.
 
-Then you can for example ask your MCP client "can you transcribe this video?"
+Then you can for example ask your MCP client “can you transcribe this video?”
 and give it a URL, and it will be able to call the `transcribe` action as a tool.
 
 What is even better is that all the inputs and outputs are saved in the current kash
-workspace, just as if you'd been running these commands yourself in the shell.
-This way, you don't lose context or any work, and can seamlessly switch between an MCP
+workspace, just as if you’d been running these commands yourself in the shell.
+This way, you don’t lose context or any work, and can seamlessly switch between an MCP
 client like Cursor, the shell, and any other tools to edit the inputs or outputs of
 actions in your workspace directory.