kittycode 0.1.0__py3-none-any.whl

kittycode/skills.py

@@ -0,0 +1,125 @@
+"""Local skill discovery for KittyCode."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import re
+
+SKILLS_DIR = Path.home() / ".kittycode" / "skills"
+
+_NAME_PATTERN = re.compile(r'^\s*name:\s*["\']?(.*?)["\']?\s*$')
+_DESCRIPTION_PATTERN = re.compile(r'^\s*description:\s*["\']?(.*?)["\']?\s*$')
+
+_cached_skills: tuple["SkillDefinition", ...] | None = None
+_cached_root: Path | None = None
+_cached_signature: tuple | None = None
+
+
+@dataclass(frozen=True)
+class SkillDefinition:
+    name: str
+    description: str
+    path: str
+
+
+def load_skills(skills_dir: Path | str | None = None, force_reload: bool = False) -> list[SkillDefinition]:
+    """Load skill metadata from ~/.kittycode/skills into process memory."""
+    global _cached_root
+    global _cached_skills
+    global _cached_signature
+
+    root = Path(skills_dir).expanduser() if skills_dir is not None else SKILLS_DIR
+    root = root.resolve()
+    signature = _build_signature(root)
+
+    if (
+        not force_reload
+        and _cached_skills is not None
+        and _cached_root == root
+        and _cached_signature == signature
+    ):
+        return list(_cached_skills)
+
+    if not root.exists() or not root.is_dir():
+        _cached_root = root
+        _cached_skills = ()
+        _cached_signature = signature
+        return []
+
+    skills: list[SkillDefinition] = []
+    for entry in sorted(root.iterdir()):
+        if not entry.is_dir():
+            continue
+        skill_doc = entry / "SKILL.md"
+        if not skill_doc.is_file():
+            continue
+        skills.append(_read_skill(entry, skill_doc))
+
+    _cached_root = root
+    _cached_skills = tuple(skills)
+    _cached_signature = signature
+    return list(_cached_skills)
+
+
+def _build_signature(root: Path) -> tuple:
+    if not root.exists() or not root.is_dir():
+        return ("missing", str(root))
+
+    items = []
+    for entry in sorted(root.iterdir()):
+        if not entry.is_dir():
+            continue
+        skill_doc = entry / "SKILL.md"
+        if not skill_doc.is_file():
+            continue
+        stat = skill_doc.stat()
+        items.append((entry.name, stat.st_mtime_ns, stat.st_size))
+    return tuple(items)
+
+
+def _read_skill(skill_dir: Path, skill_doc: Path) -> SkillDefinition:
+    name, description = _parse_skill_header(skill_doc.read_text(errors="replace"))
+    return SkillDefinition(
+        name=name or skill_dir.name,
+        description=description or "No description provided.",
+        path=str(skill_dir.resolve()),
+    )
+
+
+def _parse_skill_header(text: str) -> tuple[str, str]:
+    lines = text.splitlines()
+    header_lines = lines[:40]
+
+    name = ""
+    description = ""
+
+    for line in header_lines:
+        if not name:
+            match = _NAME_PATTERN.match(line)
+            if match:
+                name = match.group(1).strip()
+                continue
+        if not description:
+            match = _DESCRIPTION_PATTERN.match(line)
+            if match:
+                description = match.group(1).strip()
+
+        if name and description:
+            return name, description
+
+    for line in lines[:20]:
+        stripped = line.strip()
+        if stripped.startswith("# "):
+            name = name or stripped[2:].strip()
+            break
+
+    if not description:
+        for line in lines[:40]:
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#") or stripped == "---":
+                continue
+            description = stripped
+            break
+
+    return name, description

kittycode/tools/__init__.py

@@ -0,0 +1,27 @@
+"""Tool registry."""
+
+from .agent import AgentTool
+from .bash import BashTool
+from .edit import EditFileTool
+from .glob_tool import GlobTool
+from .grep import GrepTool
+from .read import ReadFileTool
+from .write import WriteFileTool
+
+ALL_TOOLS = [
+    BashTool(),
+    ReadFileTool(),
+    WriteFileTool(),
+    EditFileTool(),
+    GlobTool(),
+    GrepTool(),
+    AgentTool(),
+]
+
+
+def get_tool(name: str):
+    """Look up a tool by name."""
+    for tool in ALL_TOOLS:
+        if tool.name == name:
+            return tool
+    return None

kittycode/tools/agent.py

@@ -0,0 +1,47 @@
+"""Sub-agent spawning."""
+
+from .base import Tool
+
+
+class AgentTool(Tool):
+    name = "agent"
+    description = (
+        "Spawn a sub-agent to handle a complex sub-task independently. "
+        "The sub-agent has its own context and tool access. Use this for: "
+        "researching a codebase, implementing a multi-step change in isolation, "
+        "or any task that would benefit from a fresh context window."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "task": {
+                "type": "string",
+                "description": "What the sub-agent should accomplish",
+            },
+        },
+        "required": ["task"],
+    }
+
+    _parent_agent = None
+
+    def execute(self, task: str) -> str:
+        if self._parent_agent is None:
+            return "Error: agent tool not initialized (no parent agent)"
+
+        from ..agent import Agent
+
+        parent = self._parent_agent
+        sub_agent = Agent(
+            llm=parent.llm,
+            tools=[tool for tool in parent.tools if tool.name != "agent"],
+            max_context_tokens=parent.context.max_tokens,
+            max_rounds=20,
+        )
+
+        try:
+            result = sub_agent.chat(task)
+            if len(result) > 5000:
+                result = result[:4500] + "\n... (sub-agent output truncated)"
+            return f"[Sub-agent completed]\n{result}"
+        except Exception as exc:
+            return f"Sub-agent error: {exc}"

kittycode/tools/base.py

@@ -0,0 +1,25 @@
+"""Base class for all tools."""
+
+from abc import ABC, abstractmethod
+
+
+class Tool(ABC):
+    """Minimal tool interface."""
+
+    name: str
+    description: str
+    parameters: dict
+
+    @abstractmethod
+    def execute(self, **kwargs) -> str:
+        """Run the tool and return a text result."""
+
+    def schema(self) -> dict:
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }

kittycode/tools/bash.py

@@ -0,0 +1,100 @@
+"""Shell command execution with basic safety checks."""
+
+import os
+import re
+import subprocess
+
+from .base import Tool
+
+_cwd: str | None = None
+
+_DANGEROUS_PATTERNS = [
+    (r"\brm\s+(-\w*)?-r\w*\s+(/|~|\$HOME)", "recursive delete on home/root"),
+    (r"\brm\s+(-\w*)?-rf\s", "force recursive delete"),
+    (r"\bmkfs\b", "format filesystem"),
+    (r"\bdd\s+.*of=/dev/", "raw disk write"),
+    (r">\s*/dev/sd[a-z]", "overwrite block device"),
+    (r"\bchmod\s+(-R\s+)?777\s+/", "chmod 777 on root"),
+    (r":\(\)\s*\{.*:\|:.*\}", "fork bomb"),
+    (r"\bcurl\b.*\|\s*(sudo\s+)?bash", "pipe curl to bash"),
+    (r"\bwget\b.*\|\s*(sudo\s+)?bash", "pipe wget to bash"),
+]
+
+
+class BashTool(Tool):
+    name = "bash"
+    description = (
+        "Execute a shell command. Returns stdout, stderr, and exit code. "
+        "Use this for running tests, installing packages, git operations, and similar tasks."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "command": {
+                "type": "string",
+                "description": "The shell command to run",
+            },
+            "timeout": {
+                "type": "integer",
+                "description": "Timeout in seconds (default 120)",
+            },
+        },
+        "required": ["command"],
+    }
+
+    def execute(self, command: str, timeout: int = 120) -> str:
+        global _cwd
+
+        warning = _check_dangerous(command)
+        if warning:
+            return f"Blocked: {warning}\nCommand: {command}\nIf intentional, modify the command to be more specific."
+
+        cwd = _cwd or os.getcwd()
+
+        try:
+            process = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                cwd=cwd,
+            )
+        except subprocess.TimeoutExpired:
+            return f"Error: timed out after {timeout}s"
+        except Exception as exc:
+            return f"Error running command: {exc}"
+
+        if process.returncode == 0:
+            _update_cwd(command, cwd)
+
+        output = process.stdout
+        if process.stderr:
+            output += f"\n[stderr]\n{process.stderr}"
+        if process.returncode != 0:
+            output += f"\n[exit code: {process.returncode}]"
+        if len(output) > 15_000:
+            output = output[:6000] + f"\n\n... truncated ({len(output)} chars total) ...\n\n" + output[-3000:]
+        return output.strip() or "(no output)"
+
+
+def _check_dangerous(command: str) -> str | None:
+    for pattern, reason in _DANGEROUS_PATTERNS:
+        if re.search(pattern, command):
+            return reason
+    return None
+
+
+def _update_cwd(command: str, current_cwd: str):
+    global _cwd
+
+    for part in command.split("&&"):
+        part = part.strip()
+        if not part.startswith("cd "):
+            continue
+        target = part[3:].strip().strip("'\"")
+        if not target:
+            continue
+        new_dir = os.path.normpath(os.path.join(current_cwd, os.path.expanduser(target)))
+        if os.path.isdir(new_dir):
+            _cwd = new_dir

kittycode/tools/edit.py

@@ -0,0 +1,74 @@
+"""Search-and-replace file editing."""
+
+import difflib
+from pathlib import Path
+
+from .base import Tool
+
+
+class EditFileTool(Tool):
+    name = "edit_file"
+    description = (
+        "Edit a file by replacing an exact string match. "
+        "old_string must appear exactly once in the file for safety. "
+        "Include enough surrounding context to ensure uniqueness."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "file_path": {
+                "type": "string",
+                "description": "Path to the file to edit",
+            },
+            "old_string": {
+                "type": "string",
+                "description": "Exact text to find (must be unique in file)",
+            },
+            "new_string": {
+                "type": "string",
+                "description": "Replacement text",
+            },
+        },
+        "required": ["file_path", "old_string", "new_string"],
+    }
+
+    def execute(self, file_path: str, old_string: str, new_string: str) -> str:
+        try:
+            path = Path(file_path).expanduser().resolve()
+            if not path.exists():
+                return f"Error: {file_path} not found"
+
+            content = path.read_text()
+            occurrences = content.count(old_string)
+
+            if occurrences == 0:
+                preview = content[:500] + ("..." if len(content) > 500 else "")
+                return f"Error: old_string not found in {file_path}.\nFile starts with:\n{preview}"
+            if occurrences > 1:
+                return (
+                    f"Error: old_string appears {occurrences} times in {file_path}. "
+                    "Include more surrounding lines to make it unique."
+                )
+
+            new_content = content.replace(old_string, new_string, 1)
+            path.write_text(new_content)
+            diff = _unified_diff(content, new_content, str(path))
+            return f"Edited {file_path}\n{diff}"
+        except Exception as exc:
+            return f"Error: {exc}"
+
+
+def _unified_diff(old: str, new: str, filename: str, context: int = 3) -> str:
+    old_lines = old.splitlines(keepends=True)
+    new_lines = new.splitlines(keepends=True)
+    diff = difflib.unified_diff(
+        old_lines,
+        new_lines,
+        fromfile=f"a/{filename}",
+        tofile=f"b/{filename}",
+        n=context,
+    )
+    result = "".join(diff)
+    if len(result) > 3000:
+        result = result[:2500] + "\n... (diff truncated)\n"
+    return result

kittycode/tools/glob_tool.py

@@ -0,0 +1,42 @@
+"""File pattern matching."""
+
+from pathlib import Path
+
+from .base import Tool
+
+
+class GlobTool(Tool):
+    name = "glob"
+    description = "Find files matching a glob pattern. Supports ** for recursive matching."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "pattern": {
+                "type": "string",
+                "description": "Glob pattern, for example '**/*.py' or 'src/**/*.ts'",
+            },
+            "path": {
+                "type": "string",
+                "description": "Directory to search in (default: cwd)",
+            },
+        },
+        "required": ["pattern"],
+    }
+
+    def execute(self, pattern: str, path: str = ".") -> str:
+        try:
+            base = Path(path).expanduser().resolve()
+            if not base.is_dir():
+                return f"Error: {path} is not a directory"
+
+            hits = list(base.glob(pattern))
+            hits.sort(key=lambda item: item.stat().st_mtime if item.exists() else 0, reverse=True)
+
+            total = len(hits)
+            shown = hits[:100]
+            result = "\n".join(str(item) for item in shown)
+            if total > 100:
+                result += f"\n... ({total} matches, showing first 100)"
+            return result or "No files matched."
+        except Exception as exc:
+            return f"Error: {exc}"

kittycode/tools/grep.py

@@ -0,0 +1,70 @@
+"""Content search with regex support."""
+
+import re
+from pathlib import Path
+
+from .base import Tool
+
+_SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".tox", "dist", "build"}
+
+
+class GrepTool(Tool):
+    name = "grep"
+    description = "Search file contents with regex. Returns matching lines with file path and line number."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "pattern": {
+                "type": "string",
+                "description": "Regex pattern to search for",
+            },
+            "path": {
+                "type": "string",
+                "description": "File or directory to search (default: cwd)",
+            },
+            "include": {
+                "type": "string",
+                "description": "Only search files matching this glob (for example '*.py')",
+            },
+        },
+        "required": ["pattern"],
+    }
+
+    def execute(self, pattern: str, path: str = ".", include: str | None = None) -> str:
+        try:
+            regex = re.compile(pattern)
+        except re.error as exc:
+            return f"Invalid regex: {exc}"
+
+        base = Path(path).expanduser().resolve()
+        if not base.exists():
+            return f"Error: {path} not found"
+
+        files = [base] if base.is_file() else self._walk(base, include)
+        matches = []
+
+        for file_path in files:
+            try:
+                text = file_path.read_text(errors="ignore")
+            except OSError:
+                continue
+            for line_number, line in enumerate(text.splitlines(), 1):
+                if regex.search(line):
+                    matches.append(f"{file_path}:{line_number}: {line.rstrip()}")
+                    if len(matches) >= 200:
+                        matches.append("... (200 match limit reached)")
+                        return "\n".join(matches)
+
+        return "\n".join(matches) if matches else "No matches found."
+
+    @staticmethod
+    def _walk(root: Path, include: str | None) -> list[Path]:
+        results = []
+        for item in root.rglob(include or "*"):
+            if any(part in _SKIP_DIRS for part in item.parts):
+                continue
+            if item.is_file():
+                results.append(item)
+            if len(results) >= 5000:
+                break
+        return results

kittycode/tools/read.py

@@ -0,0 +1,49 @@
+"""File reading with line numbers."""
+
+from pathlib import Path
+
+from .base import Tool
+
+
+class ReadFileTool(Tool):
+    name = "read_file"
+    description = "Read a file's contents with line numbers. Always read a file before editing it."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "file_path": {
+                "type": "string",
+                "description": "Path to the file",
+            },
+            "offset": {
+                "type": "integer",
+                "description": "Start line (1-based). Default 1.",
+            },
+            "limit": {
+                "type": "integer",
+                "description": "Max lines to read. Default 2000.",
+            },
+        },
+        "required": ["file_path"],
+    }
+
+    def execute(self, file_path: str, offset: int = 1, limit: int = 2000) -> str:
+        try:
+            path = Path(file_path).expanduser().resolve()
+            if not path.exists():
+                return f"Error: {file_path} not found"
+            if not path.is_file():
+                return f"Error: {file_path} is a directory, not a file"
+
+            text = path.read_text(errors="replace")
+            lines = text.splitlines()
+            total = len(lines)
+            start = max(0, offset - 1)
+            chunk = lines[start : start + limit]
+            result = "\n".join(f"{start + index + 1}\t{line}" for index, line in enumerate(chunk))
+
+            if total > start + limit:
+                result += f"\n... ({total} lines total, showing {start + 1}-{start + len(chunk)})"
+            return result or "(empty file)"
+        except Exception as exc:
+            return f"Error: {exc}"

kittycode/tools/write.py

@@ -0,0 +1,37 @@
+"""File creation and overwrite."""
+
+from pathlib import Path
+
+from .base import Tool
+
+
+class WriteFileTool(Tool):
+    name = "write_file"
+    description = (
+        "Create a new file or completely overwrite an existing one. "
+        "For small edits to existing files, prefer edit_file instead."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "file_path": {
+                "type": "string",
+                "description": "Path for the file",
+            },
+            "content": {
+                "type": "string",
+                "description": "Full file content to write",
+            },
+        },
+        "required": ["file_path", "content"],
+    }
+
+    def execute(self, file_path: str, content: str) -> str:
+        try:
+            path = Path(file_path).expanduser().resolve()
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content)
+            line_count = content.count("\n") + (1 if content and not content.endswith("\n") else 0)
+            return f"Wrote {line_count} lines to {file_path}"
+        except Exception as exc:
+            return f"Error: {exc}"

kittycode-0.1.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: kittycode
+Version: 0.1.0
+Summary: Minimal AI coding agent with a simple tool loop.
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.84.0
+Requires-Dist: openai>=1.0
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'

kittycode-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+kittycode/__init__.py,sha256=KNsr0hwd0oqenca60YTaP58jSUxJXJnS-uK0-kAI004,270
+kittycode/__main__.py,sha256=IRrpi8LZaa6mIX0XE4L_YpJXRx71ROB2YFRvWa0lkAE,38
+kittycode/agent.py,sha256=XQAs9M7VU2tBXV2wdbRDg_3vtEj9FKaY_2-gaD2tmwk,4535
+kittycode/cli.py,sha256=jdQngnbNWckbB-nt6QmSGHqc8J6yUcZiS72NMj8Gn40,12949
+kittycode/config.py,sha256=2QqicFzv52DsKpaVaqXozPVjo4bhIYd7Emo2piCD-T8,2240
+kittycode/context.py,sha256=OAGbsRocuux0ESwyEoU-Pvm1A-2wF10e_ImXx57CRkM,5674
+kittycode/llm.py,sha256=R_KG52LzgKuIdS5mcQjs8VGFpLOCaRWYujgXjY3030w,10805
+kittycode/prompt.py,sha256=hFxpKWH5lF9hyHsjsoidi6rz-NHUrz4q2U9_9YuneeM,1934
+kittycode/session.py,sha256=yccMoo1utJr1Z0qpwXPp1ekRXeyeQrdruf5y7Sg-pDg,1874
+kittycode/skills.py,sha256=cLEVw7BgIxqOnresLcbwcPRWoFHIDsicaLRCQRMnJPI,3552
+kittycode/tools/__init__.py,sha256=MsDYpDJ_uvEBXcyrnGpQGVc0iamTzb4DFI3NeMNnfuc,532
+kittycode/tools/agent.py,sha256=qlCI9_-SjilI47W6ZO9oPvKOID9MOU4-Eu6JupOJlvw,1456
+kittycode/tools/base.py,sha256=r6dLpKXrtIhWXgjkh19dawP46ND7hW9px3r_Sv5R1Sc,554
+kittycode/tools/bash.py,sha256=_QlJNclhm_NQr9n3jqrNLLIfYuP9lmwA8gU_4ZuB608,3118
+kittycode/tools/edit.py,sha256=XkrTwtTMCRq1xPGnAeny0D6sugZF0JUaFuSfm3yQgBE,2485
+kittycode/tools/glob_tool.py,sha256=O-ZDA6p5ct05vOjJRG7BCZ1snVKcmoDwE_v64INAJxg,1339
+kittycode/tools/grep.py,sha256=WsGTikXS63Ikymj1N_4TWGU6fpRgQ-MUf4OVpwnCTzc,2332
+kittycode/tools/read.py,sha256=JsLTVhWU2frFHJ6ZvuQXsknj551QnzHxf7eKxhA3aAQ,1676
+kittycode/tools/write.py,sha256=xE7fwR_fzy4ICjtIqWuxNsspit46Zuc6QsQPmzubw8c,1157
+kittycode-0.1.0.dist-info/METADATA,sha256=fEKFzouoWjtUm7hViF3rZqhObip1vGvDF_Z9DFfm00Q,354
+kittycode-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+kittycode-0.1.0.dist-info/entry_points.txt,sha256=iEq5GUG9tFU05NFy_ZaspTGTYx8K1soh6VJyXkp7D7g,49
+kittycode-0.1.0.dist-info/licenses/LICENSE,sha256=gcy4YmZ3vpRS_rc2H8uzH6YN_RLKPQS5nojKRsdZlXo,1065
+kittycode-0.1.0.dist-info/RECORD,,

kittycode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

kittycode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kittycode = kittycode.cli:main

kittycode-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jimmy Ye
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.