feat: add Ollama embedder and interactive embedder selection dialog

OllamaEmbedder (embedding/ollama.py):
- Free local embeddings via ollama's OpenAI-compatible /v1/embeddings API
- Default model: nomic-embed-text (768 dims)
- Supports mxbai-embed-large, all-minilm, snowflake-arctic-embed, etc.
- Graceful errors: tells user to run 'ollama serve' or 'ollama pull <model>'

Interactive embedder dialog (ui.py → interactive_embedder_select):
- Shows table: ollama / openai / gemini / mock with availability status
- Smart default: preselects ollama when free-code or ollama is the LLM provider
- Shown automatically in init_cmd after provider selection when --embedder
  flag is not explicitly set

init_cmd.py:
- Calls interactive_embedder_select after interactive_provider_select
- Adds 'ollama' branch to the embedder switch
- Updates --embedder help text to include ollama

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dmikushin

packages/cli/src/repowise/cli/commands/init_cmd.py

@@ -188,7 +188,7 @@ async def _persist_result(
     "embedder_name",
     default=None,
     type=click.Choice(["gemini", "openai", "mock"]),
-    help="Embedder for RAG: gemini | openai | mock (default: auto-detect).",
+    help="Embedder for RAG: ollama | gemini | openai | mock (default: interactive).",
 )
 @click.option("--skip-tests", is_flag=True, default=False, help="Skip test files.")
 @click.option("--skip-infra", is_flag=True, default=False, help="Skip infrastructure files.")
@@ -377,9 +377,13 @@ def init_command(
                 )
     else:
         if not is_interactive and provider_name is None and sys.stdin.isatty():
+            from repowise.cli.ui import interactive_embedder_select as _ies
             from repowise.cli.ui import interactive_provider_select as _ips
 
             provider_name, model = _ips(console, model)
+            # Show embedder dialog only when not explicitly set via --embedder flag
+            if embedder_name is None:
+                embedder_name_resolved = _ies(console, llm_provider=provider_name)
 
         provider = resolve_provider(provider_name, model, repo_path)
         if not is_interactive:
@@ -500,6 +504,13 @@ def init_command(
                 embedder_impl = OpenAIEmbedder()
             except Exception:
                 embedder_impl = MockEmbedder()
+        elif embedder_name_resolved == "ollama":
+            try:
+                from repowise.core.providers.embedding.ollama import OllamaEmbedder
+
+                embedder_impl = OllamaEmbedder()
+            except Exception:
+                embedder_impl = MockEmbedder()
         else:
             embedder_impl = MockEmbedder()
 

packages/cli/src/repowise/cli/ui.py

@@ -335,6 +335,120 @@ def interactive_provider_select(
     return chosen, model
 
 
+# ---------------------------------------------------------------------------
+# Interactive embedder selection
+# ---------------------------------------------------------------------------
+
+_EMBEDDER_DEFS: list[dict] = [
+    {
+        "id": "ollama",
+        "label": "Ollama (local, free)",
+        "hint": "nomic-embed-text · requires: ollama pull nomic-embed-text",
+        "requires_key": False,
+        "env_keys": [],
+        "default_model": "nomic-embed-text",
+    },
+    {
+        "id": "openai",
+        "label": "OpenAI",
+        "hint": "text-embedding-3-small · requires OPENAI_API_KEY",
+        "requires_key": True,
+        "env_keys": ["OPENAI_API_KEY"],
+        "default_model": "text-embedding-3-small",
+    },
+    {
+        "id": "gemini",
+        "label": "Google Gemini",
+        "hint": "gemini-embedding-exp-03-07 · requires GEMINI_API_KEY",
+        "requires_key": True,
+        "env_keys": ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+        "default_model": "gemini-embedding-exp-03-07",
+    },
+    {
+        "id": "mock",
+        "label": "Mock (no cost, no quality)",
+        "hint": "deterministic 8-dim vectors — OK for testing / index-only",
+        "requires_key": False,
+        "env_keys": [],
+        "default_model": "",
+    },
+]
+
+_EMBEDDER_BY_ID = {e["id"]: e for e in _EMBEDDER_DEFS}
+
+
+def _detect_embedder_key(emb: dict) -> bool:
+    """Return True if the embedder's key is available in the environment."""
+    if not emb["requires_key"]:
+        return True
+    return any(os.environ.get(k) for k in emb["env_keys"])
+
+
+def interactive_embedder_select(
+    console: Console,
+    *,
+    llm_provider: str | None = None,
+) -> str:
+    """Show embedder table and let the user choose.
+
+    Returns the embedder id string (e.g. 'ollama', 'openai', 'gemini', 'mock').
+    """
+    table = Table(
+        show_header=True,
+        box=None,
+        padding=(0, 2),
+        title="[bold]Embedder Setup[/bold]",
+        title_style="",
+    )
+    table.add_column("#", style=BRAND_STYLE, width=4)
+    table.add_column("Embedder", style="bold", min_width=24)
+    table.add_column("Info", style="dim")
+
+    available: list[str] = []
+    default_idx = "1"
+
+    for idx, emb in enumerate(_EMBEDDER_DEFS, 1):
+        has_key = _detect_embedder_key(emb)
+        if has_key:
+            status_char = f"[{OK}]✓[/]"
+        else:
+            status_char = "[dim]✗[/dim]"
+        table.add_row(f"[{idx}]", f"{status_char} {emb['label']}", emb["hint"])
+        available.append(emb["id"])
+        # Smart default: prefer ollama when llm_provider is free-code or ollama,
+        # otherwise prefer the first embedder whose key is set
+        if default_idx == "1":
+            if llm_provider in ("free-code", "ollama") and emb["id"] == "ollama":
+                default_idx = str(idx)
+            elif has_key and emb["id"] not in ("mock",):
+                default_idx = str(idx)
+
+    console.print()
+    console.print(table)
+    console.print()
+
+    valid_choices = [str(i) for i in range(1, len(available) + 1)]
+    chosen_idx = Prompt.ask(
+        "  Select embedder",
+        choices=valid_choices,
+        default=default_idx,
+        console=console,
+    )
+    chosen = available[int(chosen_idx) - 1]
+
+    if chosen == "ollama":
+        base_url = os.environ.get("OLLAMA_BASE_URL", "http://localhost:11434")
+        console.print()
+        console.print(f"  [dim]Ollama endpoint: [cyan]{base_url}[/cyan][/dim]")
+        console.print(
+            "  [dim]Make sure the model is pulled: "
+            "[bold]ollama pull nomic-embed-text[/bold][/dim]"
+        )
+        console.print()
+
+    return chosen
+
+
 def _prompt_api_key(
     console: Console,
     provider: str,

packages/core/src/repowise/core/providers/embedding/ollama.py

@@ -0,0 +1,157 @@
+"""Ollama embedding support for repowise semantic search.
+
+Uses Ollama's OpenAI-compatible /v1/embeddings endpoint so no extra
+dependencies are needed beyond the openai package already required.
+
+Prerequisites:
+    1. Install Ollama: https://ollama.com/download
+    2. Pull an embedding model: ollama pull nomic-embed-text
+
+Popular embedding models:
+    nomic-embed-text   768 dims — fast, good quality (recommended default)
+    mxbai-embed-large 1024 dims — higher quality, slower
+    all-minilm         384 dims — very fast, lower quality
+
+Usage:
+    from repowise.core.providers.embedding.ollama import OllamaEmbedder
+    embedder = OllamaEmbedder(model="nomic-embed-text")
+    vecs = await embedder.embed(["hello world"])
+"""
+
+from __future__ import annotations
+
+import asyncio
+import math
+import os
+
+_DEFAULT_BASE_URL = "http://localhost:11434"
+_DEFAULT_MODEL = "nomic-embed-text"
+
+# Known dimensions for common ollama embedding models.
+# For unknown models we run a probe request at construction time.
+_KNOWN_DIMS: dict[str, int] = {
+    "nomic-embed-text": 768,
+    "mxbai-embed-large": 1024,
+    "all-minilm": 384,
+    "snowflake-arctic-embed": 1024,
+    "bge-large": 1024,
+    "bge-m3": 1024,
+}
+
+
+class OllamaEmbedder:
+    """Ollama embedding adapter implementing the repowise Embedder protocol.
+
+    Calls Ollama's OpenAI-compatible /v1/embeddings endpoint. No API key
+    required — Ollama runs locally.
+
+    Args:
+        model:    Ollama embedding model name. Default: nomic-embed-text.
+        base_url: Ollama server URL. Default: http://localhost:11434.
+                  Override via OLLAMA_BASE_URL env var.
+    """
+
+    def __init__(
+        self,
+        model: str = _DEFAULT_MODEL,
+        base_url: str | None = None,
+    ) -> None:
+        resolved_url = (
+            base_url
+            or os.environ.get("OLLAMA_BASE_URL")
+            or _DEFAULT_BASE_URL
+        )
+        # Normalise: strip trailing slash, ensure no /v1 suffix
+        resolved_url = resolved_url.rstrip("/")
+        if resolved_url.endswith("/v1"):
+            resolved_url = resolved_url[:-3]
+
+        self._model = model
+        self._base_url = resolved_url
+        self._openai_base_url = f"{resolved_url}/v1"
+        self._dims: int | None = _KNOWN_DIMS.get(model)
+        self._client: object | None = None
+
+    @property
+    def dimensions(self) -> int:
+        if self._dims is None:
+            # Probe synchronously on first access if unknown
+            import asyncio as _asyncio
+            try:
+                loop = _asyncio.get_event_loop()
+                if loop.is_running():
+                    # Can't block — return a reasonable default
+                    return 768
+                self._dims = loop.run_until_complete(self._probe_dimensions())
+            except Exception:
+                self._dims = 768
+        return self._dims
+
+    async def _probe_dimensions(self) -> int:
+        """Embed a single token to discover the model's output dimension."""
+        vecs = await self.embed(["probe"])
+        return len(vecs[0]) if vecs else 768
+
+    def _get_client(self) -> object:
+        if self._client is None:
+            import openai  # type: ignore[import-untyped]
+            self._client = openai.OpenAI(
+                api_key="ollama",  # Ollama ignores the key
+                base_url=self._openai_base_url,
+                timeout=30.0,
+            )
+        return self._client
+
+    async def embed(self, texts: list[str]) -> list[list[float]]:
+        """Embed a batch of texts using the local Ollama embedding model.
+
+        Args:
+            texts: Non-empty list of strings to embed.
+
+        Returns:
+            List of L2-normalized float vectors.
+
+        Raises:
+            RuntimeError: If Ollama is not reachable or the model is not pulled.
+        """
+        if not texts:
+            return []
+
+        model = self._model
+
+        def _embed_sync() -> list[list[float]]:
+            import openai  # type: ignore[import-untyped]
+
+            client = self._get_client()
+            try:
+                response = client.embeddings.create(model=model, input=texts)  # type: ignore[union-attr]
+            except openai.APIConnectionError as exc:
+                raise RuntimeError(
+                    f"Cannot reach Ollama at {self._base_url}. "
+                    "Is it running? Start with: ollama serve"
+                ) from exc
+            except openai.APIStatusError as exc:
+                if exc.status_code == 404:
+                    raise RuntimeError(
+                        f"Ollama model '{model}' not found. "
+                        f"Pull it first: ollama pull {model}"
+                    ) from exc
+                raise RuntimeError(f"Ollama embedding error: {exc}") from exc
+
+            raw_vectors = [list(item.embedding) for item in response.data]
+            result = [_l2_normalize(v) for v in raw_vectors]
+
+            # Cache discovered dimensions
+            if self._dims is None and result:
+                self._dims = len(result[0])
+
+            return result
+
+        return await asyncio.to_thread(_embed_sync)
+
+
+def _l2_normalize(vec: list[float]) -> list[float]:
+    norm = math.sqrt(sum(x * x for x in vec))
+    if norm == 0.0:
+        norm = 1.0
+    return [x / norm for x in vec]