python-lucide 0.3.0__tar.gz → 0.4.0__tar.gz

{python_lucide-0.3.0 → python_lucide-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-lucide
-Version: 0.3.0
+Version: 0.4.0
 Summary: A Python package for working with Lucide icons
 Keywords: lucide,icons,svg,sqlite
 Author: Mike Macpherson

{python_lucide-0.3.0 → python_lucide-0.4.0}/pyproject.toml

@@ -11,6 +11,7 @@ dev = [
   "mypy>=1.0.0",
   "plotly>=5.0.0",
   "pre-commit>=3.0.0",
+  "pydantic-ai-slim[google]>=1.0.0",
   "pytest-cov>=4.0.0",
   "pytest>=7.0.0",
   "ruff>=0.1.0",
@@ -40,7 +41,7 @@ license = {text = "MIT"}
 name = "python-lucide"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "0.3.0"
+version = "0.4.0"
 
 [project.optional-dependencies]
 search = ["fastembed>=0.4.0"]

{python_lucide-0.3.0 → python_lucide-0.4.0}/src/lucide/build_clusters.py

@@ -13,51 +13,68 @@ import logging
 import os
 import pathlib
 import sqlite3
-import urllib.request
 from datetime import datetime, timezone
 
+from pydantic import BaseModel, field_validator
+from pydantic_ai import Agent
+from pydantic_ai.models import Model
+
+from .config import DEFAULT_SEARCH_MODEL_ID
+
 logger = logging.getLogger(__name__)
 
 CLUSTER_NAMING_MODEL = "gemini-2.5-flash"
 
-NAMING_PROMPT_TEMPLATE = """\
-Here are icon names that form a visual/semantic cluster: {icon_names}
+NAMING_INSTRUCTIONS = """\
+You name clusters of icons. Given icon names that form a visual/semantic
+cluster, respond with a short, evocative theme name (2-4 words).
+Be specific about what unifies the icons.
+Do not use generic labels like "UI elements" or "miscellaneous"."""
 
-Give this cluster a short, evocative theme name (2-4 words).
-Be specific about what unifies these icons.
-Do not use generic labels like "UI elements" or "miscellaneous".
+# Generous bound for a "2-4 word" name; anything longer means the model
+# ignored the instruction (e.g. leaked its reasoning)
+MAX_THEME_LENGTH = 40
 
-Return ONLY the theme name, nothing else."""
 
-GEMINI_API_URL = (
-    "https://generativelanguage.googleapis.com/v1beta/models/"
-    "{model}:generateContent?key={api_key}"
-)
+def _sanitize_theme(raw: str) -> str | None:
+    """Validate a model-proposed theme name.
 
+    Models occasionally return their full chain-of-thought instead of just
+    the name — two shipped clusters once carried ~4k-char reasoning dumps
+    as their theme. Reject anything multi-line or implausibly long rather
+    than trying to salvage it.
+
+    Args:
+        raw: The raw model response text.
+
+    Returns:
+        The cleaned theme name, or None if the response is unusable.
+    """
+    theme = raw.strip().strip("\"'").strip()
+    if not theme or "\n" in theme or len(theme) > MAX_THEME_LENGTH:
+        return None
+    return theme
 
-def _call_gemini_text(prompt: str, api_key: str) -> str | None:
-    """Call Gemini API with a text-only prompt."""
-    payload = {"contents": [{"parts": [{"text": prompt}]}]}
-    body = json.dumps(payload).encode("utf-8")
-    url = GEMINI_API_URL.format(model=CLUSTER_NAMING_MODEL, api_key=api_key)
-    req = urllib.request.Request(
-        url,
-        data=body,
-        headers={"Content-Type": "application/json"},
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=30) as resp:
-            result = json.loads(resp.read().decode("utf-8"))
-        candidates = result.get("candidates", [])
-        if candidates:
-            parts = candidates[0].get("content", {}).get("parts", [])
-            if parts:
-                text: str = parts[0].get("text", "")
-                return text.strip()
-    except Exception:
-        logger.warning("Gemini API call failed", exc_info=True)
-    return None
+
+class ClusterTheme(BaseModel):
+    """Structured output for cluster naming.
+
+    A failed validation here becomes a retry request to the model, so a
+    leaked chain-of-thought gets re-asked instead of stored or discarded.
+    """
+
+    theme: str
+
+    @field_validator("theme")
+    @classmethod
+    def _must_be_short_single_line(cls, value: str) -> str:
+        clean = _sanitize_theme(value)
+        if clean is None:
+            raise ValueError(
+                f"theme must be a single line of at most {MAX_THEME_LENGTH} "
+                "characters — return only the 2-4 word name itself"
+            )
+        return clean
 
 
 def discover_clusters(
@@ -83,7 +100,9 @@ def discover_clusters(
         "SELECT e.name, e.embedding, d.description "
         "FROM icon_embeddings e "
         "JOIN icon_descriptions d ON e.name = d.name "
-        "ORDER BY e.name"
+        "WHERE e.model = ? "
+        "ORDER BY e.name",
+        (DEFAULT_SEARCH_MODEL_ID,),
     ).fetchall()
     conn.close()
 
@@ -140,19 +159,40 @@ def name_clusters(
     data: dict,
     *,
     api_key: str | None = None,
+    model: Model | None = None,
 ) -> dict:
-    """Name each cluster using Gemini Flash.
+    """Name each cluster using Gemini Flash via a Pydantic AI agent.
+
+    Output is validated by ``ClusterTheme``; an invalid response (e.g. a
+    leaked chain-of-thought) triggers an automatic retry instead of being
+    stored. Only after retries are exhausted does a cluster fall back to a
+    ``Cluster {id}`` placeholder.
 
     Args:
         data: Output from ``discover_clusters()``.
         api_key: Gemini API key. Falls back to ``GEMINI_API_KEY`` env var.
+        model: Model override, used by tests to avoid real API calls.
 
     Returns:
         The same data dict with ``theme`` populated for each cluster.
     """
-    api_key = api_key or os.environ.get("GEMINI_API_KEY")
-    if not api_key:
-        raise ValueError("Gemini API key required. Set GEMINI_API_KEY.")
+    if model is None:
+        from pydantic_ai.models.google import GoogleModel  # noqa: PLC0415
+        from pydantic_ai.providers.google import GoogleProvider  # noqa: PLC0415
+
+        api_key = api_key or os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError("Gemini API key required. Set GEMINI_API_KEY.")
+        model = GoogleModel(
+            CLUSTER_NAMING_MODEL, provider=GoogleProvider(api_key=api_key)
+        )
+
+    agent = Agent(
+        model,
+        output_type=ClusterTheme,
+        instructions=NAMING_INSTRUCTIONS,
+        output_retries=3,
+    )
 
     clusters = data["clusters"]
     for lid in sorted(clusters, key=lambda k: -len(clusters[k]["icons"])):
@@ -163,17 +203,15 @@ def name_clusters(
         icons = clusters[lid]["icons"]
         # Cap at 40 names to keep prompt short
         icon_names = ", ".join(icons[:40])
-        prompt = NAMING_PROMPT_TEMPLATE.format(icon_names=icon_names)
-        theme = _call_gemini_text(prompt, api_key)
-
-        if theme:
-            # Strip quotes if the model wraps it
-            theme = theme.strip("\"'")
-            clusters[lid]["theme"] = theme
-            logger.info("Cluster %s (%d icons): %s", lid, len(icons), theme)
-        else:
+        try:
+            result = agent.run_sync(f"Icon cluster: {icon_names}")
+            clusters[lid]["theme"] = result.output.theme
+            logger.info(
+                "Cluster %s (%d icons): %s", lid, len(icons), result.output.theme
+            )
+        except Exception:
             clusters[lid]["theme"] = f"Cluster {lid}"
-            logger.warning("Failed to name cluster %s", lid)
+            logger.warning("Failed to name cluster %s", lid, exc_info=True)
 
     return data
 
@@ -260,8 +298,7 @@ def build_cluster_visualization(
     fig.update_layout(
         title={
             "text": (
-                "Lucide Icon Embedding Clusters \u2014 "
-                "themes discovered via HDBSCAN in 768d space"
+                "Lucide Icon Embedding Clusters \u2014 themes discovered via HDBSCAN"
             ),
             "font": {"size": 16},
         },

{python_lucide-0.3.0 → python_lucide-0.4.0}/src/lucide/build_search.py

@@ -30,10 +30,9 @@ from datetime import datetime, timezone
 from typing import TypedDict
 
 from .config import (
-    DEFAULT_EMBEDDING_DIM,
-    DEFAULT_EMBEDDING_MODEL,
     DEFAULT_VLM_MODEL,
-    EMBEDDING_DOCUMENT_PREFIX,
+    EMBEDDING_MODELS,
+    SEARCH_DB_SCHEMA_VERSION,
 )
 
 logger = logging.getLogger(__name__)
@@ -486,9 +485,10 @@ def _ensure_search_tables(conn: sqlite3.Connection) -> None:
     )
     conn.execute(
         "CREATE TABLE IF NOT EXISTS icon_embeddings ("
-        "  name TEXT PRIMARY KEY,"
+        "  name TEXT NOT NULL,"
         "  embedding BLOB NOT NULL,"
-        "  model TEXT NOT NULL"
+        "  model TEXT NOT NULL,"
+        "  PRIMARY KEY (name, model)"
         ")"
     )
     conn.execute(
@@ -513,23 +513,35 @@ def _write_search_db(  # noqa: PLR0913
     search_db_path: pathlib.Path,
     ordered_names: list[str],
     records: dict[str, DescriptionRecord],
-    embeddings: list,
+    embeddings: dict[str, dict[str, object]],
     clusters_path: pathlib.Path,
     *,
     version: str | None = None,
     verbose: bool = False,
 ) -> None:
-    """Write descriptions, embeddings, clusters, and metadata to SQLite."""
+    """Write descriptions, embeddings, clusters, and metadata to SQLite.
+
+    Args:
+        search_db_path: Output SQLite path (recreated from scratch).
+        ordered_names: Icon names in insertion order.
+        records: Description records keyed by icon name.
+        embeddings: Embedding vectors as ``{model_id: {icon_name: vector}}``.
+            A model may cover only a subset of icons; absent names are
+            simply not inserted for that model.
+        clusters_path: JSON file with cluster assignments.
+        version: Lucide icon-set version for the metadata table.
+        verbose: Verbose logging.
+    """
     import numpy as np  # noqa: PLC0415
 
     search_db_path.parent.mkdir(parents=True, exist_ok=True)
+    # Recreate rather than DELETE-and-reuse: the schema itself may have
+    # changed since the last build (CREATE IF NOT EXISTS won't migrate it)
+    search_db_path.unlink(missing_ok=True)
     conn = sqlite3.connect(search_db_path)
     try:
         _ensure_search_tables(conn)
 
-        conn.execute("DELETE FROM icon_descriptions")
-        conn.execute("DELETE FROM icon_embeddings")
-
         for name in ordered_names:
             rec = records[name]
             conn.execute(
@@ -538,15 +550,18 @@ def _write_search_db(  # noqa: PLR0913
                 (name, rec["description"], rec["model"]),
             )
 
-        for name, emb in zip(ordered_names, embeddings, strict=True):
-            blob = np.array(emb, dtype=np.float32).tobytes()
-            conn.execute(
-                "INSERT INTO icon_embeddings (name, embedding, model) VALUES (?, ?, ?)",
-                (name, blob, DEFAULT_EMBEDDING_MODEL),
-            )
+        for model_id, vectors_by_name in embeddings.items():
+            for name in ordered_names:
+                if name not in vectors_by_name:
+                    continue
+                blob = np.array(vectors_by_name[name], dtype=np.float32).tobytes()
+                conn.execute(
+                    "INSERT INTO icon_embeddings (name, embedding, model)"
+                    " VALUES (?, ?, ?)",
+                    (name, blob, model_id),
+                )
 
         # Load clusters
-        conn.execute("DELETE FROM icon_clusters")
         cluster_data = json.loads(clusters_path.read_text())
         for cid, cluster in cluster_data["clusters"].items():
             theme = cluster.get("theme", f"Cluster {cid}")
@@ -584,10 +599,11 @@ def _write_search_db(  # noqa: PLR0913
         first = records[ordered_names[0]]
         resolved_version = version or first.get("lucide_version", "unknown")
         now = datetime.now(tz=timezone.utc).isoformat()
+        model_dims = json.dumps({mid: EMBEDDING_MODELS[mid].dim for mid in embeddings})
         for key, value in [
             ("version", resolved_version),
-            ("embedding_model", DEFAULT_EMBEDDING_MODEL),
-            ("embedding_dim", str(DEFAULT_EMBEDDING_DIM)),
+            ("schema_version", str(SEARCH_DB_SCHEMA_VERSION)),
+            ("embedding_models", model_dims),
             ("description_model", DEFAULT_VLM_MODEL),
             ("built_at", now),
         ]:
@@ -631,9 +647,10 @@ def build_search_db(
 ) -> None:
     """Build the SQLite search database from descriptions, embeddings, and clusters.
 
-    Reads descriptions from *jsonl_path*, computes embeddings with fastembed,
-    loads cluster assignments from *clusters_path*, and writes everything to
-    *search_db_path*.  The DB is rebuilt from scratch each time.
+    Reads descriptions from *jsonl_path*, computes one embedding set per
+    model in ``EMBEDDING_MODELS`` with fastembed, loads cluster assignments
+    from *clusters_path*, and writes everything to *search_db_path*.  The DB
+    is rebuilt from scratch each time.
 
     When *icons_db_path* is provided, only icons present in that database are
     included and the version metadata is read from it.
@@ -687,12 +704,18 @@ def build_search_db(
         if rec["categories"]:
             parts.append(f"Categories: {', '.join(rec['categories'])}")
         parts.append(rec["description"])
-        return f"{EMBEDDING_DOCUMENT_PREFIX}{'. '.join(parts)}"
-
-    texts = [_embedding_text(records[n]) for n in ordered_names]
-    embedder = TextEmbedding(model_name=DEFAULT_EMBEDDING_MODEL)
-    embeddings = list(embedder.embed(texts))
-    logger.info("Computed %d embeddings", len(embeddings))
+        return ". ".join(parts)
+
+    base_texts = [_embedding_text(records[n]) for n in ordered_names]
+    embeddings: dict[str, dict[str, object]] = {}
+    for model_id, model_cfg in EMBEDDING_MODELS.items():
+        texts = [f"{model_cfg.document_prefix}{t}" for t in base_texts]
+        embedder = TextEmbedding(model_name=model_cfg.fastembed_model)
+        vecs = list(embedder.embed(texts))
+        embeddings[model_id] = dict(zip(ordered_names, vecs, strict=True))
+        logger.info(
+            "Computed %d embeddings with %s", len(texts), model_cfg.fastembed_model
+        )
 
     _write_search_db(
         search_db_path,

{python_lucide-0.3.0 → python_lucide-0.4.0}/src/lucide/cli.py

@@ -24,7 +24,11 @@ import sys
 import tempfile
 from datetime import datetime
 
-from .config import DEFAULT_LUCIDE_TAG
+from .config import (
+    DEFAULT_LUCIDE_TAG,
+    DEFAULT_SEARCH_MODEL_ID,
+    EMBEDDING_MODELS,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -546,7 +550,7 @@ def _cmd_search(args: argparse.Namespace) -> int:
                 os.environ["LUCIDE_SEARCH_DB_PATH"] = str(candidate)
 
     try:
-        results = search_icons(args.query, limit=args.limit)
+        results = search_icons(args.query, limit=args.limit, model=args.model)
     except Exception as e:
         print(f"Error: {e}")
         return 1
@@ -856,6 +860,12 @@ def main() -> int:
         help="Path to the search database",
         default=None,
     )
+    search_parser.add_argument(
+        "--model",
+        choices=sorted(EMBEDDING_MODELS),
+        default=DEFAULT_SEARCH_MODEL_ID,
+        help="Embedding model to search with",
+    )
     search_parser.add_argument(
         "-v",
         "--verbose",

python_lucide-0.4.0/src/lucide/config.py

@@ -0,0 +1,101 @@
+"""Configuration for python-lucide.
+
+This module contains default configuration values used throughout the package.
+"""
+
+from dataclasses import dataclass
+
+# Default Lucide tag to use when building the icon database
+DEFAULT_LUCIDE_TAG = "1.17.0"
+
+# Default size for the LRU cache used by lucide_icon function
+DEFAULT_ICON_CACHE_SIZE = 128
+
+# --- Semantic search ---
+
+
+@dataclass(frozen=True)
+class EmbeddingModelConfig:
+    """One embedding model usable for icon search.
+
+    Each model must be available both as a fastembed ONNX model (build time
+    and Python query time) and as a transformers.js model (browser query
+    time), and the two runtimes must produce identical vectors. ``pooling``
+    is the transformers.js pooling mode that matches fastembed's output for
+    this model — verified empirically (cosine 1.0) before a model is added
+    here; mismatched pooling silently degrades search quality instead of
+    erroring.
+
+    Attributes:
+        id: Short stable identifier stored in the search DB and web manifest.
+        fastembed_model: fastembed model name.
+        web_model: transformers.js (Hugging Face) model id. Empty means the
+            model is Python-only and excluded from the web manifest.
+        dim: Embedding dimensionality.
+        pooling: transformers.js pooling mode ("mean" or "cls").
+        web_dtype: transformers.js quantization. Document vectors always
+            come from fastembed (fp32), so a quantized browser model only
+            perturbs the query vector — q8 stays ~0.994 cosine to fp32,
+            which is ranking-equivalent, and roughly quarters the download.
+        query_prefix: Prefix prepended to queries (asymmetric retrieval).
+        document_prefix: Prefix prepended to documents at build time.
+        label: Human-facing label for the web UI model toggle.
+    """
+
+    id: str
+    dim: int
+    fastembed_model: str = ""
+    web_model: str = ""
+    pooling: str = "mean"
+    web_dtype: str = "fp32"
+    query_prefix: str = ""
+    document_prefix: str = ""
+    label: str = ""
+
+
+EMBEDDING_MODELS: dict[str, EmbeddingModelConfig] = {
+    "minilm": EmbeddingModelConfig(
+        id="minilm",
+        fastembed_model="sentence-transformers/all-MiniLM-L6-v2",
+        web_model="Xenova/all-MiniLM-L6-v2",
+        dim=384,
+        pooling="mean",
+        label="Faster",
+    ),
+    "bge-small": EmbeddingModelConfig(
+        id="bge-small",
+        fastembed_model="BAAI/bge-small-en-v1.5",
+        web_model="Xenova/bge-small-en-v1.5",
+        dim=384,
+        pooling="cls",
+        query_prefix="Represent this sentence for searching relevant passages: ",
+        label="Better",
+    ),
+    "multilingual": EmbeddingModelConfig(
+        id="multilingual",
+        fastembed_model="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
+        web_model="Xenova/paraphrase-multilingual-MiniLM-L12-v2",
+        dim=384,
+        pooling="mean",
+        web_dtype="q8",
+        label="Multilingual",
+    ),
+}
+
+DEFAULT_SEARCH_MODEL_ID = "bge-small"
+
+# VLM used to generate icon descriptions at build time
+DEFAULT_VLM_MODEL = "gemini-2.5-flash-lite"
+
+# Bumped when the search DB layout changes incompatibly (v2: multi-model
+# embeddings keyed by (name, model)). Recorded in the DB metadata and baked
+# into the local cache filename so a stale cache from an older package
+# version is never misread after an upgrade.
+SEARCH_DB_SCHEMA_VERSION = 2
+
+# URL template for downloading pre-built search data.
+# {version} is replaced with the Lucide icon-set version (e.g. "0.577.0").
+SEARCH_DB_URL_TEMPLATE = (
+    "https://github.com/mmacpherson/python-lucide/releases/download/"
+    "search-v{version}/lucide-search.db"
+)

{python_lucide-0.3.0 → python_lucide-0.4.0}/src/lucide/data/lucide-icon-clusters.json

@@ -1767,7 +1767,7 @@
         "dice-6",
         "dices"
       ],
-      "theme": "THINK\nThe user wants a short, evocative theme name (2-4 words) for the icon cluster: `dice-1, dice-2, dice-3, dice-4, dice-5, dice-6, dices`.\nI need to be specific about what unifies them, which is clearly the concept of dice and rolling dice.\nI must not use generic labels.\nI must return ONLY the theme name.\n\nAnalyzing the icons:\n- `dice-1` through `dice-6`: Individual dice faces, showing specific numbers.\n- `dices`: Likely multiple dice, representing the concept of dice as a whole or a roll.\n\nThe unifying concept is \"dice\" and \"rolling/gambling with dice\".\n\nBrainstorming theme names:\n- Rolling Dice\n- Game Dice\n- Dice Roll\n- Lucky Dice\n- Dice Play\n- Gaming Dice\n- Casino Dice\n- Tabletop Dice\n\nConstraints:\n- Short (2-4 words)\n- Evocative\n- Specific\n\n\"Rolling Dice\" is good, 2 words, specific, evocative of action.\n\"Game Dice\" is good, 2 words, specific, implies context.\n\"Dice Roll\" is good, 2 words, specific, implies action/outcome.\n\"Lucky Dice\" is good, 2 words, evocative, specific.\n\"Gaming Dice\" is good, 2 words, specific, implies context.\n\nLet's pick one that feels most direct and comprehensive.\n\"Rolling Dice\" covers the individual dice and the action implied by \"dices\".\n\"Game Dice\" is also very fitting as dice are primarily used in games.\n\n\"Rolling Dice\" feels slightly more dynamic and covers the implied action of the \"dices\" icon (a set being rolled) and the outcome (the individual numbered dice).\n\"Game Dice\" is also very strong as it defines their purpose.\n\nLet's go with \"Rolling Dice\" as it implies the use case and the items. It's direct and clear.\n\"Dice Roll\" is also very good.\n\nComparing \"Rolling Dice\" vs \"Dice Roll\":\n- \"Rolling Dice\": Focuses on the items and the continuous action.\n- \"Dice Roll\": Focuses on the action and its singular outcome.\n\nGiven `dice-1` to `dice-6` (outcomes) and `dices` (the items themselves, likely in motion or a collection), \"Rolling Dice\" seems to encompass both the objects and the action they perform or are associated with.\n\nAnother option: \"Dice Game\". This is also very strong.\n\nLet's reconsider the cluster:\n`dice-1, dice-2, dice-3, dice-4, dice-5, dice-6` are the *results* of a roll.\n`dices` implies the *objects* themselves, perhaps a collection or mid-roll.\n\nSo, the cluster represents both the *tools* (dice) and their *outcomes* (numbered faces).\n\n\"Dice Games\" implies the context.\n\"Rolling Dice\" implies the action and the tools.\n\"Dice Faces\" would only cover the 1-6.\n\nLet's try to capture both the object and the action/outcome.\n\"Dice & Rolls\" - 3 words. Specific.\n\"Dice Game Elements\" - 3 words. Specific.\n\"Game Dice Icons\" - 3 words. Too meta with \"icons\".\n\n\"Rolling Dice\" is still very strong. It suggests the act and the instruments.\nIt's concise and evocative.\n\n\"Gaming Dice\" - 2 words. This is good. It implies their purpose and context.\nIt's specific and covers all aspects (the items themselves and their numbered faces which are used in gaming).\n\nLet's try \"Gaming Dice\".\nIt's 2 words.\nIt's evocative.\nIt's specific: \"dice\" specifically, and \"gaming\" for their primary use. It covers the individual faces (used in gaming) and the collection of dice (used in gaming).\n\nFinal check:\n- Short (2-4 words): Yes, 2 words.\n- Evocative: Yes, suggests a category.\n- Specific about what unifies: Yes, all are dice used for games.\n- No generic labels: No.\n- Return ONLY the theme name: Yes.\n\nI think \"Gaming Dice\" is a very strong contender.\n\"Rolling Dice\" is also strong.\n\nLet's consider which one is more of a *theme name* for a cluster of icons.\n\"Gaming Dice\" feels more like a classification for a group of related items.\n\"Rolling Dice\" feels more like an action. While the icons represent dice that are rolled, \"Gaming Dice\" directly labels what these items fundamentally *are* and *what they are for*.\n\nSo, \"Gaming Dice\" seems a slightly better fit as a theme name for a collection of icons."
+      "theme": "Gaming Dice"
     },
     "18": {
       "icons": [
@@ -2098,7 +2098,7 @@
         "phone-missed",
         "phone-outgoing"
       ],
-      "theme": "THOUGHTS:\n\nThe user wants a short, evocative theme name (2-4 words) for the given icon cluster: `phone, phone-call, phone-forwarded, phone-incoming, phone-missed, phone-outgoing`.\nI need to be specific about what unifies them, avoiding generic labels.\nThe output should ONLY be the theme name.\n\nWhat unifies them?\n- All are related to phone communication.\n- Specifically, they denote different states or types of *calls*.\n- `phone` is the general device.\n- The others describe actions or states of a *call*:\n    - `phone-call` (general call)\n    - `phone-forwarded` (call status)\n    - `phone-incoming` (call direction)\n    - `phone-missed` (call status)\n    - `phone-outgoing` (call direction)\n\nSo, the core is \"phone calls\" and their \"status/direction\".\n\nLet's brainstorm some options:\n1.  **Call History Icons:** \"History\" might be good for missed/incoming/outgoing, but \"phone-call\" and \"phone-forwarded\" don't strictly imply history. \"Phone\" itself is just the device.\n2.  **Phone Call States:** This is accurate. \"States\" covers forwarded, missed, incoming, outgoing. \"Phone call\" covers the base. \"Phone\" is the base device.\n3.  **Call Status Indicators:** Similar to \"States\". \"Indicators\" is good.\n4.  **Telephony Status:** \"Telephony\" is a bit formal.\n5.  **Call Management Icons:** \"Management\" could work, but \"status\" or \"states\" feels more direct for what these icons represent visually.\n6.  **Communication Call Signs:** \"Signs\" is okay, \"Communication\" is good.\n7.  **Voice Call Cues:** \"Voice Call\" is good. \"Cues\" is okay.\n8.  **Phone Interaction States:** \"Interaction\" is good. \"States\" is good.\n9.  **Call Flow Indicators:** \"Flow\" might be too specific.\n10. **Call Activity Indicators:** \"Activity\" covers incoming/outgoing/missed. \"Call\" is central. \"Indicators\" is good. This feels quite comprehensive.\n11. **Phone Call Dynamics:** \"Dynamics\" is interesting, implies movement/change.\n12. **Call Progress Icons:** \"Progress\" could work for forwarded, incoming, outgoing.\n\nLet's re-evaluate \"Phone Call States\" or \"Call Status Indicators\".\n`phone` - the device/general call icon\n`phone-call` - a generic call\n`phone-forwarded` - a state of a call\n`phone-incoming` - a direction/state of a call\n`phone-missed` - a state of a call\n`phone-outgoing` - a direction/state of a call\n\n\"Phone Call States\" - very direct.\n\"Call Status Indicators\" - also very direct.\n\"Call Activity Indicators\" - \"Activity\" is good for incoming/outgoing/missed. \"Status\" feels more encompassing for \"forwarded\" and \"phone-call\".\n\nI need it to be 2-4 words.\n\n*   \"Call Status Icons\" (3 words) - Good.\n*   \"Phone Call States\" (3 words) - Also good.\n*   \"Telephony Call States\" (3 words) - \"Telephony\" is a bit jargon-y.\n*   \"Call Interaction Icons\" (3 words) - \"Interaction\" is good.\n*   \"Communication Call Status\" (3 words) - Very good.\n*   \"Call Event Indicators\" (3 words) - \"Event\" captures the 'missed', 'incoming', 'outgoing'. 'Forwarded' is also an event. 'Phone-call' is a general event. 'Phone' is the device.\n\nLet's consider \"Call Event Indicators\".\n- `phone`: General call/device.\n- `phone-call`: A call event.\n- `phone-forwarded`: An event (call was forwarded).\n- `phone-incoming`: An event (call incoming).\n- `phone-missed`: An event (call was missed).\n- `phone-outgoing`: An event (call outgoing).\nThis seems to fit all very well. It's specific and descriptive.\n\nIt's 3 words, fits the criteria.\n\"Call Event Indicators\" or \"Call Status Indicators\".\n\"Event\" feels slightly better as it covers the happening of something (incoming, outgoing, missed, forwarded) rather than just its static state. A \"missed\" call is an event. \"Forwarded\" is an event.\n\nLet's go with \"Call Event Indicators\". It captures the dynamic nature and the record-keeping aspect implied by many of these.\nIt's short, evocative (in a functional way), and specific.\nIt avoids generic terms.\nIt unifies them as representations of different occurrences or states related to phone calls."
+      "theme": "Call Event Indicators"
     },
     "60": {
       "icons": [