kolega-code 0.1.0__py3-none-any.whl

kolega_code/cli/tests/test_skills.py

@@ -0,0 +1,157 @@
+from pathlib import Path
+
+import pytest
+
+from kolega_code.cli.skills import activated_skill_names, discover_skills
+from kolega_code.llm.models import Message, TextBlock, ToolResult
+
+
+def write_skill(root: Path, name: str, description: str = "Use this skill for testing.", body: str = "Do the work.") -> Path:
+    skill_dir = root / name
+    skill_dir.mkdir(parents=True)
+    skill_file = skill_dir / "SKILL.md"
+    skill_file.write_text(
+        f"---\nname: {name}\ndescription: {description}\n---\n\n{body}\n",
+        encoding="utf-8",
+    )
+    return skill_dir
+
+
+def test_discover_skills_loads_user_and_project_spec_paths(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    user_home = tmp_path / "home"
+    project.mkdir()
+
+    user_skills = user_home / ".agents" / "skills"
+    project_skills = project / ".agents" / "skills"
+    write_skill(user_skills, "user-skill", "Use this user skill.")
+    write_skill(project_skills, "project-skill", "Use this project skill.")
+
+    catalog = discover_skills(project, user_home=user_home)
+
+    assert list(catalog.skills) == ["project-skill", "user-skill"]
+    assert catalog.skills["project-skill"].scope == "project"
+    assert catalog.skills["user-skill"].scope == "user"
+
+
+def test_discover_skills_does_not_scan_singular_project_agent_path(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    user_home = tmp_path / "home"
+    project.mkdir()
+    write_skill(project / ".agent" / "skills", "ignored-skill", "Use this ignored skill.")
+
+    catalog = discover_skills(project, user_home=user_home)
+
+    assert "ignored-skill" not in catalog.skills
+
+
+def test_project_skill_overrides_user_skill_with_same_name(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    user_home = tmp_path / "home"
+    project.mkdir()
+    write_skill(user_home / ".agents" / "skills", "shared-skill", "Use the user skill.", body="user body")
+    write_skill(project / ".agents" / "skills", "shared-skill", "Use the project skill.", body="project body")
+
+    catalog = discover_skills(project, user_home=user_home)
+
+    assert catalog.skills["shared-skill"].scope == "project"
+    assert "project body" in catalog.activation_content("shared-skill")
+    assert any("overrides user skill" in diagnostic.message for diagnostic in catalog.diagnostics)
+
+
+def test_discover_skills_supports_folded_yaml_description(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    user_home = tmp_path / "home"
+    skills_root = project / ".agents" / "skills"
+    skill_dir = skills_root / "folded-skill"
+    skill_dir.mkdir(parents=True)
+    (skill_dir / "SKILL.md").write_text(
+        """---
+name: folded-skill
+description: >
+  Use this folded skill
+  when testing YAML descriptions.
+---
+
+Follow folded instructions.
+""",
+        encoding="utf-8",
+    )
+
+    catalog = discover_skills(project, user_home=user_home)
+
+    assert catalog.skills["folded-skill"].description == "Use this folded skill when testing YAML descriptions."
+
+
+def test_discover_skills_skips_missing_description_and_malformed_yaml(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    user_home = tmp_path / "home"
+    skills_root = project / ".agents" / "skills"
+    missing = skills_root / "missing-description"
+    malformed = skills_root / "malformed-skill"
+    missing.mkdir(parents=True)
+    malformed.mkdir(parents=True)
+    (missing / "SKILL.md").write_text("---\nname: missing-description\n---\nbody\n", encoding="utf-8")
+    (malformed / "SKILL.md").write_text(
+        "---\nname: malformed-skill\ndescription: Use when: yaml breaks\n---\nbody\n",
+        encoding="utf-8",
+    )
+
+    catalog = discover_skills(project, user_home=user_home)
+
+    assert catalog.skills == {}
+    assert len(catalog.diagnostics) == 2
+    assert all(diagnostic.severity == "error" for diagnostic in catalog.diagnostics)
+
+
+def test_activation_content_wraps_body_and_lists_resources(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    user_home = tmp_path / "home"
+    skill_dir = write_skill(project / ".agents" / "skills", "resource-skill", "Use resources.", body="# Steps")
+    (skill_dir / "references").mkdir()
+    (skill_dir / "references" / "guide.md").write_text("reference content", encoding="utf-8")
+    (skill_dir / "scripts").mkdir()
+    (skill_dir / "scripts" / "run.py").write_text("print('ok')", encoding="utf-8")
+
+    catalog = discover_skills(project, user_home=user_home)
+    content = catalog.activation_content("resource-skill")
+
+    assert '<skill_content name="resource-skill">' in content
+    assert "# Steps" in content
+    assert "Skill directory:" in content
+    assert "<file>references/guide.md</file>" in content
+    assert "<file>scripts/run.py</file>" in content
+    assert "name: resource-skill" not in content
+
+
+def test_read_resource_rejects_path_traversal_and_caps_content(tmp_path: Path) -> None:
+    project = tmp_path / "project"
+    user_home = tmp_path / "home"
+    skill_dir = write_skill(project / ".agents" / "skills", "read-skill")
+    (skill_dir / "big.txt").write_text("a" * 20, encoding="utf-8")
+
+    catalog = discover_skills(project, user_home=user_home)
+
+    assert catalog.read_resource("read-skill", "big.txt", max_chars=5).startswith("aaaaa\n\n[truncated")
+    with pytest.raises(ValueError, match="inside the skill directory"):
+        catalog.read_resource("read-skill", "../SKILL.md")
+
+
+def test_activated_skill_names_scans_text_and_tool_results() -> None:
+    history = [
+        Message("user", [TextBlock('<skill_content name="one">body</skill_content>')]),
+        Message("user", '<skill_content name="two">body</skill_content>'),
+        Message(
+            "user",
+            [
+                ToolResult(
+                    tool_use_id="toolu_123",
+                    content=[TextBlock('<skill_content name="three">body</skill_content>')],
+                    name="activate_skill",
+                    is_error=False,
+                )
+            ],
+        ),
+    ]
+
+    assert activated_skill_names(history) == {"one", "two", "three"}

kolega_code/cli/tests/test_slash_commands.py

@@ -0,0 +1,88 @@
+from pathlib import Path
+
+from ..skills import SkillCatalog, SkillRecord
+from ..slash_commands import (
+    SKILLS_LIST_COMMAND,
+    THREAD_RESET_COMMANDS,
+    TUI_COMMAND_NAMES,
+    CommandScope,
+    agent_command_names,
+    all_command_entries,
+    search_commands,
+)
+
+
+def _catalog(*names: str) -> SkillCatalog:
+    skills = {
+        name: SkillRecord(
+            name=name,
+            description=f"Description of {name}",
+            skill_dir=Path("/tmp") / name,
+            skill_file=Path("/tmp") / name / "SKILL.md",
+            scope="project",
+        )
+        for name in names
+    }
+    return SkillCatalog(skills=skills)
+
+
+def test_agent_command_names_match_command_processor():
+    from kolega_code.agent.utils.commands import CommandProcessor
+
+    assert agent_command_names() == {spec.name for spec in CommandProcessor.SPECS}
+    assert THREAD_RESET_COMMANDS <= agent_command_names()
+    assert SKILLS_LIST_COMMAND in TUI_COMMAND_NAMES
+
+
+def test_all_command_entries_unique_with_descriptions():
+    entries = all_command_entries(_catalog("demo-skill"))
+    names = [entry.name for entry in entries]
+    assert len(names) == len(set(names))
+    assert all(entry.description for entry in entries)
+    assert all(entry.token == f"/{entry.name}" for entry in entries)
+
+
+def test_all_command_entries_include_each_scope():
+    entries = all_command_entries(_catalog("demo-skill"))
+    by_name = {entry.name: entry for entry in entries}
+    assert by_name["help"].scope is CommandScope.AGENT
+    assert by_name["plan"].scope is CommandScope.TUI
+    assert by_name["demo-skill"].scope is CommandScope.SKILL
+
+
+def test_builtin_command_shadows_skill_with_same_name():
+    entries = all_command_entries(_catalog("plan"))
+    matches = [entry for entry in entries if entry.name == "plan"]
+    assert len(matches) == 1
+    assert matches[0].scope is CommandScope.TUI
+
+
+def test_search_commands_prefix_matches_first():
+    results = search_commands("c", _catalog())
+    names = [entry.name for entry in results]
+    prefix = [name for name in names if name.startswith("c")]
+    assert prefix == names[: len(prefix)]
+    assert "clear" in prefix and "compress" in prefix and "context" in prefix and "copy" in prefix
+
+
+def test_search_commands_substring_after_prefix():
+    results = search_commands("ui", _catalog())
+    names = [entry.name for entry in results]
+    assert "quit" in names
+
+
+def test_search_commands_empty_query_lists_all_up_to_limit():
+    catalog = _catalog("a-skill", "b-skill")
+    assert len(search_commands("", catalog, limit=5)) == 5
+    everything = search_commands("", catalog, limit=100)
+    assert {entry.name for entry in everything} >= {"help", "plan", "a-skill", "b-skill"}
+
+
+def test_search_commands_includes_skills_dynamically():
+    results = search_commands("demo", _catalog("demo-skill"))
+    assert [entry.name for entry in results] == ["demo-skill"]
+    assert results[0].description == "Description of demo-skill"
+
+
+def test_search_commands_no_match():
+    assert search_commands("zzz", _catalog()) == []

kolega_code/cli/theme.py

@@ -0,0 +1,180 @@
+"""Visual design tokens for the Kolega Code CLI.
+
+This module is the single source of truth for colors, glyphs, spacing, and
+truncation limits used by both the Textual TUI (app.py) and the plain CLI
+commands (main.py). It must stay importable without rich or textual installed,
+so those libraries are only imported lazily inside helpers.
+"""
+
+from __future__ import annotations
+
+import sys
+from functools import lru_cache
+from typing import Optional
+
+
+class Color:
+    """Semantic color roles as Rich style strings."""
+
+    ACCENT = "cyan"
+    SUCCESS = "green"
+    WARNING = "yellow"
+    ERROR = "red"
+    MUTED = "bright_black"
+    USER = "cyan"
+    AGENT = "magenta"
+    TOOL = "blue"
+    THINKING = "bright_black"
+
+
+class Glyph:
+    """Unicode glyphs used in the UI. Use g() to apply ASCII fallbacks."""
+
+    USER = "❯"  # ❯
+    AGENT = "●"  # ●
+    STATUS = "●"  # ●
+    TOOL = "⏺"  # ⏺
+    SUB_AGENT = "◆"  # ◆
+    PLAN = "◆"  # ◆
+    QUESTION = "?"
+    INSET_BAR = "│"  # │
+    INSET_ELBOW = "└"  # └
+    ELLIPSIS = "…"  # …
+    BULLET_SEP = "·"  # ·
+    BAR_FILLED = "█"  # █
+    BAR_EMPTY = "░"  # ░
+    CHECK = "✓"  # ✓
+    CROSS = "✗"  # ✗
+    DOWN = "↓"  # ↓
+
+
+ASCII_FALLBACKS = {
+    Glyph.USER: ">",
+    Glyph.AGENT: "*",
+    Glyph.TOOL: "*",
+    Glyph.SUB_AGENT: "*",
+    Glyph.INSET_BAR: "|",
+    Glyph.INSET_ELBOW: "`-",
+    Glyph.ELLIPSIS: "...",
+    Glyph.BULLET_SEP: "-",
+    Glyph.BAR_FILLED: "#",
+    Glyph.BAR_EMPTY: "-",
+    Glyph.CHECK: "ok",
+    Glyph.CROSS: "x",
+    Glyph.DOWN: "v",
+}
+
+SPINNER_FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"  # ⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏
+SPINNER_FRAMES_ASCII = "|/-\\"
+SPINNER_INTERVAL = 0.25
+
+# Truncation and layout limits
+TOOL_RESULT_PREVIEW_CHARS = 500
+TOOL_STREAM_PREVIEW_CHARS = 4_000
+TOOL_FULL_CONTENT_CAP_CHARS = 50_000
+SUB_AGENT_TAIL_CHARS = 200
+SUB_AGENT_TASK_PREVIEW_CHARS = 120
+CONTEXT_BAR_WIDTH = 18
+INSET_WIDTH = 2
+MARKDOWN_CODE_THEME = "monokai"
+RENDER_COALESCE_INTERVAL = 0.05
+
+
+@lru_cache(maxsize=None)
+def supports_unicode(encoding: Optional[str] = None) -> bool:
+    """Whether the output encoding can represent the glyphs above.
+
+    Probes the original stdout (sys.__stdout__) because Textual redirects
+    sys.stdout while the app is running.
+    """
+    if encoding is None:
+        encoding = getattr(sys.__stdout__, "encoding", None)
+    if encoding is None:
+        import locale
+
+        encoding = locale.getpreferredencoding(False) or "ascii"
+    try:
+        Glyph.TOOL.encode(encoding)
+        SPINNER_FRAMES.encode(encoding)
+    except (UnicodeEncodeError, LookupError):
+        return False
+    return True
+
+
+def g(glyph: str) -> str:
+    """Return the glyph, or its ASCII fallback on limited encodings."""
+    if supports_unicode():
+        return glyph
+    return ASCII_FALLBACKS.get(glyph, glyph)
+
+
+def spinner_frames() -> str:
+    return SPINNER_FRAMES if supports_unicode() else SPINNER_FRAMES_ASCII
+
+
+LOG_LEVEL_COLORS = {
+    "debug": Color.MUTED,
+    "info": Color.MUTED,
+    "ok": Color.SUCCESS,
+    "warn": Color.WARNING,
+    "warning": Color.WARNING,
+    "error": Color.ERROR,
+    "critical": Color.ERROR,
+}
+
+
+def log_level_color(level: str) -> str:
+    """Semantic color for a log level, defaulting to muted."""
+    return LOG_LEVEL_COLORS.get(level.lower(), Color.MUTED)
+
+
+def styled(text: str, style: str) -> str:
+    """Wrap text in Rich markup for the given style."""
+    return f"[{style}]{text}[/{style}]"
+
+
+def role_header(
+    glyph: str,
+    label: str,
+    color: str,
+    *,
+    label_style: str = "bold",
+    state: Optional[str] = None,
+    detail: Optional[str] = None,
+) -> str:
+    """Render the shared entry-header grammar.
+
+    GRAMMAR: <colored glyph> <bold label> [ · state] [ · detail]
+    The glyph carries the semantic color; state and detail are muted.
+    """
+    parts = [styled(g(glyph), color), styled(label, label_style)]
+    sep = g(Glyph.BULLET_SEP)
+    if state:
+        parts.append(styled(f"{sep} {state}", "dim"))
+    if detail:
+        parts.append(styled(f"{sep} {detail}", "dim"))
+    return " ".join(parts)
+
+
+def context_bar(usage_percentage: float, width: int = CONTEXT_BAR_WIDTH) -> str:
+    """Render a usage bar like █████░░░░ for the status dashboard."""
+    filled = max(0, min(width, round((usage_percentage / 100) * width)))
+    return g(Glyph.BAR_FILLED) * filled + g(Glyph.BAR_EMPTY) * (width - filled)
+
+
+def build_rich_theme():
+    """Build a rich Theme mapping semantic names to the palette (lazy import)."""
+    from rich.theme import Theme
+
+    return Theme(
+        {
+            "accent": Color.ACCENT,
+            "success": Color.SUCCESS,
+            "warning": Color.WARNING,
+            "error": Color.ERROR,
+            "muted": Color.MUTED,
+            "user": Color.USER,
+            "agent": Color.AGENT,
+            "tool": Color.TOOL,
+        }
+    )

kolega_code/config.py

@@ -0,0 +1,154 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class ModelProvider(str, Enum):
+    """Supported model providers."""
+
+    ANTHROPIC = "anthropic"
+    OPENAI = "openai"
+    GOOGLE = "google"
+    GROQ = "groq"
+    TOGETHER = "together"
+    FIREWORKS = "fireworks"
+    XAI = "xai"
+    LLAMA = "llama"
+    DASHSCOPE = "dashscope"
+    MOONSHOT = "moonshot"
+    DEEPSEEK = "deepseek"
+
+
+class RateLimitConfig(BaseModel):
+    """Rate limit configuration for a specific LLM."""
+
+    requests_per_minute: int = Field(default=60, description="Maximum number of requests allowed per minute", gt=0)
+
+    tokens_per_minute: int = Field(default=80_000, description="Maximum number of tokens allowed per minute", gt=0)
+
+    max_retries: int = Field(default=3, description="Maximum number of retries for failed requests", ge=0)
+
+
+class ModelConfig(BaseModel):
+    """Configuration for a specific model type (long context, fast, or thinking)."""
+
+    provider: ModelProvider = Field(description="Provider to use for this model configuration")
+
+    model: str = Field(description="Model identifier to use")
+
+    rate_limits: RateLimitConfig = Field(default_factory=RateLimitConfig, description="Rate limits for this model")
+
+    # Only used for thinking config
+    thinking_tokens: Optional[int] = Field(
+        default=None, description="Number of tokens to reserve for thinking operations", gt=0
+    )
+
+
+class AgentConfig(BaseModel):
+    """Configuration for the agent system.
+
+    This class contains all configuration parameters needed to run the agent,
+    including API keys for different providers and model configurations for
+    various operational modes (long context, fast, and thinking).
+
+    Usage:
+        # Create a default configuration
+        config = AgentConfig()
+
+        # Create a custom configuration
+        config = AgentConfig(
+            anthropic_api_key="your_anthropic_key",
+            long_context_config=ModelConfig(
+                provider=ModelProvider.ANTHROPIC,
+                model="claude-3-7-sonnet-20250219"
+            )
+        )
+
+        # Get an API key for a specific provider
+        api_key = config.get_api_key(ModelProvider.ANTHROPIC)
+
+        # Access model configurations
+        long_context_model = config.long_context_config
+        fast_model = config.fast_config
+        thinking_model = config.thinking_config
+
+    API keys can be set directly or loaded from environment variables.
+    Model configurations define which models to use for different operational
+    contexts and their respective token limits and rate limits.
+    """
+
+    # API Keys for different providers
+    anthropic_api_key: Optional[str] = Field(default=None, description="API key for Anthropic")
+    openai_api_key: Optional[str] = Field(default=None, description="API key for OpenAI")
+    google_api_key: Optional[str] = Field(default=None, description="API key for Google")
+    groq_api_key: Optional[str] = Field(default=None, description="API key for Groq")
+    together_api_key: Optional[str] = Field(default=None, description="API key for Together.ai")
+    fireworks_api_key: Optional[str] = Field(default=None, description="API key for Fireworks.ai")
+    xai_api_key: Optional[str] = Field(default=None, description="API key for X.ai")
+    dashscope_api_key: Optional[str] = Field(default=None, description="API key for Dashscope (Alibaba Model Studio)")
+    moonshot_api_key: Optional[str] = Field(default=None, description="API key for Moonshot.ai")
+    deepseek_api_key: Optional[str] = Field(default=None, description="API key for DeepSeek")
+
+    # Langfuse configuration
+    langfuse_enabled: bool = Field(default=False, description="Enable Langfuse tracing")
+    langfuse_host: Optional[str] = Field(default=None, description="Langfuse host URL")
+    langfuse_public_key: Optional[str] = Field(default=None, description="Langfuse public key")
+    langfuse_secret_key: Optional[str] = Field(default=None, description="Langfuse secret key")
+    environment: Optional[str] = Field(default="development", description="Environment name (development, production)")
+
+    # Model configurations
+    long_context_config: ModelConfig = Field(
+        default_factory=lambda: ModelConfig(provider=ModelProvider.ANTHROPIC, model="claude-opus-4-7"),
+        description="Configuration for long context operations",
+    )
+
+    fast_config: ModelConfig = Field(
+        default_factory=lambda: ModelConfig(provider=ModelProvider.ANTHROPIC, model="claude-haiku-4-5-20251001"),
+        description="Configuration for fast operations",
+    )
+
+    edit_model_config: ModelConfig = Field(
+        default_factory=lambda: ModelConfig(provider=ModelProvider.ANTHROPIC, model="claude-sonnet-4-6"),
+        description="Configuration for applying edits",
+    )
+
+    thinking_config: ModelConfig = Field(
+        default_factory=lambda: ModelConfig(
+            provider=ModelProvider.ANTHROPIC, model="claude-opus-4-7", thinking_tokens=1024
+        ),
+        description="Configuration for thinking operations",
+    )
+
+    def get_api_key(self, provider: ModelProvider) -> Optional[str]:
+        """Get the API key for a specific provider."""
+        api_key_map = {
+            ModelProvider.ANTHROPIC: self.anthropic_api_key,
+            ModelProvider.OPENAI: self.openai_api_key,
+            ModelProvider.GOOGLE: self.google_api_key,
+            ModelProvider.GROQ: self.groq_api_key,
+            ModelProvider.TOGETHER: self.together_api_key,
+            ModelProvider.FIREWORKS: self.fireworks_api_key,
+            ModelProvider.XAI: self.xai_api_key,
+            ModelProvider.DASHSCOPE: self.dashscope_api_key,
+            ModelProvider.MOONSHOT: self.moonshot_api_key,
+            ModelProvider.DEEPSEEK: self.deepseek_api_key,
+            ModelProvider.LLAMA: None,  # Local model, no API key needed
+        }
+        return api_key_map[provider]
+
+    @model_validator(mode="after")
+    def validate_provider_api_key(self) -> "AgentConfig":
+        """Validates that if a model provider is specified, the corresponding API key is provided."""
+        configs = [
+            (self.long_context_config, "long context"),
+            (self.fast_config, "fast"),
+            (self.thinking_config, "thinking"),
+            (self.edit_model_config, "edit model"),
+        ]
+
+        for config, config_name in configs:
+            if config.provider != ModelProvider.LLAMA and self.get_api_key(config.provider) is None:
+                raise ValueError(f"Missing API key for {config_name} provider '{config.provider.value}'")
+
+        return self