kolega-code 0.1.0__py3-none-any.whl

kolega_code/cli/mentions.py

@@ -0,0 +1,155 @@
+"""Parsing and expansion of @path file mentions in CLI prompts."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+MENTION_RE = re.compile(r'(?:(?<=\s)|^)@(?:"([^"]+)"|(\S+))')
+
+TRAILING_PUNCTUATION = ",.;:!?)]}'\""
+
+MAX_ATTACHMENT_LINES = 2000
+MAX_ATTACHMENT_BYTES = 48 * 1024
+MAX_DIR_ENTRIES = 200
+MAX_MENTIONS_PER_MESSAGE = 20
+
+
+@dataclass(frozen=True)
+class Mention:
+    raw: str  # token text as typed, without the leading @
+    path: str  # candidate path with trailing punctuation stripped
+
+
+def parse_mentions(text: str) -> List[Mention]:
+    """Extract candidate @path tokens; purely syntactic, no filesystem checks."""
+    mentions: List[Mention] = []
+    for match in MENTION_RE.finditer(text):
+        quoted, bare = match.groups()
+        if quoted is not None:
+            mentions.append(Mention(raw=quoted, path=quoted))
+            continue
+        path = bare.rstrip(TRAILING_PUNCTUATION)
+        if path:
+            mentions.append(Mention(raw=bare, path=path))
+    return mentions
+
+
+def build_file_attachments(text: str, project_path: Path) -> Tuple[List[Dict[str, Any]], List[str]]:
+    """Resolve @ mentions in ``text`` against ``project_path``.
+
+    Returns (attachments, unresolved) where attachments are
+    ``{"type": "file", "path": rel, "content": str, "truncated": bool, "is_dir": bool}``
+    payloads and unresolved lists mention tokens that did not match an existing
+    path (left in the message as literal text).
+    """
+    project_path = Path(project_path).resolve()
+    attachments: List[Dict[str, Any]] = []
+    unresolved: List[str] = []
+    seen: set[str] = set()
+
+    for mention in parse_mentions(text)[:MAX_MENTIONS_PER_MESSAGE]:
+        rel = _resolve_relative(mention.path, project_path)
+        if rel is None:
+            unresolved.append(mention.path)
+            continue
+        if rel in seen:
+            continue
+        seen.add(rel)
+
+        target = project_path / rel
+        if target.is_dir():
+            attachments.append(
+                {
+                    "type": "file",
+                    "path": rel,
+                    "content": _directory_listing(target),
+                    "truncated": False,
+                    "is_dir": True,
+                }
+            )
+        else:
+            content, truncated = _read_file_content(target)
+            attachments.append(
+                {
+                    "type": "file",
+                    "path": rel,
+                    "content": content,
+                    "truncated": truncated,
+                    "is_dir": False,
+                }
+            )
+
+    return attachments, unresolved
+
+
+def _resolve_relative(candidate: str, project_path: Path) -> str | None:
+    """Map a mention to a project-relative posix path, or None if invalid."""
+    raw = Path(candidate.rstrip("/")) if candidate not in ("", "/") else Path(".")
+    try:
+        if raw.is_absolute():
+            rel = raw.resolve().relative_to(project_path)
+        else:
+            rel = (project_path / raw).resolve().relative_to(project_path)
+    except (ValueError, OSError):
+        return None
+    target = project_path / rel
+    if not target.exists():
+        return None
+    return rel.as_posix()
+
+
+def _read_file_content(target: Path) -> Tuple[str, bool]:
+    if _looks_binary(target):
+        return "[binary file - content not attached]", False
+
+    try:
+        raw = target.read_text(encoding="utf-8", errors="replace")
+    except OSError as exc:
+        return f"[could not read file: {exc}]", False
+
+    lines = raw.splitlines(keepends=True)
+    total_lines = len(lines)
+    truncated = False
+
+    if total_lines > MAX_ATTACHMENT_LINES:
+        lines = lines[:MAX_ATTACHMENT_LINES]
+        truncated = True
+    content = "".join(lines)
+    if len(content.encode("utf-8", errors="replace")) > MAX_ATTACHMENT_BYTES:
+        content = content.encode("utf-8", errors="replace")[:MAX_ATTACHMENT_BYTES].decode("utf-8", errors="replace")
+        truncated = True
+
+    if truncated:
+        shown_lines = content.count("\n") + (0 if content.endswith("\n") or not content else 1)
+        content += (
+            f"\n[truncated: showing first {shown_lines} of {total_lines} lines"
+            " - ask the agent to read specific sections for more]"
+        )
+    return content, truncated
+
+
+def _looks_binary(target: Path) -> bool:
+    try:
+        with target.open("rb") as handle:
+            chunk = handle.read(8192)
+    except OSError:
+        return False
+    return b"\x00" in chunk
+
+
+def _directory_listing(target: Path) -> str:
+    try:
+        children = sorted(target.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower()))
+    except OSError as exc:
+        return f"[could not list directory: {exc}]"
+
+    names = []
+    for child in children[:MAX_DIR_ENTRIES]:
+        names.append(child.name + "/" if child.is_dir() else child.name)
+    listing = "\n".join(names) if names else "[empty directory]"
+    if len(children) > MAX_DIR_ENTRIES:
+        listing += f"\n[truncated: showing first {MAX_DIR_ENTRIES} of {len(children)} entries]"
+    return listing

kolega_code/cli/messages.py

@@ -0,0 +1,89 @@
+"""User-facing microcopy for the Kolega Code CLI.
+
+Single voice for every string the user reads: sentence case, full sentences
+end with a period, in-progress states end with a single ellipsis character,
+no exclamation marks.
+"""
+
+from __future__ import annotations
+
+# Composer placeholders and modal prompts
+COMPOSER_PLACEHOLDER = "Ask Kolega Code..."
+PLAN_READY_PLACEHOLDER = "Plan ready. Choose Implement plan or Discuss further."
+QUESTION_PLACEHOLDER = "Choose an option below or type a custom answer..."
+
+# Durable transcript messages
+THREAD_RESET_MESSAGE = "Thread reset. Previous messages were cleared."
+TASK_LIST_EMPTY_MESSAGE = "No task list has been set."
+PLAN_EMPTY_MESSAGE = "No plan captured yet."
+
+# Turn progress
+WORKING = "Working…"
+GENERATING = "Generating…"
+THINKING = "Thinking…"
+READING_RESPONSE = "Reading model response…"
+STOP_REQUESTED = "Stopping…"
+FINISHED = "Finished."
+STOPPED_BY_USER = "Stopped by user."
+STOPPED_WITH_ERROR = "Stopped due to an error: {error}"
+CANCEL_REQUESTED = "Cancellation requested."
+WAITING_FOR_ANSWER = "Waiting for your answer…"
+
+# Turn status strip finals
+DONE_IN = "Done in {duration}"
+STOPPED_AFTER = "Stopped after {duration}"
+ERRORED_AFTER = "Errored after {duration}"
+
+# Tool and sub-agent activity
+RUNNING_TOOL = "Running {tool}…"
+TOOL_DONE = "{tool} finished."
+TOOL_FAILED = "{tool} failed."
+RUNNING_TERMINAL_COMMAND = "Running terminal command…"
+RUNNING_SUB_AGENT = "Running sub-agent {name} #{index}…"
+RUNNING_SUB_AGENTS = "Running {count} sub-agents…"
+
+# Confirmations
+SWITCHED_MODE = "Switched to {mode} mode."
+PLAN_CAPTURED = "Plan captured. Choose Implement plan or Discuss further."
+PLAN_DISCUSSION_RESUMED = "Planning discussion resumed."
+SKILL_ACTIVATED = "Activated skill {name}."
+SKILLS_LISTED = "Listed agent skills."
+
+# Mentions
+MENTIONS_NOT_FOUND = "Not found, sent as plain text: {mentions}"
+
+# Slash commands
+MODEL_SWITCHED = "Switched model to {provider}/{model}."
+MODEL_UNKNOWN = "Unknown model {model} for provider {provider}."
+MODEL_SWITCH_HINT = "Switch with /model <name>."
+COPY_LAST_RESPONSE = "Copied the last response to the clipboard."
+COPY_NOTHING = "No response to copy yet."
+VERSION_INFO = "Kolega Code version {version}."
+
+# Blockers
+BLOCK_STOP_BEFORE_RESET = "Stop the current turn before resetting the thread."
+BLOCK_STOP_BEFORE_MODE_SWITCH = "Stop the current turn before switching modes."
+BLOCK_STOP_BEFORE_SKILL = "Stop the current turn before activating a skill."
+BLOCK_STOP_BEFORE_MODEL_SWITCH = "Stop the current turn before switching models."
+BLOCK_PLAN_DECISION = "Choose Implement plan or Discuss further before sending another message."
+BLOCK_PLAN_DECISION_MODE_SWITCH = "Choose Implement plan or Discuss further before switching modes."
+BLOCK_PLAN_DECISION_SKILL = "Choose Implement plan or Discuss further before activating a skill."
+BLOCK_PENDING_QUESTION_SKILL = "Answer the pending planning question before activating a skill."
+SETTINGS_REQUIRED = "Save a provider, model, and API key before chatting."
+SETTINGS_REQUIRED_SKILL = "Save a provider, model, and API key before activating a skill."
+
+# Settings tab
+SETTINGS_SAVED = "Settings saved."
+SETTINGS_INCOMPLETE = "Configuration incomplete: {error}"
+SETTINGS_ACTIVE_MODEL = "Active model: {provider}/{model}"
+SETTINGS_API_KEY_LINE = "API key: {status}"
+
+# Status dashboard
+STATUS_TOKENS_UNKNOWN = "Token counts unavailable."
+
+# Logs
+LOG_IGNORED_EVENT = "Ignored non-display event: {event_type}"
+
+# Misc
+COPY_MACOS_FAILED = "Copied for supported terminals, but the macOS clipboard failed."
+STREAM_TRUNCATED = "[stream truncated to the last {chars} characters]"

kolega_code/cli/provider_registry.py

@@ -0,0 +1,96 @@
+"""Provider and model registry for the CLI settings UI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from kolega_code.config import ModelProvider
+from kolega_code.llm.specs import get_model_specs
+
+UI_DEFAULT_PROVIDER = ModelProvider.MOONSHOT.value
+UI_DEFAULT_MODEL = "kimi-k2.6"
+DEEPSEEK_DEFAULT_MODEL = "deepseek-v4-pro"
+
+
+@dataclass(frozen=True)
+class ModelOption:
+    provider: str
+    provider_label: str
+    model: str
+    model_label: str
+    api_key_env: str
+    context_length: int
+    max_completion_tokens: int
+
+
+def _model_option(
+    provider: ModelProvider,
+    provider_label: str,
+    model: str,
+    model_label: str,
+    api_key_env: str,
+) -> ModelOption:
+    specs = get_model_specs(provider, model)
+    return ModelOption(
+        provider=provider.value,
+        provider_label=provider_label,
+        model=model,
+        model_label=model_label,
+        api_key_env=api_key_env,
+        context_length=int(specs["context_length"]),
+        max_completion_tokens=int(specs["max_completion_tokens"]),
+    )
+
+
+UI_MODEL_OPTIONS = [
+    _model_option(
+        ModelProvider.MOONSHOT,
+        "Moonshot AI",
+        UI_DEFAULT_MODEL,
+        "Kimi K2.6",
+        "MOONSHOT_API_KEY",
+    ),
+    _model_option(
+        ModelProvider.DEEPSEEK,
+        "DeepSeek AI",
+        DEEPSEEK_DEFAULT_MODEL,
+        "DeepSeek V4 Pro",
+        "DEEPSEEK_API_KEY",
+    ),
+]
+
+
+def ui_provider_options() -> list[tuple[str, str]]:
+    """Return Textual Select options for supported UI providers."""
+    seen: set[str] = set()
+    options: list[tuple[str, str]] = []
+    for option in UI_MODEL_OPTIONS:
+        if option.provider in seen:
+            continue
+        seen.add(option.provider)
+        options.append((option.provider_label, option.provider))
+    return options
+
+
+def ui_model_options(provider: str) -> list[tuple[str, str]]:
+    """Return Textual Select options for supported UI models."""
+    return [(option.model_label, option.model) for option in UI_MODEL_OPTIONS if option.provider == provider]
+
+
+def get_ui_model(provider: str, model: str) -> ModelOption | None:
+    """Return a supported UI model option."""
+    for option in UI_MODEL_OPTIONS:
+        if option.provider == provider and option.model == model:
+            return option
+    return None
+
+
+def default_model_for_provider(provider: ModelProvider) -> str:
+    """Return a usable default model for a provider when only the provider is selected."""
+    if provider == ModelProvider.MOONSHOT:
+        return UI_DEFAULT_MODEL
+    if provider == ModelProvider.DEEPSEEK:
+        return DEEPSEEK_DEFAULT_MODEL
+    if provider == ModelProvider.ANTHROPIC:
+        return "claude-opus-4-7"
+    raise ValueError(f"No default CLI model is registered for provider '{provider.value}'.")

kolega_code/cli/session_store.py

@@ -0,0 +1,207 @@
+"""Local resumable session storage for the Kolega Code CLI."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable, Optional
+
+SCHEMA_VERSION = 1
+
+
+class SessionStoreError(RuntimeError):
+    """Raised when a CLI session cannot be loaded or saved."""
+
+
+@dataclass
+class SessionRecord:
+    session_id: str
+    project_path: str
+    workspace_id: str
+    thread_id: str
+    mode: str
+    title: str
+    created_at: str
+    updated_at: str
+    config: dict[str, Any] = field(default_factory=dict)
+    history: list[dict[str, Any]] = field(default_factory=list)
+    task_list_markdown: str = ""
+    latest_plan_markdown: str = ""
+    interaction_mode: str = "build"
+    schema_version: int = SCHEMA_VERSION
+
+    @classmethod
+    def create(
+        cls,
+        project_path: Path,
+        mode: str,
+        config: dict[str, Any],
+        session_id: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> "SessionRecord":
+        now = _now()
+        resolved_project = str(project_path.resolve())
+        session_id = session_id or uuid.uuid4().hex
+        return cls(
+            schema_version=SCHEMA_VERSION,
+            session_id=session_id,
+            project_path=resolved_project,
+            workspace_id=f"cli-{uuid.uuid4().hex}",
+            thread_id=uuid.uuid4().hex,
+            mode=mode,
+            title=title or Path(resolved_project).name or "Kolega Code",
+            created_at=now,
+            updated_at=now,
+            config=config,
+            history=[],
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "SessionRecord":
+        if data.get("schema_version") != SCHEMA_VERSION:
+            raise SessionStoreError(f"Unsupported session schema version: {data.get('schema_version')}")
+        return cls(
+            schema_version=data["schema_version"],
+            session_id=data["session_id"],
+            project_path=data["project_path"],
+            workspace_id=data["workspace_id"],
+            thread_id=data["thread_id"],
+            mode=data["mode"],
+            title=data.get("title") or "Kolega Code",
+            created_at=data["created_at"],
+            updated_at=data["updated_at"],
+            config=data.get("config") or {},
+            history=data.get("history") or [],
+            task_list_markdown=data.get("task_list_markdown") or "",
+            latest_plan_markdown=data.get("latest_plan_markdown") or "",
+            interaction_mode=data.get("interaction_mode") or "build",
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schema_version": self.schema_version,
+            "session_id": self.session_id,
+            "project_path": self.project_path,
+            "workspace_id": self.workspace_id,
+            "thread_id": self.thread_id,
+            "mode": self.mode,
+            "title": self.title,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "config": self.config,
+            "history": self.history,
+            "task_list_markdown": self.task_list_markdown,
+            "latest_plan_markdown": self.latest_plan_markdown,
+            "interaction_mode": self.interaction_mode,
+        }
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def default_state_dir(env: Optional[dict[str, str]] = None) -> Path:
+    env = env or os.environ
+    if env.get("KOLEGA_CODE_STATE_DIR"):
+        return Path(env["KOLEGA_CODE_STATE_DIR"]).expanduser()
+
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / "kolega-code"
+    if sys.platform.startswith("win"):
+        base = Path(env.get("LOCALAPPDATA") or Path.home() / "AppData" / "Local")
+        return base / "kolega-code"
+    return Path(env.get("XDG_STATE_HOME", Path.home() / ".local" / "state")) / "kolega-code"
+
+
+class SessionStore:
+    """Filesystem-backed session store."""
+
+    def __init__(self, root: Optional[Path] = None) -> None:
+        self.root = (root or default_state_dir()).expanduser()
+        self.sessions_dir = self.root / "sessions"
+
+    def ensure_dirs(self) -> None:
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+
+    def path_for(self, session_id: str) -> Path:
+        return self.sessions_dir / f"{session_id}.json"
+
+    def create(
+        self,
+        project_path: Path,
+        mode: str,
+        config: dict[str, Any],
+        session_id: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> SessionRecord:
+        record = SessionRecord.create(project_path, mode, config, session_id=session_id, title=title)
+        self.save(record)
+        return record
+
+    def save(self, record: SessionRecord) -> None:
+        self.ensure_dirs()
+        record.updated_at = _now()
+        payload = json.dumps(record.to_dict(), indent=2, sort_keys=True)
+        target = self.path_for(record.session_id)
+        temp = target.with_suffix(".json.tmp")
+        temp.write_text(payload + "\n", encoding="utf-8")
+        temp.replace(target)
+
+    def load(self, session_id: str) -> SessionRecord:
+        path = self.path_for(session_id)
+        if not path.exists():
+            raise SessionStoreError(f"Session not found: {session_id}")
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError as exc:
+            raise SessionStoreError(f"Session file is not valid JSON: {path}") from exc
+        return SessionRecord.from_dict(data)
+
+    def load_by_thread_id(self, thread_id: str) -> SessionRecord:
+        for record in self._iter_records():
+            if record.thread_id == thread_id:
+                return record
+        raise SessionStoreError(f"Thread not found: {thread_id}")
+
+    def load_session_or_thread(self, identifier: str) -> SessionRecord:
+        path = self.path_for(identifier)
+        if path.exists():
+            return self.load(identifier)
+        return self.load_by_thread_id(identifier)
+
+    def delete(self, session_id: str) -> None:
+        path = self.path_for(session_id)
+        if not path.exists():
+            raise SessionStoreError(f"Session not found: {session_id}")
+        path.unlink()
+
+    def list(self, project_path: Optional[Path] = None) -> list[SessionRecord]:
+        records = list(self._iter_records())
+        if project_path is not None:
+            resolved = str(project_path.resolve())
+            records = [record for record in records if record.project_path == resolved]
+        return sorted(records, key=lambda record: record.updated_at, reverse=True)
+
+    def latest_for_project(self, project_path: Path) -> Optional[SessionRecord]:
+        records = self.list(project_path=project_path)
+        return records[0] if records else None
+
+    def export(self, session_id: str) -> str:
+        return json.dumps(self.load(session_id).to_dict(), indent=2, sort_keys=True) + "\n"
+
+    def _iter_records(self) -> Iterable[SessionRecord]:
+        if not self.sessions_dir.exists():
+            return []
+
+        records = []
+        for path in self.sessions_dir.glob("*.json"):
+            try:
+                records.append(SessionRecord.from_dict(json.loads(path.read_text(encoding="utf-8"))))
+            except Exception:
+                continue
+        return records

kolega_code/cli/settings.py

@@ -0,0 +1,87 @@
+"""Persistent CLI settings for provider/model selection and API keys."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from .session_store import default_state_dir
+
+SETTINGS_SCHEMA_VERSION = 1
+
+
+class SettingsStoreError(RuntimeError):
+    """Raised when CLI settings cannot be loaded or saved."""
+
+
+@dataclass
+class CliSettings:
+    active_provider: Optional[str] = None
+    active_model: Optional[str] = None
+    api_keys: dict[str, str] = field(default_factory=dict)
+    schema_version: int = SETTINGS_SCHEMA_VERSION
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "CliSettings":
+        if data.get("schema_version") != SETTINGS_SCHEMA_VERSION:
+            raise SettingsStoreError(f"Unsupported settings schema version: {data.get('schema_version')}")
+        api_keys = data.get("api_keys") or {}
+        return cls(
+            schema_version=data["schema_version"],
+            active_provider=data.get("active_provider"),
+            active_model=data.get("active_model"),
+            api_keys={str(provider): str(key) for provider, key in api_keys.items() if key},
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "schema_version": self.schema_version,
+            "active_provider": self.active_provider,
+            "active_model": self.active_model,
+            "api_keys": self.api_keys,
+        }
+
+    def get_api_key(self, provider: str) -> Optional[str]:
+        return self.api_keys.get(provider)
+
+    def set_api_key(self, provider: str, api_key: str) -> None:
+        if api_key:
+            self.api_keys[provider] = api_key
+
+    def has_api_key(self, provider: str) -> bool:
+        return bool(self.get_api_key(provider))
+
+
+class SettingsStore:
+    """Filesystem-backed CLI settings store."""
+
+    def __init__(self, root: Optional[Path] = None) -> None:
+        self.root = (root or default_state_dir()).expanduser()
+        self.path = self.root / "settings.json"
+
+    def load(self) -> CliSettings:
+        if not self.path.exists():
+            return CliSettings()
+        try:
+            return CliSettings.from_dict(json.loads(self.path.read_text(encoding="utf-8")))
+        except json.JSONDecodeError as exc:
+            raise SettingsStoreError(f"Settings file is not valid JSON: {self.path}") from exc
+
+    def save(self, settings: CliSettings) -> None:
+        self.root.mkdir(parents=True, exist_ok=True)
+        payload = json.dumps(settings.to_dict(), indent=2, sort_keys=True)
+        temp = self.path.with_suffix(".json.tmp")
+        temp.write_text(payload + "\n", encoding="utf-8")
+        _chmod_private(temp)
+        temp.replace(self.path)
+        _chmod_private(self.path)
+
+
+def _chmod_private(path: Path) -> None:
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass