kolega-code 0.1.0__py3-none-any.whl

kolega_code/cli/config.py

@@ -0,0 +1,280 @@
+"""Configuration helpers for the Kolega Code CLI."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Mapping, Optional
+
+from dotenv import dotenv_values
+
+from kolega_code.config import AgentConfig, ModelConfig, ModelProvider, RateLimitConfig
+from kolega_code.llm.specs import get_model_specs
+
+from .provider_registry import UI_DEFAULT_PROVIDER, default_model_for_provider
+from .settings import CliSettings
+
+DEFAULT_LONG_PROVIDER = ModelProvider.ANTHROPIC
+DEFAULT_LONG_MODEL = "claude-opus-4-7"
+DEFAULT_FAST_PROVIDER = ModelProvider.ANTHROPIC
+DEFAULT_FAST_MODEL = "claude-haiku-4-5-20251001"
+DEFAULT_EDIT_PROVIDER = ModelProvider.ANTHROPIC
+DEFAULT_EDIT_MODEL = "claude-sonnet-4-6"
+DEFAULT_THINKING_PROVIDER = ModelProvider.ANTHROPIC
+DEFAULT_THINKING_MODEL = "claude-opus-4-7"
+DEFAULT_THINKING_TOKENS = 1024
+
+API_KEY_ENV = {
+    ModelProvider.ANTHROPIC: "ANTHROPIC_API_KEY",
+    ModelProvider.OPENAI: "OPENAI_API_KEY",
+    ModelProvider.GOOGLE: "GOOGLE_API_KEY",
+    ModelProvider.GROQ: "GROQ_API_KEY",
+    ModelProvider.TOGETHER: "TOGETHER_API_KEY",
+    ModelProvider.FIREWORKS: "FIREWORKS_API_KEY",
+    ModelProvider.XAI: "XAI_API_KEY",
+    ModelProvider.DASHSCOPE: "DASHSCOPE_API_KEY",
+    ModelProvider.MOONSHOT: "MOONSHOT_API_KEY",
+    ModelProvider.DEEPSEEK: "DEEPSEEK_API_KEY",
+}
+
+
+class CliConfigError(ValueError):
+    """Raised when CLI configuration is incomplete or invalid."""
+
+
+@dataclass(frozen=True)
+class CliConfigOverrides:
+    """Model and provider overrides supplied by CLI flags."""
+
+    provider: Optional[str] = None
+    model: Optional[str] = None
+    fast_provider: Optional[str] = None
+    fast_model: Optional[str] = None
+    edit_provider: Optional[str] = None
+    edit_model: Optional[str] = None
+    thinking_provider: Optional[str] = None
+    thinking_model: Optional[str] = None
+    thinking_tokens: Optional[int] = None
+    environment: Optional[str] = None
+
+
+def load_cli_env(project_path: Path, env: Optional[Mapping[str, str]] = None) -> dict[str, str]:
+    """Load process environment over a project-local .env file."""
+    base_env = dict(env if env is not None else os.environ)
+    dotenv_path = project_path / ".env"
+    if not dotenv_path.exists():
+        return base_env
+
+    file_env = {key: value for key, value in dotenv_values(dotenv_path).items() if value is not None}
+    return {**file_env, **base_env}
+
+
+def _env_or_default(
+    env: Mapping[str, str],
+    key: str,
+    override: Optional[str],
+    default: str,
+) -> str:
+    if override:
+        return override
+    return env.get(key) or default
+
+
+def _provider(value: str) -> ModelProvider:
+    try:
+        return ModelProvider(value.lower())
+    except ValueError as exc:
+        valid = ", ".join(provider.value for provider in ModelProvider)
+        raise CliConfigError(f"Unsupported provider '{value}'. Valid providers: {valid}") from exc
+
+
+def _api_key_for_provider(
+    provider: ModelProvider,
+    env: Mapping[str, str],
+    settings: Optional[CliSettings],
+) -> Optional[str]:
+    env_name = API_KEY_ENV.get(provider)
+    if env_name and env.get(env_name):
+        return env[env_name]
+    if settings:
+        return settings.get_api_key(provider.value)
+    return None
+
+
+def _active_provider_model(
+    env: Mapping[str, str],
+    overrides: CliConfigOverrides,
+    settings: Optional[CliSettings],
+) -> tuple[Optional[ModelProvider], Optional[str]]:
+    provider_value = overrides.provider or env.get("KOLEGA_CODE_PROVIDER")
+    model_value = overrides.model or env.get("KOLEGA_CODE_MODEL")
+
+    if provider_value or model_value:
+        provider = _provider(provider_value or DEFAULT_LONG_PROVIDER.value)
+        return provider, model_value or default_model_for_provider(provider)
+
+    if settings and (settings.active_provider or settings.active_model):
+        provider = _provider(settings.active_provider or UI_DEFAULT_PROVIDER)
+        return provider, settings.active_model or default_model_for_provider(provider)
+
+    return None, None
+
+
+def _slot_provider_model(
+    env: Mapping[str, str],
+    provider_env_key: str,
+    model_env_key: str,
+    provider_override: Optional[str],
+    model_override: Optional[str],
+    default_provider: ModelProvider,
+    default_model: str,
+    active_provider: Optional[ModelProvider],
+    active_model: Optional[str],
+) -> tuple[ModelProvider, str]:
+    provider_value = provider_override or env.get(provider_env_key)
+    model_value = model_override or env.get(model_env_key)
+
+    if provider_value or model_value:
+        provider = _provider(provider_value or (active_provider.value if active_provider else default_provider.value))
+        return provider, model_value or (
+            active_model if active_provider == provider and active_model else default_model_for_provider(provider)
+        )
+
+    if active_provider and active_model:
+        return active_provider, active_model
+
+    return default_provider, default_model
+
+
+def _model_config(provider: ModelProvider, model: str, thinking_tokens: Optional[int] = None) -> ModelConfig:
+    try:
+        get_model_specs(provider, model)
+    except ValueError as exc:
+        raise CliConfigError(str(exc)) from exc
+
+    return ModelConfig(
+        provider=provider,
+        model=model,
+        rate_limits=RateLimitConfig(),
+        thinking_tokens=thinking_tokens,
+    )
+
+
+def build_agent_config(
+    project_path: Path,
+    overrides: Optional[CliConfigOverrides] = None,
+    env: Optional[Mapping[str, str]] = None,
+    settings: Optional[CliSettings] = None,
+) -> AgentConfig:
+    """Build an AgentConfig for CLI-hosted agents."""
+    overrides = overrides or CliConfigOverrides()
+    loaded_env = load_cli_env(project_path, env)
+
+    active_provider, active_model = _active_provider_model(loaded_env, overrides, settings)
+
+    long_provider, long_model = _slot_provider_model(
+        loaded_env,
+        "KOLEGA_CODE_PROVIDER",
+        "KOLEGA_CODE_MODEL",
+        overrides.provider,
+        overrides.model,
+        DEFAULT_LONG_PROVIDER,
+        DEFAULT_LONG_MODEL,
+        active_provider,
+        active_model,
+    )
+    fast_provider, fast_model = _slot_provider_model(
+        loaded_env,
+        "KOLEGA_CODE_FAST_PROVIDER",
+        "KOLEGA_CODE_FAST_MODEL",
+        overrides.fast_provider,
+        overrides.fast_model,
+        DEFAULT_FAST_PROVIDER,
+        DEFAULT_FAST_MODEL,
+        active_provider,
+        active_model,
+    )
+    edit_provider, edit_model = _slot_provider_model(
+        loaded_env,
+        "KOLEGA_CODE_EDIT_PROVIDER",
+        "KOLEGA_CODE_EDIT_MODEL",
+        overrides.edit_provider,
+        overrides.edit_model,
+        DEFAULT_EDIT_PROVIDER,
+        DEFAULT_EDIT_MODEL,
+        active_provider,
+        active_model,
+    )
+    thinking_provider, thinking_model = _slot_provider_model(
+        loaded_env,
+        "KOLEGA_CODE_THINKING_PROVIDER",
+        "KOLEGA_CODE_THINKING_MODEL",
+        overrides.thinking_provider,
+        overrides.thinking_model,
+        DEFAULT_THINKING_PROVIDER,
+        DEFAULT_THINKING_MODEL,
+        active_provider,
+        active_model,
+    )
+    thinking_tokens = overrides.thinking_tokens or int(
+        loaded_env.get("KOLEGA_CODE_THINKING_TOKENS", str(DEFAULT_THINKING_TOKENS))
+    )
+
+    required_providers = {long_provider, fast_provider, edit_provider, thinking_provider}
+    missing_keys = [
+        API_KEY_ENV[provider]
+        for provider in sorted(required_providers, key=lambda item: item.value)
+        if provider != ModelProvider.LLAMA and not _api_key_for_provider(provider, loaded_env, settings)
+    ]
+    if missing_keys:
+        raise CliConfigError(f"Missing required API key environment variable(s): {', '.join(missing_keys)}")
+
+    try:
+        return AgentConfig(
+            anthropic_api_key=_api_key_for_provider(ModelProvider.ANTHROPIC, loaded_env, settings),
+            openai_api_key=_api_key_for_provider(ModelProvider.OPENAI, loaded_env, settings),
+            google_api_key=_api_key_for_provider(ModelProvider.GOOGLE, loaded_env, settings),
+            groq_api_key=_api_key_for_provider(ModelProvider.GROQ, loaded_env, settings),
+            together_api_key=_api_key_for_provider(ModelProvider.TOGETHER, loaded_env, settings),
+            fireworks_api_key=_api_key_for_provider(ModelProvider.FIREWORKS, loaded_env, settings),
+            xai_api_key=_api_key_for_provider(ModelProvider.XAI, loaded_env, settings),
+            dashscope_api_key=_api_key_for_provider(ModelProvider.DASHSCOPE, loaded_env, settings),
+            moonshot_api_key=_api_key_for_provider(ModelProvider.MOONSHOT, loaded_env, settings),
+            deepseek_api_key=_api_key_for_provider(ModelProvider.DEEPSEEK, loaded_env, settings),
+            environment=overrides.environment or loaded_env.get("KOLEGA_CODE_ENVIRONMENT", "development"),
+            long_context_config=_model_config(long_provider, long_model),
+            fast_config=_model_config(fast_provider, fast_model),
+            edit_model_config=_model_config(edit_provider, edit_model),
+            thinking_config=_model_config(thinking_provider, thinking_model, thinking_tokens=thinking_tokens),
+        )
+    except ValueError as exc:
+        raise CliConfigError(str(exc)) from exc
+
+
+def key_status(provider: str, project_path: Path, settings: Optional[CliSettings] = None) -> str:
+    """Return the API-key source for display without exposing the key."""
+    provider_value = _provider(provider)
+    env = load_cli_env(project_path)
+    env_name = API_KEY_ENV.get(provider_value)
+    if env_name and env.get(env_name):
+        return f"present via {env_name}"
+    if settings and settings.get_api_key(provider_value.value):
+        return "present in local settings"
+    return "missing"
+
+
+def config_summary(config: AgentConfig) -> dict[str, str | int | None]:
+    """Return a session-safe summary of model configuration."""
+    return {
+        "environment": config.environment,
+        "long_provider": config.long_context_config.provider.value,
+        "long_model": config.long_context_config.model,
+        "fast_provider": config.fast_config.provider.value,
+        "fast_model": config.fast_config.model,
+        "edit_provider": config.edit_model_config.provider.value,
+        "edit_model": config.edit_model_config.model,
+        "thinking_provider": config.thinking_config.provider.value,
+        "thinking_model": config.thinking_config.model,
+        "thinking_tokens": config.thinking_config.thinking_tokens,
+    }

kolega_code/cli/connection.py

@@ -0,0 +1,49 @@
+"""CLI event bridge for agent broadcasts."""
+
+from __future__ import annotations
+
+import asyncio
+from collections import Counter
+from typing import Any
+
+from kolega_code.events import AgentConnectionManager
+from kolega_code.events import AgentEvent
+
+
+class CliConnectionManager(AgentConnectionManager):
+    """Connection manager that exposes agent broadcasts through an asyncio queue."""
+
+    def __init__(self) -> None:
+        self.events: asyncio.Queue[AgentEvent] = asyncio.Queue()
+        self._connections: Counter[tuple[str, str, str]] = Counter()
+
+    async def connect(
+        self,
+        websocket: Any,
+        workspace_id: str,
+        thread_id: str,
+        connection_type: str,
+        user_info=None,
+    ) -> None:
+        self._connections[(workspace_id, thread_id, connection_type)] += 1
+
+    def disconnect(self, websocket: Any, workspace_id: str, thread_id: str, connection_type: str) -> None:
+        key = (workspace_id, thread_id, connection_type)
+        if self._connections[key] > 1:
+            self._connections[key] -= 1
+        else:
+            self._connections.pop(key, None)
+
+    async def broadcast_event(self, event: AgentEvent, workspace_id: str, thread_id: str) -> None:
+        await self.events.put(event)
+
+    def get_connection_count(self, workspace_id: str, thread_id: str) -> dict:
+        counts: dict[str, int] = {}
+        for (ws_id, th_id, connection_type), count in self._connections.items():
+            if ws_id == workspace_id and th_id == thread_id:
+                counts[connection_type] = count
+        return counts
+
+    async def next_event(self) -> AgentEvent:
+        """Return the next broadcast event."""
+        return await self.events.get()

kolega_code/cli/file_index.py

@@ -0,0 +1,147 @@
+"""Workspace file index powering @ mention autocomplete in the CLI."""
+
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import List, Optional
+
+import pathspec
+
+from kolega_code.agent.tool_backend.glob_tool import GlobTool
+
+
+@dataclass(frozen=True)
+class IndexEntry:
+    path: str  # relative to project root, posix-style separators
+    is_dir: bool
+
+
+class WorkspaceFileIndex:
+    """Cached, gitignore-aware listing of workspace files for completion."""
+
+    MAX_FILES = 5000
+    TTL_SECONDS = 5.0
+
+    def __init__(self, project_path: Path) -> None:
+        self.project_path = Path(project_path)
+        self._entries: List[IndexEntry] = []
+        self._refreshed_at: Optional[float] = None
+
+    def entries(self) -> List[IndexEntry]:
+        now = time.monotonic()
+        if self._refreshed_at is None or now - self._refreshed_at > self.TTL_SECONDS:
+            self.refresh()
+        return self._entries
+
+    def refresh(self) -> None:
+        gitignore = self._load_gitignore_spec()
+        entries: List[IndexEntry] = []
+        root = self.project_path
+        for dirpath, dirnames, filenames in os.walk(root, topdown=True):
+            rel_dir = Path(dirpath).relative_to(root)
+            kept_dirs = []
+            for name in sorted(dirnames):
+                if name in GlobTool.EXCLUDE_DIRS:
+                    continue
+                rel = self._posix(rel_dir / name)
+                if gitignore is not None and gitignore.match_file(rel + "/"):
+                    continue
+                kept_dirs.append(name)
+                entries.append(IndexEntry(path=rel + "/", is_dir=True))
+            dirnames[:] = kept_dirs
+
+            for name in sorted(filenames):
+                if Path(name).suffix.lower() in GlobTool.BINARY_EXTENSIONS:
+                    continue
+                rel = self._posix(rel_dir / name)
+                if gitignore is not None and gitignore.match_file(rel):
+                    continue
+                entries.append(IndexEntry(path=rel, is_dir=False))
+
+            if len(entries) >= self.MAX_FILES:
+                entries = entries[: self.MAX_FILES]
+                break
+
+        self._entries = entries
+        self._refreshed_at = time.monotonic()
+
+    def search(self, query: str, limit: int = 8) -> List[IndexEntry]:
+        scored = []
+        for entry in self.entries():
+            score = fuzzy_score(query, entry.path)
+            if score is not None:
+                scored.append((score, entry))
+        scored.sort(key=lambda pair: (-pair[0], pair[1].path))
+        return [entry for _, entry in scored[:limit]]
+
+    def _load_gitignore_spec(self) -> Optional[pathspec.PathSpec]:
+        gitignore_path = self.project_path / ".gitignore"
+        try:
+            if not gitignore_path.is_file():
+                return None
+            content = gitignore_path.read_text(encoding="utf-8")
+            return pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, content.splitlines())
+        except Exception:
+            return None
+
+    @staticmethod
+    def _posix(path: Path) -> str:
+        rel = str(PurePosixPath(path.as_posix()))
+        return "" if rel == "." else rel
+
+
+def fuzzy_score(query: str, path: str) -> Optional[float]:
+    """Score how well ``query`` matches ``path``; higher is better, None means no match.
+
+    Case-insensitive subsequence match with bonuses for consecutive runs,
+    matches at path-segment boundaries, and matches inside the basename.
+    """
+    if not query:
+        # Empty query matches everything; prefer shallow paths.
+        return -float(path.count("/"))
+
+    q = query.lower()
+    p = path.lower()
+    basename_start = p.rstrip("/").rfind("/") + 1
+    penalty = path.count("/") * 0.5 + len(path) * 0.01
+
+    # Substring matches outrank scattered subsequences.
+    idx = p.find(q)
+    if idx != -1:
+        score = 100.0
+        if idx >= basename_start:
+            score += 50.0
+        if idx == 0 or p[idx - 1] in "/._-":
+            score += 25.0
+        return score - penalty
+
+    # Subsequence match: try a basename-anchored scan too, so dense matches in
+    # the filename beat scattered matches that start in the directory part.
+    full = _subsequence_score(q, p, 0, basename_start)
+    anchored = _subsequence_score(q, p, basename_start, basename_start)
+    candidates = [score for score in (full, anchored) if score is not None]
+    if not candidates:
+        return None
+    return max(candidates) - penalty
+
+
+def _subsequence_score(q: str, p: str, start: int, basename_start: int) -> Optional[float]:
+    score = 0.0
+    pos = start - 1
+    prev_matched = -2
+    for ch in q:
+        pos = p.find(ch, pos + 1)
+        if pos == -1:
+            return None
+        if pos == prev_matched + 1:
+            score += 3.0  # consecutive run
+        if pos == 0 or p[pos - 1] in "/._-":
+            score += 5.0  # segment/word boundary
+        if pos >= basename_start:
+            score += 2.0
+        prev_matched = pos
+        score += 1.0
+    return score