iac-code 0.1.0__py3-none-any.whl

iac_code/memory/__init__.py

@@ -0,0 +1 @@
+# Memory system package.

iac_code/memory/memory_manager.py

@@ -0,0 +1,92 @@
+"""Persistent memory system — stores memories across sessions."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+MEMORY_TYPES = {"user", "feedback", "project", "reference"}
+INDEX_FILE = "MEMORY.md"
+MAX_INDEX_LINES = 200
+
+
+class MemoryManager:
+    def __init__(self, memory_dir: str):
+        self._memory_dir = memory_dir
+        os.makedirs(memory_dir, exist_ok=True)
+
+    def _memory_path(self, name: str) -> str:
+        return os.path.join(self._memory_dir, f"{name}.md")
+
+    def _index_path(self) -> str:
+        return os.path.join(self._memory_dir, INDEX_FILE)
+
+    def save(self, name: str, content: str, memory_type: str, description: str) -> None:
+        if memory_type not in MEMORY_TYPES:
+            raise ValueError(f"Invalid memory type: {memory_type}")
+        file_content = f"---\nname: {name}\ndescription: {description}\ntype: {memory_type}\n---\n\n{content}\n"
+        with open(self._memory_path(name), "w", encoding="utf-8") as f:
+            f.write(file_content)
+        self._update_index()
+
+    def load(self, name: str) -> dict[str, Any] | None:
+        path = self._memory_path(name)
+        if not os.path.exists(path):
+            return None
+        with open(path, encoding="utf-8") as f:
+            return self._parse_memory_file(f.read())
+
+    def delete(self, name: str) -> None:
+        path = self._memory_path(name)
+        if os.path.exists(path):
+            os.remove(path)
+        self._update_index()
+
+    def list_memories(self) -> list[dict[str, Any]]:
+        memories = []
+        for filename in os.listdir(self._memory_dir):
+            if filename.endswith(".md") and filename != INDEX_FILE:
+                mem = self.load(filename[:-3])
+                if mem:
+                    memories.append(mem)
+        return memories
+
+    def get_index_content(self) -> str:
+        path = self._index_path()
+        if not os.path.exists(path):
+            return ""
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+
+    def get_prompt_content(self) -> str:
+        memories = self.list_memories()
+        if not memories:
+            return ""
+        return "\n\n".join(f"[{m.get('type', '')}] {m['content']}" for m in memories)
+
+    def _update_index(self) -> None:
+        entries = []
+        for filename in sorted(os.listdir(self._memory_dir)):
+            if filename.endswith(".md") and filename != INDEX_FILE:
+                mem = self.load(filename[:-3])
+                if mem:
+                    entries.append(f"- [{filename[:-3]}]({filename}) — {mem.get('description', '')}")
+        with open(self._index_path(), "w", encoding="utf-8") as f:
+            f.write("\n".join(entries[:MAX_INDEX_LINES]) + "\n")
+
+    @staticmethod
+    def _parse_memory_file(text: str) -> dict[str, Any]:
+        result: dict[str, Any] = {}
+        if text.startswith("---"):
+            parts = text.split("---", 2)
+            if len(parts) >= 3:
+                for line in parts[1].strip().split("\n"):
+                    if ":" in line:
+                        key, value = line.split(":", 1)
+                        result[key.strip()] = value.strip()
+                result["content"] = parts[2].strip()
+            else:
+                result["content"] = text
+        else:
+            result["content"] = text
+        return result

iac_code/memory/memory_tools.py

@@ -0,0 +1,88 @@
+"""Tools for the model to read and write persistent memories."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from iac_code.memory.memory_manager import MEMORY_TYPES, MemoryManager
+from iac_code.tools.base import Tool, ToolContext, ToolResult
+
+
+class ReadMemoryTool(Tool):
+    def __init__(self, memory_manager: MemoryManager):
+        self._manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "read_memory"
+
+    @property
+    def description(self) -> str:
+        return "Read persistent memories. Omit name to list all, or provide name to read specific memory."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Memory name to read. Omit to list all.",
+                }
+            },
+        }
+
+    async def execute(self, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        name = tool_input.get("name")
+        if name:
+            mem = self._manager.load(name)
+            if mem is None:
+                return ToolResult.error(f"Memory '{name}' not found.")
+            return ToolResult.success(f"[{mem.get('type', '')}] {mem.get('description', '')}\n\n{mem['content']}")
+        else:
+            index = self._manager.get_index_content()
+            return ToolResult.success(index or "No memories saved yet.")
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return True
+
+
+class WriteMemoryTool(Tool):
+    def __init__(self, memory_manager: MemoryManager):
+        self._manager = memory_manager
+
+    @property
+    def name(self) -> str:
+        return "write_memory"
+
+    @property
+    def description(self) -> str:
+        return f"Save a persistent memory. Types: {', '.join(sorted(MEMORY_TYPES))}."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"},
+                "content": {"type": "string"},
+                "memory_type": {"type": "string", "enum": sorted(MEMORY_TYPES)},
+                "description": {"type": "string"},
+            },
+            "required": ["name", "content", "memory_type", "description"],
+        }
+
+    async def execute(self, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        try:
+            self._manager.save(
+                name=tool_input["name"],
+                content=tool_input["content"],
+                memory_type=tool_input["memory_type"],
+                description=tool_input["description"],
+            )
+            return ToolResult.success(f"Memory '{tool_input['name']}' saved.")
+        except Exception as e:
+            return ToolResult.error(str(e))
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return False

iac_code/providers/__init__.py

@@ -0,0 +1 @@
+# Provider layer package.

iac_code/providers/anthropic_provider.py

@@ -0,0 +1,284 @@
+"""Anthropic provider — streams and completes via the Anthropic SDK."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from typing import Any
+
+import anthropic
+
+from iac_code.providers.base import (
+    ContentBlock,
+    Message,
+    NonStreamingResponse,
+    Provider,
+    ToolDefinition,
+)
+from iac_code.providers.thinking import (
+    ANTHROPIC_BUDGET,
+    ThinkingFamily,
+    get_thinking_spec,
+    normalize_effort,
+)
+from iac_code.types.stream_events import (
+    MessageEndEvent,
+    MessageStartEvent,
+    StreamEvent,
+    TextDeltaEvent,
+    ThinkingDeltaEvent,
+    ToolInputDeltaEvent,
+    ToolUseStartEvent,
+    Usage,
+)
+from iac_code.utils.tool_input_parser import parse_tool_input_events
+
+# Model aliases for variants that share a real model ID but require beta flags.
+# Value format: (real_model_id, extra_beta_features)
+_MODEL_ALIAS: dict[str, tuple[str, tuple[str, ...]]] = {
+    "claude-sonnet-4-6-1m": ("claude-sonnet-4-6", ("context-1m-2025-08-07",)),
+}
+
+
+class AnthropicProvider(Provider):
+    """Provider implementation backed by ``anthropic.AsyncAnthropic``."""
+
+    def __init__(
+        self,
+        model: str,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        max_tokens: int = 8192,
+        client: Any = None,
+        effort: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self._model = model
+        self._max_tokens = max_tokens
+        self._effort = effort
+        if client is not None:
+            self._client = client
+        else:
+            client_kwargs: dict[str, Any] = {}
+            if api_key is not None:
+                client_kwargs["api_key"] = api_key
+            if base_url is not None:
+                client_kwargs["base_url"] = base_url
+            client_kwargs.update(kwargs)
+            self._client = anthropic.AsyncAnthropic(**client_kwargs)
+
+    # -- public interface ------------------------------------------------------
+
+    _PROVIDER_KEY = "anthropic"
+
+    def get_model_name(self) -> str:
+        return self._model
+
+    def _build_thinking_kwargs(self) -> dict[str, Any]:
+        spec = get_thinking_spec(self._PROVIDER_KEY, self._model)
+        if spec.family is not ThinkingFamily.ANTHROPIC:
+            return {}
+        effort = normalize_effort(self._effort)
+        if effort is None or effort == "auto":
+            return {}
+        budget = ANTHROPIC_BUDGET.get(effort)
+        if budget is None:
+            return {}
+        return {"thinking": {"type": "enabled", "budget_tokens": budget}}
+
+    def _adjust_max_tokens(self, max_tokens: int) -> int:
+        spec = get_thinking_spec(self._PROVIDER_KEY, self._model)
+        if spec.family is not ThinkingFamily.ANTHROPIC:
+            return max_tokens
+        effort = normalize_effort(self._effort)
+        if effort is None or effort == "auto":
+            return max_tokens
+        budget = ANTHROPIC_BUDGET.get(effort)
+        if budget is None:
+            return max_tokens
+        min_max = budget + 4096
+        return max(max_tokens, min_max)
+
+    async def stream(
+        self,
+        messages: list[Message],
+        system: str,
+        tools: list[ToolDefinition] | None = None,
+        max_tokens: int = 8192,
+    ) -> AsyncGenerator[StreamEvent, None]:
+        kwargs = self._build_kwargs(messages, system, tools, max_tokens)
+
+        async with self._client.messages.stream(**kwargs) as stream:
+            # Track current content block state
+            current_tool_use_id: str | None = None
+            current_tool_name: str = ""
+            current_tool_input_json: str = ""
+
+            async for event in stream:
+                if event.type == "message_start":
+                    event_data: Any = event
+                    yield MessageStartEvent(message_id=event_data.message.id)
+
+                elif event.type == "content_block_start":
+                    event_data: Any = event
+                    block: Any = event_data.content_block
+                    if block.type == "text":
+                        pass  # text deltas will follow
+                    elif block.type == "tool_use":
+                        current_tool_use_id = block.id
+                        current_tool_name = block.name
+                        current_tool_input_json = ""
+                        yield ToolUseStartEvent(tool_use_id=block.id, name=block.name)
+                    elif block.type == "thinking":
+                        pass  # thinking deltas will follow
+
+                elif event.type == "content_block_delta":
+                    event_data: Any = event
+                    delta: Any = event_data.delta
+                    if delta.type == "text_delta":
+                        yield TextDeltaEvent(text=delta.text)
+                    elif delta.type == "input_json_delta":
+                        current_tool_input_json += delta.partial_json
+                        if current_tool_use_id is not None:
+                            yield ToolInputDeltaEvent(
+                                tool_use_id=current_tool_use_id,
+                                partial_json=delta.partial_json,
+                            )
+                    elif delta.type == "thinking_delta":
+                        yield ThinkingDeltaEvent(text=delta.thinking)
+
+                elif event.type == "content_block_stop":
+                    if current_tool_use_id is not None:
+                        events = list(
+                            parse_tool_input_events(
+                                current_tool_use_id,
+                                current_tool_name,
+                                current_tool_input_json,
+                            )
+                        )
+                        for ev in events:
+                            yield ev
+                        current_tool_use_id = None
+                        current_tool_name = ""
+                        current_tool_input_json = ""
+
+            # After the stream ends, emit the final message event
+            final = await stream.get_final_message()
+            usage = Usage(
+                input_tokens=final.usage.input_tokens,
+                output_tokens=final.usage.output_tokens,
+                cache_creation_input_tokens=getattr(final.usage, "cache_creation_input_tokens", 0) or 0,
+                cache_read_input_tokens=getattr(final.usage, "cache_read_input_tokens", 0) or 0,
+            )
+            yield MessageEndEvent(stop_reason=final.stop_reason or "end_turn", usage=usage)
+
+    async def complete(
+        self,
+        messages: list[Message],
+        system: str,
+        tools: list[ToolDefinition] | None = None,
+        max_tokens: int = 8192,
+    ) -> NonStreamingResponse:
+        kwargs = self._build_kwargs(messages, system, tools, max_tokens)
+        response = await self._client.messages.create(**kwargs)
+
+        text_parts: list[str] = []
+        tool_uses: list[dict[str, Any]] = []
+        for block in response.content:
+            if block.type == "text":
+                text_parts.append(block.text)
+            elif block.type == "tool_use":
+                tool_uses.append({"id": block.id, "name": block.name, "input": block.input})
+
+        usage = Usage(
+            input_tokens=response.usage.input_tokens,
+            output_tokens=response.usage.output_tokens,
+            cache_creation_input_tokens=getattr(response.usage, "cache_creation_input_tokens", 0) or 0,
+            cache_read_input_tokens=getattr(response.usage, "cache_read_input_tokens", 0) or 0,
+        )
+
+        return NonStreamingResponse(
+            message_id=response.id,
+            text="".join(text_parts),
+            tool_uses=tool_uses,
+            stop_reason=response.stop_reason,
+            usage=usage,
+        )
+
+    # -- conversion helpers ----------------------------------------------------
+
+    def _build_kwargs(
+        self,
+        messages: list[Message],
+        system: str,
+        tools: list[ToolDefinition] | None,
+        max_tokens: int,
+    ) -> dict[str, Any]:
+        thinking_kwargs = self._build_thinking_kwargs()
+        effective_max_tokens = self._adjust_max_tokens(max_tokens)
+
+        model_id, extra_betas = _MODEL_ALIAS.get(self._model, (self._model, ()))
+        kwargs: dict[str, Any] = {
+            "model": model_id,
+            "max_tokens": effective_max_tokens,
+            "system": system,
+            "messages": self._convert_messages(messages),
+        }
+        if tools:
+            kwargs["tools"] = self._convert_tools(tools)
+        kwargs.update(thinking_kwargs)
+        if extra_betas:
+            kwargs["extra_headers"] = {"anthropic-beta": ",".join(extra_betas)}
+        return kwargs
+
+    def _convert_messages(self, messages: list[Message]) -> list[dict[str, Any]]:
+        """Convert internal ``Message`` list to Anthropic API format."""
+        result: list[dict[str, Any]] = []
+        for msg in messages:
+            if isinstance(msg.content, str):
+                result.append({"role": msg.role, "content": msg.content})
+            elif isinstance(msg.content, list):
+                blocks: list[dict[str, Any]] = []
+                for block in msg.content:
+                    blocks.append(self._convert_content_block(block))
+                result.append({"role": msg.role, "content": blocks})
+            else:
+                result.append({"role": msg.role, "content": msg.content})
+        return result
+
+    @staticmethod
+    def _convert_content_block(block: ContentBlock) -> dict[str, Any]:
+        """Convert a single ``ContentBlock`` to Anthropic dict."""
+        if block.type == "text":
+            return {"type": "text", "text": block.text or ""}
+        elif block.type == "tool_use":
+            return {
+                "type": "tool_use",
+                "id": block.tool_use_id or "",
+                "name": block.name or "",
+                "input": block.input or {},
+            }
+        elif block.type == "tool_result":
+            d: dict[str, Any] = {
+                "type": "tool_result",
+                "tool_use_id": block.tool_use_id or "",
+                "content": block.content or "",
+            }
+            if block.is_error:
+                d["is_error"] = True
+            return d
+        elif block.type == "thinking":
+            return {"type": "thinking", "thinking": block.text or ""}
+        else:
+            return {"type": block.type}
+
+    @staticmethod
+    def _convert_tools(tools: list[ToolDefinition]) -> list[dict[str, Any]]:
+        """Convert ``ToolDefinition`` list to Anthropic API format."""
+        return [
+            {
+                "name": t.name,
+                "description": t.description,
+                "input_schema": t.input_schema,
+            }
+            for t in tools
+        ]

iac_code/providers/base.py

@@ -0,0 +1,128 @@
+"""Abstract Provider interface — unified across Anthropic, OpenAI, DashScope."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from dataclasses import dataclass
+from typing import Any
+
+from iac_code.types.stream_events import StreamEvent, Usage
+
+
+@dataclass
+class ToolDefinition:
+    """Tool schema passed to the model."""
+
+    name: str
+    description: str
+    input_schema: dict[str, Any]
+
+
+@dataclass
+class ContentBlock:
+    """A block of content within a message."""
+
+    type: str  # "text", "tool_use", "tool_result", "thinking"
+    text: str | None = None
+    tool_use_id: str | None = None
+    name: str | None = None
+    input: dict[str, Any] | None = None
+    content: str | None = None
+    is_error: bool = False
+
+
+@dataclass
+class Message:
+    """Unified message format for all providers."""
+
+    role: str  # "user", "assistant"
+    content: str | list[ContentBlock] = ""
+
+    @classmethod
+    def user(cls, text: str) -> Message:
+        return cls(role="user", content=text)
+
+    @classmethod
+    def assistant_text(cls, text: str) -> Message:
+        return cls(role="assistant", content=[ContentBlock(type="text", text=text)])
+
+    @classmethod
+    def assistant_tool_use(cls, *, tool_use_id: str, name: str, input: dict[str, Any]) -> Message:
+        return cls(
+            role="assistant",
+            content=[
+                ContentBlock(
+                    type="tool_use",
+                    tool_use_id=tool_use_id,
+                    name=name,
+                    input=input,
+                )
+            ],
+        )
+
+    @classmethod
+    def tool_result(cls, *, tool_use_id: str, content: str, is_error: bool = False) -> Message:
+        return cls(
+            role="user",
+            content=[
+                ContentBlock(
+                    type="tool_result",
+                    tool_use_id=tool_use_id,
+                    content=content,
+                    is_error=is_error,
+                )
+            ],
+        )
+
+
+@dataclass
+class NonStreamingResponse:
+    """Complete response from a non-streaming API call."""
+
+    message_id: str
+    text: str
+    tool_uses: list[dict[str, Any]]
+    stop_reason: str
+    usage: Usage
+    thinking: str = ""
+
+
+class Provider(ABC):
+    @abstractmethod
+    def stream(
+        self,
+        messages: list[Message],
+        system: str,
+        tools: list[ToolDefinition] | None = None,
+        max_tokens: int = 8192,
+    ) -> AsyncGenerator[StreamEvent, None]: ...
+
+    @abstractmethod
+    async def complete(
+        self,
+        messages: list[Message],
+        system: str,
+        tools: list[ToolDefinition] | None = None,
+        max_tokens: int = 8192,
+    ) -> NonStreamingResponse: ...
+
+    @abstractmethod
+    def get_model_name(self) -> str: ...
+
+    def _build_thinking_kwargs(self) -> dict[str, Any]:
+        """Wire-level thinking kwargs to merge into the request payload.
+
+        Default: emit nothing. Subclasses override to translate
+        ``self._effort`` + the model's ``ThinkingSpec`` into provider-specific
+        request fields (e.g. ``reasoning_effort``, ``extra_body.thinking``).
+        """
+        return {}
+
+    def _adjust_max_tokens(self, max_tokens: int) -> int:
+        """Provider-specific ``max_tokens`` adjustment.
+
+        Anthropic raises this to leave room for the configured thinking
+        budget; other providers leave it unchanged.
+        """
+        return max_tokens

iac_code/providers/dashscope_provider.py

@@ -0,0 +1,47 @@
+"""DashScope provider — Aliyun DashScope's OpenAI-compatible endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from iac_code.providers.openai_provider import OpenAIProvider
+from iac_code.providers.thinking import ThinkingFamily, get_thinking_spec
+
+DASHSCOPE_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+DASHSCOPE_TOKEN_PLAN_BASE_URL = "https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
+
+
+class DashScopeProvider(OpenAIProvider):
+    """Provider backed by Aliyun DashScope's OpenAI-compatible endpoint.
+
+    Both standard DashScope and DashScope Token Plan share the same wire
+    protocol (extra_body.enable_thinking=True); only the base URL and
+    thinking-registry key differ. Both are injected via __init__.
+    """
+
+    _PROVIDER_KEY = "dashscope"
+    supports_stream_options = True
+
+    def __init__(
+        self,
+        model: str,
+        api_key: str | None = None,
+        effort: str | None = None,
+        base_url: str = DASHSCOPE_BASE_URL,
+        provider_key: str = "dashscope",
+    ) -> None:
+        super().__init__(
+            model=model,
+            api_key=api_key,
+            base_url=base_url,
+            effort=effort,
+        )
+        # Instance attribute shadows the class attribute so per-variant
+        # thinking-registry lookups resolve to the right MODEL_THINKING bucket.
+        self._PROVIDER_KEY = provider_key
+
+    def _build_thinking_kwargs(self) -> dict[str, Any]:
+        spec = get_thinking_spec(self._PROVIDER_KEY, self._model)
+        if spec.family is not ThinkingFamily.DASHSCOPE:
+            return {}
+        return {"extra_body": {"enable_thinking": True}}

iac_code/providers/deepseek_provider.py

@@ -0,0 +1,36 @@
+"""DeepSeek provider — uses OpenAI-compatible API with thinking mode support."""
+
+from __future__ import annotations
+
+from iac_code.providers.openai_provider import OpenAIProvider
+
+DEEPSEEK_BASE_URL = "https://api.deepseek.com/v1"
+
+
+class DeepSeekProvider(OpenAIProvider):
+    """Provider backed by DeepSeek's OpenAI-compatible endpoint.
+
+    Wire format is identical to ``OpenAIProvider`` (``reasoning_effort`` +
+    ``extra_body.thinking.type=enabled``); the registry's ``allowed_efforts``
+    constrains the effort vocabulary to ``high`` / ``max`` for DeepSeek V4.
+
+    Reasoning content is captured via ``reasoning_content`` in the stream
+    and echoed back as ``reasoning_content`` on subsequent assistant
+    messages (required by DeepSeek when tool calls are involved).
+    """
+
+    _PROVIDER_KEY = "deepseek"
+    supports_stream_options = True
+
+    def __init__(
+        self,
+        model: str,
+        api_key: str | None = None,
+        effort: str | None = None,
+    ) -> None:
+        super().__init__(
+            model=model,
+            api_key=api_key,
+            base_url=DEEPSEEK_BASE_URL,
+            effort=effort,
+        )