kittycode 0.1.0__py3-none-any.whl

kittycode/context.py

@@ -0,0 +1,170 @@
+"""Multi-layer context compression."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .llm import LLM
+
+
+def _approx_tokens(text: str) -> int:
+    """Rough token count for mixed English and Chinese content."""
+    return len(text) // 3
+
+
+def estimate_tokens(messages: list[dict]) -> int:
+    total = 0
+    for message in messages:
+        if message.get("content"):
+            total += _approx_tokens(message["content"])
+        if message.get("tool_calls"):
+            total += _approx_tokens(str(message["tool_calls"]))
+    return total
+
+
+class ContextManager:
+    def __init__(self, max_tokens: int = 128_000):
+        self.max_tokens = max_tokens
+        self._snip_at = int(max_tokens * 0.50)
+        self._summarize_at = int(max_tokens * 0.70)
+        self._collapse_at = int(max_tokens * 0.90)
+
+    def maybe_compress(self, messages: list[dict], llm: LLM | None = None) -> bool:
+        """Apply compression layers as needed."""
+        current = estimate_tokens(messages)
+        compressed = False
+
+        if current > self._snip_at:
+            if self._snip_tool_outputs(messages):
+                compressed = True
+                current = estimate_tokens(messages)
+
+        if current > self._summarize_at and len(messages) > 10:
+            if self._summarize_old(messages, llm, keep_recent=8):
+                compressed = True
+                current = estimate_tokens(messages)
+
+        if current > self._collapse_at and len(messages) > 4:
+            self._hard_collapse(messages, llm)
+            compressed = True
+
+        return compressed
+
+    @staticmethod
+    def _snip_tool_outputs(messages: list[dict]) -> bool:
+        changed = False
+        for message in messages:
+            if message.get("role") != "tool":
+                continue
+            content = message.get("content", "")
+            if len(content) <= 1500:
+                continue
+            lines = content.splitlines()
+            if len(lines) <= 6:
+                continue
+            message["content"] = (
+                "\n".join(lines[:3])
+                + f"\n... ({len(lines)} lines, snipped to save context) ...\n"
+                + "\n".join(lines[-3:])
+            )
+            changed = True
+        return changed
+
+    def _summarize_old(
+        self,
+        messages: list[dict],
+        llm: LLM | None,
+        keep_recent: int = 8,
+    ) -> bool:
+        if len(messages) <= keep_recent:
+            return False
+
+        old_messages = messages[:-keep_recent]
+        recent_messages = messages[-keep_recent:]
+        summary = self._get_summary(old_messages, llm)
+
+        messages.clear()
+        messages.append(
+            {
+                "role": "user",
+                "content": f"[Context compressed - conversation summary]\n{summary}",
+            }
+        )
+        messages.append(
+            {
+                "role": "assistant",
+                "content": "Got it, I have the context from our earlier conversation.",
+            }
+        )
+        messages.extend(recent_messages)
+        return True
+
+    def _hard_collapse(self, messages: list[dict], llm: LLM | None):
+        tail = messages[-4:] if len(messages) > 4 else messages[-2:]
+        summary = self._get_summary(messages[:-len(tail)], llm)
+
+        messages.clear()
+        messages.append({"role": "user", "content": f"[Hard context reset]\n{summary}"})
+        messages.append(
+            {"role": "assistant", "content": "Context restored. Continuing from where we left off."}
+        )
+        messages.extend(tail)
+
+    def _get_summary(self, messages: list[dict], llm: LLM | None) -> str:
+        flat = self._flatten(messages)
+
+        if llm:
+            try:
+                response = llm.chat(
+                    messages=[
+                        {
+                            "role": "system",
+                            "content": (
+                                "Compress this conversation into a brief summary. "
+                                "Preserve: file paths edited, key decisions made, "
+                                "errors encountered, current task state. "
+                                "Drop: verbose command output, code listings, "
+                                "redundant back-and-forth."
+                            ),
+                        },
+                        {"role": "user", "content": flat[:15000]},
+                    ],
+                )
+                return response.content
+            except Exception:
+                pass
+
+        return self._extract_key_info(messages)
+
+    @staticmethod
+    def _flatten(messages: list[dict]) -> str:
+        parts = []
+        for message in messages:
+            role = message.get("role", "?")
+            text = message.get("content", "") or ""
+            if text:
+                parts.append(f"[{role}] {text[:400]}")
+        return "\n".join(parts)
+
+    @staticmethod
+    def _extract_key_info(messages: list[dict]) -> str:
+        import re
+
+        files_seen = set()
+        errors = []
+
+        for message in messages:
+            text = message.get("content", "") or ""
+            for match in re.finditer(r"[\w./\-]+\.\w{1,5}", text):
+                files_seen.add(match.group())
+            for line in text.splitlines():
+                if "error" in line.lower():
+                    errors.append(line.strip()[:150])
+
+        parts = []
+        if files_seen:
+            parts.append(f"Files touched: {', '.join(sorted(files_seen)[:20])}")
+        if errors:
+            parts.append(f"Errors seen: {'; '.join(errors[:5])}")
+        return "\n".join(parts) or "(no extractable context)"

kittycode/llm.py

@@ -0,0 +1,325 @@
+"""LLM provider layer for OpenAI-compatible and Anthropic APIs."""
+
+import json
+import time
+from dataclasses import dataclass, field
+
+import anthropic
+from anthropic import Anthropic
+from openai import APIConnectionError, APIError, APITimeoutError, OpenAI, RateLimitError
+
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    arguments: dict
+
+
+@dataclass
+class LLMResponse:
+    content: str = ""
+    tool_calls: list[ToolCall] = field(default_factory=list)
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+
+    @property
+    def message(self) -> dict:
+        message: dict = {"role": "assistant", "content": self.content or None}
+        if self.tool_calls:
+            message["tool_calls"] = [
+                {
+                    "id": tool_call.id,
+                    "type": "function",
+                    "function": {
+                        "name": tool_call.name,
+                        "arguments": json.dumps(tool_call.arguments),
+                    },
+                }
+                for tool_call in self.tool_calls
+            ]
+        return message
+
+
+class LLM:
+    def __init__(
+        self,
+        model: str,
+        api_key: str,
+        interface: str = "openai",
+        base_url: str | None = None,
+        **kwargs,
+    ):
+        self.model = model
+        self.interface = interface
+        if interface == "anthropic":
+            self.client = Anthropic(api_key=api_key, base_url=base_url)
+        else:
+            self.client = OpenAI(api_key=api_key, base_url=base_url)
+        self.extra = kwargs
+        self.total_prompt_tokens = 0
+        self.total_completion_tokens = 0
+
+    def chat(
+        self,
+        messages: list[dict],
+        tools: list[dict] | None = None,
+        on_token=None,
+    ) -> LLMResponse:
+        if self.interface == "anthropic":
+            return self._chat_anthropic(messages, tools=tools, on_token=on_token)
+
+        return self._chat_openai(messages, tools=tools, on_token=on_token)
+
+    def _chat_openai(
+        self,
+        messages: list[dict],
+        tools: list[dict] | None = None,
+        on_token=None,
+    ) -> LLMResponse:
+        params: dict = {
+            "model": self.model,
+            "messages": messages,
+            "stream": True,
+            **self.extra,
+        }
+        if tools:
+            params["tools"] = tools
+
+        try:
+            params["stream_options"] = {"include_usage": True}
+            stream = self._call_with_retry(params)
+        except Exception:
+            params.pop("stream_options", None)
+            stream = self._call_with_retry(params)
+
+        content_parts: list[str] = []
+        tool_call_map: dict[int, dict] = {}
+        prompt_tokens = 0
+        completion_tokens = 0
+
+        for chunk in stream:
+            if chunk.usage:
+                prompt_tokens = chunk.usage.prompt_tokens
+                completion_tokens = chunk.usage.completion_tokens
+
+            if not chunk.choices:
+                continue
+            delta = chunk.choices[0].delta
+
+            if delta.content:
+                content_parts.append(delta.content)
+                if on_token:
+                    on_token(delta.content)
+
+            if delta.tool_calls:
+                for tool_call_delta in delta.tool_calls:
+                    index = tool_call_delta.index
+                    if index not in tool_call_map:
+                        tool_call_map[index] = {"id": "", "name": "", "args": ""}
+                    if tool_call_delta.id:
+                        tool_call_map[index]["id"] = tool_call_delta.id
+                    if tool_call_delta.function:
+                        if tool_call_delta.function.name:
+                            tool_call_map[index]["name"] = tool_call_delta.function.name
+                        if tool_call_delta.function.arguments:
+                            tool_call_map[index]["args"] += tool_call_delta.function.arguments
+
+        parsed_tool_calls: list[ToolCall] = []
+        for index in sorted(tool_call_map):
+            raw = tool_call_map[index]
+            try:
+                args = json.loads(raw["args"])
+            except (json.JSONDecodeError, KeyError):
+                args = {}
+            parsed_tool_calls.append(
+                ToolCall(id=raw["id"], name=raw["name"], arguments=args)
+            )
+
+        self.total_prompt_tokens += prompt_tokens
+        self.total_completion_tokens += completion_tokens
+
+        return LLMResponse(
+            content="".join(content_parts),
+            tool_calls=parsed_tool_calls,
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+        )
+
+    def _chat_anthropic(
+        self,
+        messages: list[dict],
+        tools: list[dict] | None = None,
+        on_token=None,
+    ) -> LLMResponse:
+        system_message, conversation = _extract_system_message(messages)
+        params: dict = {
+            "model": self.model,
+            "messages": _to_anthropic_messages(conversation),
+            "max_tokens": int(self.extra.get("max_tokens", 4096)),
+        }
+
+        temperature = self.extra.get("temperature")
+        if temperature is not None:
+            params["temperature"] = temperature
+        if system_message:
+            params["system"] = system_message
+        if tools:
+            params["tools"] = _to_anthropic_tools(tools)
+
+        message = self._call_anthropic_with_retry(params)
+        response = _anthropic_message_to_response(message, on_token=on_token)
+        self.total_prompt_tokens += response.prompt_tokens
+        self.total_completion_tokens += response.completion_tokens
+        return response
+
+    def _call_with_retry(self, params: dict, max_retries: int = 3):
+        for attempt in range(max_retries):
+            try:
+                return self.client.chat.completions.create(**params)
+            except (RateLimitError, APITimeoutError, APIConnectionError):
+                if attempt == max_retries - 1:
+                    raise
+                time.sleep(2 ** attempt)
+            except APIError as exc:
+                if exc.status_code and exc.status_code >= 500 and attempt < max_retries - 1:
+                    time.sleep(2 ** attempt)
+                else:
+                    raise
+
+    def _call_anthropic_with_retry(self, params: dict, max_retries: int = 3):
+        for attempt in range(max_retries):
+            try:
+                return self.client.messages.create(**params)
+            except (anthropic.RateLimitError, anthropic.APITimeoutError, anthropic.APIConnectionError):
+                if attempt == max_retries - 1:
+                    raise
+                time.sleep(2 ** attempt)
+            except anthropic.APIError as exc:
+                status_code = getattr(exc, "status_code", None)
+                if status_code and status_code >= 500 and attempt < max_retries - 1:
+                    time.sleep(2 ** attempt)
+                else:
+                    raise
+
+
+def _extract_system_message(messages: list[dict]) -> tuple[str, list[dict]]:
+    system_parts: list[str] = []
+    conversation: list[dict] = []
+
+    for message in messages:
+        if message.get("role") == "system":
+            content = message.get("content")
+            if content:
+                system_parts.append(content)
+            continue
+        conversation.append(message)
+
+    return "\n\n".join(system_parts), conversation
+
+
+def _to_anthropic_tools(tools: list[dict]) -> list[dict]:
+    converted = []
+    for tool in tools:
+        function = tool.get("function", {})
+        converted.append(
+            {
+                "name": function.get("name", ""),
+                "description": function.get("description", ""),
+                "input_schema": function.get("parameters", {"type": "object", "properties": {}}),
+            }
+        )
+    return converted
+
+
+def _to_anthropic_messages(messages: list[dict]) -> list[dict]:
+    converted: list[dict] = []
+    index = 0
+
+    while index < len(messages):
+        message = messages[index]
+        role = message.get("role")
+
+        if role == "tool":
+            tool_results = []
+            while index < len(messages) and messages[index].get("role") == "tool":
+                current = messages[index]
+                tool_results.append(
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": current.get("tool_call_id", ""),
+                        "content": current.get("content", "") or "",
+                    }
+                )
+                index += 1
+            converted.append({"role": "user", "content": tool_results})
+            continue
+
+        if role in {"user", "assistant"}:
+            converted.append({"role": role, "content": _to_anthropic_content(message)})
+
+        index += 1
+
+    return converted
+
+
+def _to_anthropic_content(message: dict) -> list[dict]:
+    blocks: list[dict] = []
+
+    content = message.get("content")
+    if content:
+        blocks.append({"type": "text", "text": str(content)})
+
+    for tool_call in message.get("tool_calls", []) or []:
+        function = tool_call.get("function", {})
+        raw_args = function.get("arguments", {})
+        if isinstance(raw_args, str):
+            try:
+                parsed_args = json.loads(raw_args)
+            except json.JSONDecodeError:
+                parsed_args = {}
+        else:
+            parsed_args = raw_args or {}
+
+        blocks.append(
+            {
+                "type": "tool_use",
+                "id": tool_call.get("id", ""),
+                "name": function.get("name", ""),
+                "input": parsed_args,
+            }
+        )
+
+    return blocks or [{"type": "text", "text": ""}]
+
+
+def _anthropic_message_to_response(message, on_token=None) -> LLMResponse:
+    content_parts: list[str] = []
+    tool_calls: list[ToolCall] = []
+
+    for block in getattr(message, "content", []) or []:
+        block_type = getattr(block, "type", None)
+        if block_type == "text":
+            text = getattr(block, "text", "") or ""
+            content_parts.append(text)
+            if text and on_token:
+                on_token(text)
+        elif block_type == "tool_use":
+            tool_calls.append(
+                ToolCall(
+                    id=getattr(block, "id", ""),
+                    name=getattr(block, "name", ""),
+                    arguments=getattr(block, "input", {}) or {},
+                )
+            )
+
+    usage = getattr(message, "usage", None)
+    prompt_tokens = getattr(usage, "input_tokens", 0) if usage else 0
+    completion_tokens = getattr(usage, "output_tokens", 0) if usage else 0
+
+    return LLMResponse(
+        content="".join(content_parts),
+        tool_calls=tool_calls,
+        prompt_tokens=prompt_tokens,
+        completion_tokens=completion_tokens,
+    )

kittycode/prompt.py

@@ -0,0 +1,51 @@
+"""System prompt builder."""
+
+import os
+import platform
+
+
+def system_prompt(tools, skills=None) -> str:
+    cwd = os.getcwd()
+    tool_list = "\n".join(f"- **{tool.name}**: {tool.description}" for tool in tools)
+    uname = platform.uname()
+    skill_block = _format_skill_block(skills or [])
+
+    return f"""\
+{skill_block}
+
+You are KittyCode, an AI coding assistant running in the user's terminal.
+You help with software engineering: writing code, fixing bugs, refactoring, explaining code, running commands, and more.
+
+# Environment
+- Working directory: {cwd}
+- OS: {uname.system} {uname.release} ({uname.machine})
+- Python: {platform.python_version()}
+
+# Tools
+{tool_list}
+
+# Rules
+1. Read before edit. Always read a file before modifying it.
+2. edit_file for small changes. Use edit_file for targeted edits; write_file only for new files or complete rewrites.
+3. Verify your work. After making changes, run relevant tests or commands to confirm correctness.
+4. Be concise. Show code over prose. Explain only what is necessary.
+5. One step at a time. For multi-step tasks, execute them sequentially.
+6. edit_file uniqueness. When using edit_file, include enough surrounding context in old_string to guarantee a unique match.
+7. Respect existing style. Match the project's coding conventions.
+8. Ask when unsure. If the request is ambiguous, ask for clarification rather than guessing.
+"""
+
+
+def _format_skill_block(skills) -> str:
+    if not skills:
+        return "# Available Skills\n- None loaded from ~/.kittycode/skills"
+
+    lines = [
+        "# Available Skills",
+        "Use these local skills when relevant. If one looks useful, read its SKILL.md and any related files under the listed path before using it.",
+    ]
+    for skill in skills:
+        lines.append(f"- name: {skill.name}")
+        lines.append(f"  description: {skill.description}")
+        lines.append(f"  path: {skill.path}")
+    return "\n".join(lines)

kittycode/session.py

@@ -0,0 +1,66 @@
+"""Session persistence helpers."""
+
+import json
+import time
+from pathlib import Path
+
+SESSIONS_DIR = Path.home() / ".kittycode" / "sessions"
+
+
+def save_session(messages: list[dict], model: str, session_id: str | None = None) -> str:
+    """Save conversation to disk and return the session ID."""
+    SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+
+    if not session_id:
+        session_id = f"session_{int(time.time())}"
+
+    data = {
+        "id": session_id,
+        "model": model,
+        "saved_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "messages": messages,
+    }
+
+    path = SESSIONS_DIR / f"{session_id}.json"
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2))
+    return session_id
+
+
+def load_session(session_id: str) -> tuple[list[dict], str] | None:
+    """Load a saved session and return (messages, model)."""
+    path = SESSIONS_DIR / f"{session_id}.json"
+    if not path.exists():
+        return None
+
+    data = json.loads(path.read_text())
+    return data["messages"], data["model"]
+
+
+def list_sessions() -> list[dict]:
+    """List available sessions, newest first."""
+    if not SESSIONS_DIR.exists():
+        return []
+
+    sessions = []
+    for path in sorted(SESSIONS_DIR.glob("*.json"), reverse=True):
+        try:
+            data = json.loads(path.read_text())
+        except (json.JSONDecodeError, KeyError):
+            continue
+
+        preview = ""
+        for message in data.get("messages", []):
+            if message.get("role") == "user" and message.get("content"):
+                preview = message["content"][:80]
+                break
+
+        sessions.append(
+            {
+                "id": data.get("id", path.stem),
+                "model": data.get("model", "?"),
+                "saved_at": data.get("saved_at", "?"),
+                "preview": preview,
+            }
+        )
+
+    return sessions[:20]