ottopilot 0.1.0__py3-none-any.whl

ottoai/__init__.py

@@ -0,0 +1,7 @@
+"""OttoAI — a local-first, extensible coding agent."""
+
+__version__ = "0.1.0"
+
+from .types import Message, ToolCall, ToolResult, ChatResponse
+
+__all__ = ["Message", "ToolCall", "ToolResult", "ChatResponse", "__version__"]

ottoai/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ottoai/agent.py

@@ -0,0 +1,244 @@
+"""The agent loop: orchestrates provider + tools + memory for one user turn."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Optional
+
+from .memory import Store
+from .memory.compaction import compact, should_compact
+from .memory.embeddings import Embedder
+from .prompts import build_system_prompt
+from .providers import build_provider
+from .tools import ToolContext, ToolRegistry
+from .types import ChatResponse, Message, ToolCall, ToolResult
+
+
+class Agent:
+    """Drives a single session. Holds the active (in-context) message list and
+    persists everything to the Store."""
+
+    def __init__(
+        self,
+        config: Any,
+        store: Store,
+        cwd: str,
+        provider_name: Optional[str] = None,
+        model: Optional[str] = None,
+        session_id: Optional[str] = None,
+        confirm: Optional[Callable[[str, dict], bool]] = None,
+        on_event: Optional[Callable[[str, dict], None]] = None,
+    ):
+        self.config = config
+        self.store = store
+        self.cwd = cwd
+        self.provider_name = provider_name or config.get("default_provider", "ollama")
+        self.model = model or config.get("default_model", "qwen3")
+        self.confirm = confirm or (lambda name, args: True)
+        self.on_event = on_event or (lambda ev, data: None)
+
+        self.provider = build_provider(self.provider_name, config)
+        self.embedder = Embedder(config)
+
+        # Session + tool context.
+        if session_id:
+            self.session_id = session_id
+            self.messages = self.store.get_messages(session_id)
+        else:
+            self.session_id = self.store.create_session(
+                cwd=cwd, provider=self.provider_name, model=self.model
+            )
+            self.messages = []
+
+        self.context = ToolContext(
+            cwd=cwd, store=store, config=config, session_id=self.session_id
+        )
+        self.registry = ToolRegistry(self.context)
+        self.registry.load_all()
+        self._load_mcp()
+
+        if not self.messages:
+            self._ensure_system_message()
+
+    # ---------- setup helpers ----------
+    def _load_mcp(self) -> None:
+        servers = self.config.get("mcp_servers", {})
+        if not servers:
+            return
+        try:
+            from .tools.mcp import register_mcp_servers
+
+            register_mcp_servers(self.registry, servers)
+        except Exception as e:  # pragma: no cover
+            self.on_event("warn", {"message": f"MCP load failed: {e}"})
+
+    def _ensure_system_message(self) -> None:
+        mem = self._memory_context()
+        sys_msg = Message(role="system", content=build_system_prompt(self.cwd, self.config, mem))
+        self.messages.insert(0, sys_msg)
+        self.store.add_message(self.session_id, sys_msg)
+
+    def _memory_context(self) -> str:
+        facts = self.store.list_memory()
+        if not facts:
+            return ""
+        return "\n".join(f"- ({f['subject']}) {f['fact']}" for f in facts[:20])
+
+    # ---------- main entry ----------
+    def switch_provider(self, provider_name: str, model: Optional[str] = None) -> None:
+        self.provider_name = provider_name
+        self.provider = build_provider(provider_name, self.config)
+        if model:
+            self.model = model
+        self.store.touch_session(self.session_id, provider=provider_name, model=self.model)
+
+    # ---------- thinking mode ----------
+    COMPLEX_HINTS = (
+        "debug", "why", "fix", "bug", "error", "stack trace", "traceback", "root cause",
+        "algorithm", "optimize", "optimis", "refactor", "design", "architect", "plan",
+        "prove", "calculate", "compute", "math", "analyze", "analyse", "analysis",
+        "compare", "performance", "concurren", "race condition", "deadlock", "complexity",
+        "reason", "step by step", "edge case", "strateg", "trade-off", "tradeoff",
+        "review", "security", "vulnerab", "migrate", "implement", "architecture",
+    )
+
+    def _looks_complex(self, text: str) -> bool:
+        t = text.lower().strip()
+        if len(t.split()) >= 30:
+            return True
+        if "```" in text or "\n" in t:  # multi-line input / pasted code
+            return True
+        if t.count("?") >= 2 or " and then " in t:
+            return True
+        return any(h in t for h in self.COMPLEX_HINTS)
+
+    def _resolve_think(self, user_input: str) -> bool:
+        setting = self.config.get("think", True)
+        if isinstance(setting, bool):
+            return setting
+        if isinstance(setting, str):
+            s = setting.lower()
+            if s == "auto":
+                enabled = self._looks_complex(user_input)
+                self.on_event("think_mode", {"auto": True, "enabled": enabled})
+                return enabled
+            return s in ("1", "true", "on", "yes")
+        return True
+
+    def run_turn(self, user_input: str) -> str:
+        user_msg = Message(role="user", content=user_input)
+        self.messages.append(user_msg)
+        self.store.add_message(self.session_id, user_msg)
+        self._index_embedding(user_msg)
+
+        # Resolve the thinking mode once per user turn (handles "auto").
+        self._active_think = self._resolve_think(user_input)
+
+        if self.store.get_session(self.session_id)["title"] in ("Untitled session", None):
+            self.store.touch_session(self.session_id, title=user_input[:60])
+
+        max_iters = self.config.get("max_tool_iterations", 25)
+        tool_specs = self.registry.specs()
+
+        for _ in range(max_iters):
+            self._maybe_compact()
+            self.on_event("thinking", {"model": self.model, "provider": self.provider_name})
+            resp = self._get_response(tool_specs)
+
+            assistant_msg = Message(
+                role="assistant", content=resp.content, tool_calls=resp.tool_calls
+            )
+            self.messages.append(assistant_msg)
+            self.store.add_message(self.session_id, assistant_msg)
+            if resp.content:
+                self._index_embedding(assistant_msg)
+
+            if not resp.wants_tools:
+                return resp.content
+
+            if resp.content and not self.config.get("stream", True):
+                self.on_event("assistant_text", {"text": resp.content})
+
+            for call in resp.tool_calls:
+                result = self._execute_tool(call)
+                tool_msg = Message(
+                    role="tool",
+                    content=result.content,
+                    tool_call_id=call.id,
+                    name=call.name,
+                )
+                self.messages.append(tool_msg)
+                self.store.add_message(self.session_id, tool_msg)
+
+        return "[stopped: reached max tool iterations]"
+
+    def _get_response(self, tool_specs: list) -> "ChatResponse":
+        """Run one model turn, streaming deltas as events when enabled."""
+        think = getattr(self, "_active_think", True)
+        if not self.config.get("stream", True):
+            return self.provider.chat(
+                self.messages, tools=tool_specs or None, model=self.model, think=think
+            )
+
+        final = None
+        streamed = False
+        for chunk in self.provider.chat_stream(
+            self.messages, tools=tool_specs or None, model=self.model, think=think
+        ):
+            if chunk.kind == "text" and chunk.text:
+                streamed = True
+                self.on_event("assistant_delta", {"text": chunk.text})
+            elif chunk.kind == "final":
+                final = chunk.response
+        if streamed:
+            self.on_event("assistant_done", {})
+        if final is None:  # defensive fallback
+            final = self.provider.chat(
+                self.messages, tools=tool_specs or None, model=self.model, think=think
+            )
+        return final
+
+    # ---------- tool execution ----------
+    def _execute_tool(self, call: ToolCall) -> ToolResult:
+        tool = self.registry.get(call.name)
+        if tool is None:
+            return ToolResult(call.id, call.name, f"[error] unknown tool: {call.name}", True)
+
+        self.on_event("tool_start", {"name": call.name, "arguments": call.arguments})
+        if tool.requires_confirmation and not self.confirm(call.name, call.arguments):
+            msg = "[denied] user declined to run this tool."
+            self.on_event("tool_end", {"name": call.name, "result": msg, "denied": True})
+            return ToolResult(call.id, call.name, msg, True)
+        try:
+            output = tool.run(**call.arguments)
+        except Exception as e:
+            output = f"[error] tool '{call.name}' raised: {e}"
+        self.on_event("tool_end", {"name": call.name, "result": output})
+        return ToolResult(call.id, call.name, output)
+
+    # ---------- memory / compaction ----------
+    def _maybe_compact(self) -> None:
+        if should_compact(self.messages, self.config):
+            self.on_event("compacting", {"count": len(self.messages)})
+            self.messages = compact(self.messages, self.provider, self.model, self.config)
+
+    def force_compact(self) -> None:
+        self.messages = compact(self.messages, self.provider, self.model, self.config)
+
+    def _index_embedding(self, msg: Message) -> None:
+        if not msg.content:
+            return
+        vec = self.embedder.embed_one(msg.content)
+        if vec:
+            import uuid
+
+            self.store.add_embedding(
+                uuid.uuid4().hex, "message", self.session_id, msg.content[:2000], vec
+            )
+
+    def remember(self, subject: str, fact: str, scope: str = "user") -> None:
+        self.store.add_memory(subject, fact, scope, self.session_id)
+        vec = self.embedder.embed_one(fact)
+        if vec:
+            import uuid
+
+            self.store.add_embedding(uuid.uuid4().hex, "memory", self.session_id, fact, vec)