mita-code 0.1.0__py3-none-any.whl

mita/__init__.py

@@ -0,0 +1,5 @@
+"""Mita Code — Local-first agentic coding assistant powered by Ollama."""
+
+from importlib.metadata import version
+
+__version__ = version("mita-code")

mita/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running mita as `python -m mita`."""
+
+from mita.cli import app
+
+app()

mita/agent/__init__.py

@@ -0,0 +1 @@
+"""Core agent loop: prompt -> LLM -> tool calls -> execute -> loop."""

mita/agent/context.py

@@ -0,0 +1,43 @@
+"""Context assembly: memory + tool definitions → system prompt."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mita.agent.conversation import Conversation, Message, Role
+from mita.agent.system_prompt import build_system_prompt
+from mita.config.schema import MitaConfig
+from mita.memory.loader import load_memory
+from mita.tools.registry import ToolRegistry
+
+
+def assemble_context(
+    conversation: Conversation,
+    config: MitaConfig,
+    registry: ToolRegistry,
+    cwd: Path | None = None,
+) -> None:
+    """Assemble the initial context for the agent loop.
+
+    Builds the system prompt from config, memory, and tool definitions,
+    and adds it to the conversation.
+
+    Args:
+        conversation: The conversation to add the system message to.
+        config: Application configuration.
+        registry: Tool registry with all available tools.
+        cwd: Working directory for memory discovery. Defaults to Path.cwd().
+    """
+    working_dir = cwd or Path.cwd()
+
+    # Load memory from MITA.md files
+    memory_content = load_memory(cwd=working_dir)
+
+    # Build system prompt
+    system_prompt = build_system_prompt(
+        config=config,
+        memory=memory_content,
+        tools=registry.get_definitions(),
+    )
+
+    conversation.add(Message(role=Role.SYSTEM, content=system_prompt))

mita/agent/conversation.py

@@ -0,0 +1,101 @@
+"""Message history management with token counting and truncation."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class Role(StrEnum):
+    """Message roles in the conversation."""
+
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+    TOOL = "tool"
+
+
+class Message(BaseModel):
+    """A single message in the conversation."""
+
+    role: Role
+    content: str
+    tool_calls: list[dict[str, Any]] = Field(default_factory=list)
+    tool_call_id: str | None = None  # for tool-result messages
+    name: str | None = None  # tool name for tool-result messages
+
+    def to_api_dict(self) -> dict[str, Any]:
+        """Convert to LiteLLM/OpenAI API format."""
+        msg: dict[str, Any] = {"role": self.role.value, "content": self.content}
+        if self.tool_calls:
+            msg["tool_calls"] = self.tool_calls
+        if self.tool_call_id is not None:
+            msg["tool_call_id"] = self.tool_call_id
+        if self.name is not None:
+            msg["name"] = self.name
+        return msg
+
+
+class Conversation(BaseModel):
+    """Conversation history with token estimation and truncation."""
+
+    messages: list[Message] = Field(default_factory=list)
+    total_tokens: int = 0
+
+    def add(self, msg: Message) -> None:
+        """Add a message to the conversation."""
+        self.messages.append(msg)
+        # Rough token estimate: ~4 chars per token
+        self.total_tokens += _estimate_tokens(msg.content)
+
+    def get_messages_for_api(self) -> list[dict[str, Any]]:
+        """Convert all messages to API format."""
+        return [m.to_api_dict() for m in self.messages]
+
+    def truncate_to_fit(self, max_tokens: int) -> None:
+        """Truncate conversation to fit within the token budget.
+
+        Strategy: Keep the system message(s) and last N messages.
+        Remove oldest non-system messages first.
+        """
+        if self.total_tokens <= max_tokens:
+            return
+
+        # Separate system messages from the rest
+        system_msgs = [m for m in self.messages if m.role == Role.SYSTEM]
+        other_msgs = [m for m in self.messages if m.role != Role.SYSTEM]
+
+        system_tokens = sum(_estimate_tokens(m.content) for m in system_msgs)
+        budget = max_tokens - system_tokens
+
+        if budget <= 0:
+            # System prompt alone exceeds budget — keep just the last system msg
+            self.messages = system_msgs[-1:] if system_msgs else []
+            self.total_tokens = sum(_estimate_tokens(m.content) for m in self.messages)
+            return
+
+        # Keep messages from the end until we hit the budget
+        kept: list[Message] = []
+        used = 0
+        for msg in reversed(other_msgs):
+            msg_tokens = _estimate_tokens(msg.content)
+            if used + msg_tokens > budget:
+                break
+            kept.append(msg)
+            used += msg_tokens
+
+        kept.reverse()
+        self.messages = system_msgs + kept
+        self.total_tokens = system_tokens + used
+
+    def clear_non_system(self) -> None:
+        """Clear all non-system messages (for /clear command)."""
+        self.messages = [m for m in self.messages if m.role == Role.SYSTEM]
+        self.total_tokens = sum(_estimate_tokens(m.content) for m in self.messages)
+
+
+def _estimate_tokens(text: str) -> int:
+    """Rough token estimate: ~4 characters per token."""
+    return max(1, len(text) // 4)