kash-shell 0.3.0__py3-none-any.whl

kash/concepts/embeddings.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import ast
+from collections.abc import Iterable
+from pathlib import Path
+from typing import TypeAlias
+
+import pandas as pd
+from litellm import embedding
+from pydantic.dataclasses import dataclass
+from strif import abbrev_list
+
+from kash.config.logger import get_logger
+from kash.llm_utils.language_models import DEFAULT_EMBEDDING_MODEL
+
+log = get_logger(__name__)
+
+
+BATCH_SIZE = 1024
+
+Key: TypeAlias = str
+
+KeyVal: TypeAlias = tuple[Key, str]
+"""
+A key-value pair where the key is a unique identifier (such as the path)
+and the value is the text to embed.
+"""
+
+
+@dataclass
+class Embeddings:
+    """
+    Embedded string values. Each string value has a unique key (e.g. its id or title or for
+    small texts, the text itself).
+    """
+
+    data: dict[Key, tuple[str, list[float]]]
+    """Mapping of key to text and embedding."""
+
+    def as_iterable(self) -> Iterable[tuple[Key, str, list[float]]]:
+        return ((key, text, emb) for key, (text, emb) in self.data.items())
+
+    def as_df(self) -> pd.DataFrame:
+        keys, texts, embeddings = zip(
+            *[(key, text, emb) for key, (text, emb) in self.data.items()], strict=False
+        )
+        return pd.DataFrame(
+            {
+                "key": keys,
+                "text": texts,
+                "embedding": embeddings,
+            }
+        )
+
+    def __getitem__(self, key: Key) -> tuple[str, list[float]]:
+        if key in self.data:
+            return self.data[key]
+        else:
+            raise KeyError(f"Key '{key}' not found in embeddings")
+
+    @classmethod
+    def embed(cls, keyvals: list[KeyVal], model=DEFAULT_EMBEDDING_MODEL) -> Embeddings:
+        data = {}
+        log.message(
+            "Embedding %d texts (model %s, batch size %s)…",
+            len(keyvals),
+            model.litellm_name,
+            BATCH_SIZE,
+        )
+        for batch_start in range(0, len(keyvals), BATCH_SIZE):
+            batch_end = batch_start + BATCH_SIZE
+            batch = keyvals[batch_start:batch_end]
+            keys = [kv[0] for kv in batch]
+            texts = [kv[1] for kv in batch]
+
+            response = embedding(model=model.litellm_name, input=texts)
+            if not response.data:
+                raise ValueError("No embedding response data")
+
+            batch_embeddings = [e["embedding"] for e in response.data]
+            data.update(
+                {
+                    key: (text, emb)
+                    for key, text, emb in zip(keys, texts, batch_embeddings, strict=False)
+                }
+            )
+
+            log.info(
+                "Embedded batch %d-%d: %s",
+                batch_start,
+                batch_end,
+                abbrev_list(texts),
+            )
+
+        return cls(data=data)
+
+    def to_csv(self, path: Path) -> None:
+        self.as_df().to_csv(path, index=False)
+
+    @classmethod
+    def read_from_csv(cls, path: Path) -> Embeddings:
+        df = pd.read_csv(path)
+        df["embedding"] = df["embedding"].apply(ast.literal_eval)
+        data = {row["key"]: (row["text"], row["embedding"]) for _, row in df.iterrows()}
+        return cls(data=data)  # pyright: ignore
+
+    def to_npz(self, path: Path) -> None:
+        """Save embeddings in numpy's compressed format."""
+        import numpy as np
+
+        keys: list[Key] = list(self.data.keys())
+        texts: list[str] = [self.data[k][0] for k in keys]
+        embeddings = np.array([self.data[k][1] for k in keys])
+        np.savez_compressed(path, keys=keys, texts=texts, embeddings=embeddings)
+
+    @classmethod
+    def read_from_npz(cls, path: Path) -> Embeddings:
+        """Load embeddings from numpy's compressed format."""
+        import numpy as np
+
+        with np.load(path) as data:
+            loaded_data = {
+                k: (t, e.tolist())
+                for k, t, e in zip(data["keys"], data["texts"], data["embeddings"], strict=False)
+            }
+        return cls(data=loaded_data)
+
+    def __str__(self) -> str:
+        dims = -1 if len(self.data) == 0 else len(next(iter(self.data))[1])
+        return f"Embeddings({len(self.data)} items, {dims} dimensions)"

kash/concepts/text_similarity.py

@@ -0,0 +1,108 @@
+import litellm
+import pandas as pd
+from funlog import log_calls, tally_calls
+from litellm import embedding
+from litellm.types.utils import EmbeddingResponse
+from scipy import spatial
+
+from kash.concepts.embeddings import Embeddings
+from kash.config.logger import get_logger
+from kash.errors import ApiResultError
+from kash.llm_utils.language_models import DEFAULT_EMBEDDING_MODEL, EmbeddingModel
+
+log = get_logger(__name__)
+
+
+def sort_by_length(values: list[str]) -> list[str]:
+    return sorted(values, key=lambda x: (len(x), x))
+
+
+def cosine_relatedness(x, y):
+    return 1 - spatial.distance.cosine(x, y)
+
+
+@log_calls(level="info", show_return_value=False)
+def embed_query(model: EmbeddingModel, query: str) -> EmbeddingResponse:
+    try:
+        response = embedding(model=model.litellm_name, input=[query])
+    except litellm.exceptions.APIError as e:
+        log.info("API error embedding query: %s", e)
+        raise ApiResultError(str(e))
+    if not response.data:
+        log.info("API error embedding query, got: %s", response)
+        raise ApiResultError("No embedding response data")
+    return response
+
+
+@log_calls(level="info", show_return_value=False)
+def rank_by_relatedness(
+    query: str,
+    embeddings: Embeddings,
+    relatedness_fn=cosine_relatedness,
+    model=DEFAULT_EMBEDDING_MODEL,
+    top_n: int = -1,
+) -> list[tuple[str, str, float]]:
+    """
+    Returns a list of strings and relatednesses, sorted from most related to least.
+    """
+    response = embed_query(model, query)
+
+    query_embedding = response.data[0]["embedding"]
+
+    scored_strings = [
+        (key, text, relatedness_fn(query_embedding, emb))
+        for key, text, emb in embeddings.as_iterable()
+    ]
+    scored_strings.sort(key=lambda x: x[2], reverse=True)
+
+    return scored_strings[:top_n]
+
+
+@tally_calls(level="warning", min_total_runtime=5, if_slower_than=10)
+def relate_texts_by_embedding(
+    embeddings: Embeddings, relatedness_fn=cosine_relatedness
+) -> pd.DataFrame:
+    log.message("Computing relatedness matrix of %d text embeddings…", len(embeddings.data))
+
+    keys = [key for key, _, _ in embeddings.as_iterable()]
+    relatedness_matrix = pd.DataFrame(index=keys, columns=keys)  # pyright: ignore
+
+    for i, (key1, _, emb1) in enumerate(embeddings.as_iterable()):
+        for j, (key2, _, emb2) in enumerate(embeddings.as_iterable()):
+            if i <= j:
+                score = relatedness_fn(emb1, emb2)
+                relatedness_matrix.at[key1, key2] = score
+                relatedness_matrix.at[key2, key1] = score
+
+    # Fill diagonal (self-relatedness).
+    for key in keys:
+        relatedness_matrix.at[key, key] = 1.0
+
+    return relatedness_matrix
+
+
+def find_related_pairs(
+    relatedness_matrix: pd.DataFrame, threshold: float = 0.9
+) -> list[tuple[str, str, float]]:
+    log.message(
+        "Finding near duplicates among %s items (threshold %s)",
+        relatedness_matrix.shape[0],
+        threshold,
+    )
+
+    pairs: list[tuple[str, str, float]] = []
+    keys = relatedness_matrix.index.tolist()
+
+    for i, key1 in enumerate(keys):
+        for j, key2 in enumerate(keys):
+            if i < j:
+                relatedness = relatedness_matrix.at[key1, key2]
+                if relatedness >= threshold:
+                    # Put shortest one first.
+                    [short_key, long_key] = sort_by_length([key1, key2])
+                    pairs.append((short_key, long_key, relatedness))
+
+    # Sort with highest relatedness first.
+    pairs.sort(key=lambda x: x[2], reverse=True)
+
+    return pairs

kash/config/__init__.py

@@ -0,0 +1,4 @@
+"""
+App specific setup, settings, and configs. Should have no dependencies outside
+this module except for a very few things in the util module.
+"""

kash/config/api_keys.py

@@ -0,0 +1,84 @@
+import os
+from enum import Enum
+
+from dotenv import find_dotenv, load_dotenv
+from rich.text import Text
+
+from kash.shell.output.shell_output import cprint, format_success_or_failure
+from kash.utils.common.atomic_var import AtomicVar
+
+
+class Api(str, Enum):
+    openai = "OPENAI_API_KEY"
+    anthropic = "ANTHROPIC_API_KEY"
+    gemini = "GEMINI_API_KEY"
+    xai = "XAI_API_KEY"
+    deepseek = "DEEPSEEK_API_KEY"
+    mistral = "MISTRAL_API_KEY"
+    perplexityai = "PERPLEXITYAI_API_KEY"
+    deepgram = "DEEPGRAM_API_KEY"
+    groq = "GROQ_API_KEY"
+    firecrawl = "FIRECRAWL_API_KEY"
+    exa = "EXA_API_KEY"
+
+
+RECOMMENDED_APIS = [
+    Api.openai,
+    Api.anthropic,
+    Api.deepgram,
+    Api.groq,
+]
+
+
+def api_setup() -> str:
+    dotenv_path = find_dotenv(usecwd=True)
+    if dotenv_path:
+        load_dotenv(dotenv_path)
+    return dotenv_path
+
+
+_log_api_setup_done = AtomicVar(False)
+
+
+def warn_if_missing_api_keys(keys: list[Api] = RECOMMENDED_APIS) -> list[Api]:
+    from kash.config.logger import get_logger
+
+    log = get_logger(__name__)
+
+    missing_keys = [api for api in keys if api.value not in os.environ]
+    if missing_keys:
+        log.warning(
+            "Missing recommended API keys (check .env file or set them?): %s",
+            ", ".join(missing_keys),
+        )
+
+    return missing_keys
+
+
+def print_api_key_setup(once: bool = False) -> None:
+    if once and _log_api_setup_done:
+        return
+
+    dotenv_path = api_setup()
+
+    cprint(
+        Text.assemble(
+            format_success_or_failure(
+                value=bool(dotenv_path),
+                true_str=f"Found .env file: {dotenv_path}",
+                false_str="No .env file found. Set up your API keys in a .env file.",
+            ),
+        )
+    )
+
+    def is_set(key: str) -> bool:
+        value = os.environ.get(key, None)
+        return bool(value and value.strip() and "changeme" not in value)
+
+    texts = [format_success_or_failure(is_set(api.value), api.name) for api in Api]
+
+    cprint(Text.assemble("API keys found: ", Text(" ").join(texts)))
+
+    warn_if_missing_api_keys()
+
+    _log_api_setup_done.set(True)

kash/config/capture_output.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import io
+from contextlib import redirect_stdout
+from dataclasses import dataclass
+
+from kash.config.logger import get_logger, record_console
+
+log = get_logger(__name__)
+
+
+@dataclass(frozen=True)
+class CapturedOutput:
+    """
+    Holds captured console and stdout output.
+    """
+
+    console_text: str
+    stdout_text: str
+
+    @property
+    def logs(self) -> str:
+        logs = ""
+        if self.console_text:
+            logs += f"Console:\n{self.console_text}\n\n"
+        if self.stdout_text:
+            logs += f"Stdout:\n{self.stdout_text}\n\n"
+        return logs
+
+
+class captured_output:
+    """
+    Context manager for capturing console and stdout output.
+    Returns a CapturedOutput instance when exiting the context.
+    """
+
+    def __init__(self):
+        self._output = None
+        self.stdout_buffer = None
+        self.console = None
+        self.stdout_redirector = None
+
+    def __enter__(self) -> captured_output:
+        self.stdout_buffer = io.StringIO()
+        self.console = record_console().__enter__()
+        self.stdout_redirector = redirect_stdout(self.stdout_buffer)
+        self.stdout_redirector.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        console_text = self.console.export_text() if self.console else ""
+        stdout_text = self.stdout_buffer.getvalue() if self.stdout_buffer else ""
+
+        # Create output object before cleanup.
+        self._output = CapturedOutput(console_text=console_text, stdout_text=stdout_text)
+
+        if console_text:
+            log.info("Captured console:\n%s", console_text)
+        if stdout_text:
+            log.info("Captured stdout:\n%s", stdout_text)
+
+        # Clean up the context managers using stored instances.
+        stdout_suppress = True
+        if self.stdout_redirector:
+            stdout_suppress = self.stdout_redirector.__exit__(exc_type, exc_val, exc_tb)
+        console_suppress = True
+        if self.console:
+            console_suppress = self.console.__exit__(exc_type, exc_val, exc_tb)
+
+        # Propagate exceptions unless suppressed by both handlers.
+        return stdout_suppress and console_suppress
+
+    @property
+    def output(self) -> CapturedOutput:
+        if self._output is None:
+            raise RuntimeError("Cannot access output before context manager exits")
+        return self._output

kash/config/colors.py

@@ -0,0 +1,279 @@
+from types import SimpleNamespace
+
+from colour import Color
+from rich.terminal_theme import TerminalTheme
+
+
+def hsl_to_hex(hsl_string: str) -> str:
+    """
+    Convert an HSL/HSLA string to an RGB hex string or RGBA value.
+    "hsl(134, 43%, 60%)" -> "#6dbd6d"
+    "hsla(220, 14%, 96%, 0.86)" -> "rgba(244, 245, 247, 0.86)"
+    """
+    is_hsla = hsl_string.startswith("hsla")
+    hsl_values = (
+        hsl_string.replace("hsla(", "")
+        .replace("hsl(", "")
+        .replace(")", "")
+        .replace("%", "")
+        .split(",")
+    )
+
+    if is_hsla:
+        hue, saturation, lightness, alpha = (float(value.strip()) for value in hsl_values)
+    else:
+        hue, saturation, lightness = (float(value.strip()) for value in hsl_values)
+        alpha = 1.0
+
+    saturation /= 100
+    lightness /= 100
+
+    color = Color(hsl=(hue / 360, saturation, lightness))
+
+    if alpha < 1:
+        rgb = color.rgb
+        return f"rgba({int(rgb[0] * 255)}, {int(rgb[1] * 255)}, {int(rgb[2] * 255)}, {alpha})"
+    return color.hex_l
+
+
+def hex_to_int(hex_string: str) -> tuple[int, int, int]:
+    """
+    Convert a hex color string to RGB integers.
+    Supports both 6-digit and 3-digit hex codes:
+    "#6dbd6d" -> (109, 189, 109)
+    "#333" -> (51, 51, 51)  # equivalent to #333333
+    """
+    try:
+        hex_string = hex_string.lstrip("#")
+        if len(hex_string) == 3:
+            hex_string = "".join(c + c for c in hex_string)
+        if len(hex_string) != 6:
+            raise ValueError(f"Invalid hex color length: {hex_string}")
+
+        r = int(hex_string[0:2], 16)
+        g = int(hex_string[2:4], 16)
+        b = int(hex_string[4:6], 16)
+
+        return (r, g, b)
+    except Exception:
+        raise ValueError(f"Could not parse hex color: `{hex_string}`")
+
+
+# Main colors.
+terminal_colors = SimpleNamespace(
+    # Based on:
+    # https://rootloops.sh?sugar=8&colors=7&sogginess=5&flavor=2&fruit=9&milk=1
+    # Some tools only like hex colors so convert them at once.
+    # black
+    black_darkest=hsl_to_hex("hsl(0, 0%, 7%)"),
+    black_darker=hsl_to_hex("hsl(0, 0%, 13%)"),
+    black_dark=hsl_to_hex("hsl(0, 0%, 30%)"),
+    black_light=hsl_to_hex("hsl(0, 0%, 73%)"),
+    black_lighter=hsl_to_hex("hsl(0, 0%, 90%)"),
+    # red
+    red_darkest=hsl_to_hex("hsl(7, 50%, 35%)"),
+    red_darker=hsl_to_hex("hsl(7, 43%, 48%)"),
+    red_dark=hsl_to_hex("hsl(7, 73%, 72%)"),
+    red_light=hsl_to_hex("hsl(7, 87%, 85%)"),
+    red_lighter=hsl_to_hex("hsl(7, 95%, 94%)"),
+    # green
+    green_darkest=hsl_to_hex("hsl(134, 35%, 34%)"),
+    green_darker=hsl_to_hex("hsl(134, 37%, 46%)"),
+    green_dark=hsl_to_hex("hsl(134, 43%, 60%)"),
+    green_light=hsl_to_hex("hsl(134, 53%, 73%)"),
+    green_lighter=hsl_to_hex("hsl(134, 70%, 90%)"),
+    # yellow
+    yellow_darkest=hsl_to_hex("hsl(44, 47%, 34%)"),
+    yellow_darker=hsl_to_hex("hsl(44, 47%, 44%)"),
+    yellow_dark=hsl_to_hex("hsl(44, 54%, 55%)"),
+    yellow_light=hsl_to_hex("hsl(44, 74%, 76%)"),
+    yellow_lighter=hsl_to_hex("hsl(44, 80%, 90%)"),
+    # blue
+    blue_darkest=hsl_to_hex("hsl(225, 35%, 34%)"),
+    blue_darker=hsl_to_hex("hsl(225, 46%, 52%)"),
+    blue_dark=hsl_to_hex("hsl(225, 71%, 76%)"),
+    blue_light=hsl_to_hex("hsl(225, 86%, 88%)"),
+    blue_lighter=hsl_to_hex("hsl(225, 90%, 94%)"),
+    # magenta
+    magenta_darkest=hsl_to_hex("hsl(305, 35%, 34%)"),
+    magenta_darker=hsl_to_hex("hsl(305, 38%, 55%)"),
+    magenta_dark=hsl_to_hex("hsl(305, 54%, 71%)"),
+    magenta_light=hsl_to_hex("hsl(305, 68%, 85%)"),
+    magenta_lighter=hsl_to_hex("hsl(305, 96%, 95%)"),
+    # cyan
+    cyan_darkest=hsl_to_hex("hsl(188, 60%, 32%)"),
+    cyan_darker=hsl_to_hex("hsl(188, 60%, 41%)"),
+    cyan_dark=hsl_to_hex("hsl(188, 58%, 57%)"),
+    cyan_light=hsl_to_hex("hsl(188, 52%, 76%)"),
+    cyan_lighter=hsl_to_hex("hsl(188, 52%, 92%)"),
+    # white
+    white_darkest=hsl_to_hex("hsl(240, 6%, 60%)"),
+    white_darker=hsl_to_hex("hsl(240, 6%, 72%)"),
+    white_dark=hsl_to_hex("hsl(240, 6%, 87%)"),
+    white_light=hsl_to_hex("hsl(240, 6%, 94%)"),
+    white_lighter=hsl_to_hex("hsl(240, 6%, 98%)"),
+)
+
+
+# Only support dark terminal colors for now.
+terminal_dark = SimpleNamespace(
+    foreground="#fff",
+    background="#000",
+    border=hsl_to_hex("hsl(188, 8%, 33%)"),
+    cursor=hsl_to_hex("hsl(305, 84%, 68%)"),
+    input=hsl_to_hex("hsl(305, 92%, 95%)"),
+    input_form=hsl_to_hex("hsl(188, 52%, 76%)"),
+    **terminal_colors.__dict__,
+)
+terminal = terminal_dark
+
+
+# Web light colors.
+web_light_translucent = SimpleNamespace(
+    primary=hsl_to_hex("hsl(188, 31%, 41%)"),
+    primary_light=hsl_to_hex("hsl(188, 40%, 62%)"),
+    secondary=hsl_to_hex("hsl(188, 12%, 28%)"),
+    bg=hsl_to_hex("hsla(44, 6%, 100%, 0.75)"),
+    bg_header=hsl_to_hex("hsla(188, 42%, 70%, 0.2)"),
+    bg_alt=hsl_to_hex("hsla(44, 28%, 90%, 0.3)"),
+    text=hsl_to_hex("hsl(188, 39%, 11%)"),
+    border=hsl_to_hex("hsl(188, 8%, 50%)"),
+    border_hint=hsl_to_hex("hsla(188, 8%, 72%, 0.7)"),
+    border_accent=hsl_to_hex("hsla(305, 18%, 65%, 0.85)"),
+    hover=hsl_to_hex("hsl(188, 12%, 84%)"),
+    hover_bg=hsl_to_hex("hsla(188, 7%, 94%, 0.8)"),
+    hint=hsl_to_hex("hsl(188, 11%, 65%)"),
+    tooltip_bg=hsl_to_hex("hsla(188, 6%, 37%, 0.7)"),
+    popover_bg=hsl_to_hex("hsla(188, 6%, 37%, 0.7)"),
+    bright=hsl_to_hex("hsl(134, 43%, 60%)"),
+    selection="hsla(225, 61%, 82%, 0.80)",
+    scrollbar=hsl_to_hex("hsla(189, 12%, 55%, 0.9)"),
+    scrollbar_hover=hsl_to_hex("hsla(190, 12%, 38%, 0.9)"),
+)
+
+
+rich_terminal_dark = TerminalTheme(
+    hex_to_int(terminal_dark.background),
+    hex_to_int(terminal_dark.foreground),
+    # normal colors [black, red, green, yellow, blue, magenta, cyan, white]
+    [
+        hex_to_int(terminal_dark.black_dark),
+        hex_to_int(terminal_dark.red_dark),
+        hex_to_int(terminal_dark.green_dark),
+        hex_to_int(terminal_dark.yellow_dark),
+        hex_to_int(terminal_dark.blue_dark),
+        hex_to_int(terminal_dark.magenta_dark),
+        hex_to_int(terminal_dark.cyan_dark),
+        hex_to_int(terminal_dark.white_dark),
+    ],
+    # bright colors [black, red, green, yellow, blue, magenta, cyan, white]
+    [
+        hex_to_int(terminal_dark.black_lighter),
+        hex_to_int(terminal_dark.red_lighter),
+        hex_to_int(terminal_dark.green_lighter),
+        hex_to_int(terminal_dark.yellow_lighter),
+        hex_to_int(terminal_dark.blue_lighter),
+        hex_to_int(terminal_dark.magenta_lighter),
+        hex_to_int(terminal_dark.cyan_lighter),
+        hex_to_int(terminal_dark.white_lighter),
+    ],
+)
+
+rich_terminal_light = TerminalTheme(
+    hex_to_int(terminal_dark.background),
+    hex_to_int(terminal_dark.foreground),
+    # normal colors [black, red, green, yellow, blue, magenta, cyan, white]
+    [
+        hex_to_int(terminal_dark.black_dark),
+        hex_to_int(terminal_dark.red_dark),
+        hex_to_int(terminal_dark.green_dark),
+        hex_to_int(terminal_dark.yellow_dark),
+        hex_to_int(terminal_dark.blue_dark),
+        hex_to_int(terminal_dark.magenta_dark),
+        hex_to_int(terminal_dark.cyan_dark),
+        hex_to_int(terminal_dark.white_dark),
+    ],
+    # bright colors [black, red, green, yellow, blue, magenta, cyan, white]
+    [
+        hex_to_int(terminal_dark.black_darker),
+        hex_to_int(terminal_dark.red_darker),
+        hex_to_int(terminal_dark.green_darker),
+        hex_to_int(terminal_dark.yellow_darker),
+        hex_to_int(terminal_dark.blue_darker),
+        hex_to_int(terminal_dark.magenta_darker),
+        hex_to_int(terminal_dark.cyan_darker),
+        hex_to_int(terminal_dark.white_darker),
+    ],
+)
+
+# We default to light colors for Rich content in HTML.
+rich_terminal = rich_terminal_light
+
+# Only support light web colors for now.
+web = web_light_translucent
+
+# Logical colors
+logical = SimpleNamespace(
+    concept_dark=terminal.green_dark,
+    concept_light=terminal.green_light,
+    concept_lighter=terminal.green_lighter,
+    doc_dark=terminal.blue_dark,
+    doc_light=terminal.blue_light,
+    doc_lighter=terminal.blue_lighter,
+    resource_dark=terminal.cyan_dark,
+    resource_light=terminal.cyan_light,
+    resource_lighter=terminal.cyan_lighter,
+    link_dark=terminal.yellow_dark,
+    link_light=terminal.yellow_light,
+    link_lighter=terminal.yellow_lighter,
+    other=terminal.white_dark,
+    other_light=terminal.white_light,
+    other_lighter=terminal.white_lighter,
+)
+
+
+def consolidate_color_vars(overrides: dict[str, str] | None = None) -> dict[str, str]:
+    """
+    Consolidate all color variables into a single dictionary with appropriate prefixes.
+    Terminal variables have no prefix, while web and logical variables have "color-" prefix.
+    """
+    if overrides is None:
+        overrides = {}
+    return {
+        # Terminal variables (no prefix)
+        **terminal.__dict__,
+        # Web and logical variables with "color-" prefix
+        **{f"color-{k}": v for k, v in web.__dict__.items()},
+        **{f"color-{k}": v for k, v in logical.__dict__.items()},
+        # Overrides take precedence (assume they already have correct prefixes)
+        **overrides,
+    }
+
+
+def normalize_var_names(variables: dict[str, str]) -> dict[str, str]:
+    """
+    Normalize variable names from Python style to CSS style.
+    Example: color_bg -> color-bg
+    """
+    return {k.replace("_", "-"): v for k, v in variables.items()}
+
+
+def generate_css_vars(overrides: dict[str, str] | None = None) -> str:
+    """
+    Generate CSS variables for the terminal and web colors.
+    """
+    if overrides is None:
+        overrides = {}
+    normalized_vars = normalize_var_names(consolidate_color_vars(overrides))
+
+    # Generate the CSS.
+    css_variables = ":root {\n"
+    for name, value in normalized_vars.items():
+        css_variables += f"  --{name}: {value};\n"
+    css_variables += "}"
+
+    return css_variables
+
+
+if __name__ == "__main__":
+    print(generate_css_vars())

kash/config/init.py

@@ -0,0 +1,18 @@
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from kash.model.actions_model import Action
+
+
+def kash_reload_all() -> tuple[dict[str, Callable], dict[str, type["Action"]]]:
+    """
+    Import all kash modules that define actions and commands.
+    """
+    from kash.exec.action_registry import reload_all_action_classes
+    from kash.exec.command_registry import get_all_commands
+
+    commands = get_all_commands()
+    actions = reload_all_action_classes()
+
+    return commands, actions