deepcraft-agent 0.1.0__py3-none-any.whl

deepcraft/__init__.py

@@ -0,0 +1,3 @@
+"""DeepCraft — DeepSeek-powered AI coding agent."""
+
+__version__ = "0.1.0"

deepcraft/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as: python -m deepcraft"""
+
+from deepcraft.cli import main
+
+if __name__ == "__main__":
+    main()

deepcraft/agent/__init__.py

@@ -0,0 +1,23 @@
+from deepcraft.agent.context import ContextManager
+from deepcraft.agent.corrector import SelfCorrector
+from deepcraft.agent.llm import DeepSeekLLM
+from deepcraft.agent.loop import Agent
+from deepcraft.agent.mcp.client import MCPManager
+from deepcraft.agent.modes import AgentMode, ModeSelector
+from deepcraft.agent.planner import Planner
+from deepcraft.agent.subagent import Delegator, SubAgent
+from deepcraft.agent.tools.base import ToolRegistry
+
+__all__ = [
+    "Agent",
+    "AgentMode",
+    "ContextManager",
+    "DeepSeekLLM",
+    "Delegator",
+    "MCPManager",
+    "ModeSelector",
+    "Planner",
+    "SelfCorrector",
+    "SubAgent",
+    "ToolRegistry",
+]

deepcraft/agent/context.py

@@ -0,0 +1,114 @@
+"""Context and memory management — conversation history, compression, system prompt."""
+
+from __future__ import annotations
+
+from deepcraft.agent.types import ChatMessage, Role
+
+# Approximate tokens per character (rough estimate for mixed Chinese/English)
+TOKENS_PER_CHAR = 0.4
+MAX_CONTEXT_TOKENS = 100_000  # Leave headroom below 128K
+COMPRESS_THRESHOLD = 0.8  # Compress at 80% capacity
+
+
+SYSTEM_PROMPT = """You are DeepCraft, an AI coding agent powered by DeepSeek.
+
+Your capabilities:
+- Read, write, and search files in the project workspace
+- Execute shell commands via terminal
+- Manage git repositories
+- Analyze code, find bugs, and suggest fixes
+
+Guidelines:
+- Be concise and direct. No fluff.
+- When you need to see file contents, use read_file.
+- When you need to create/modify files, use write_file.
+- When you need to run commands, use terminal.
+- Think step by step: understand the problem first, then act.
+- If a tool fails, analyze the error and try a different approach."""
+
+
+class ContextManager:
+    """Manages conversation context: messages, token counting, compression."""
+
+    def __init__(self, system_prompt: str | None = None) -> None:
+        self._messages: list[ChatMessage] = []
+        self._system_prompt = system_prompt or SYSTEM_PROMPT
+        # Add system message
+        self._messages.append(ChatMessage(role="system", content=self._system_prompt))
+
+    @property
+    def token_count(self) -> int:
+        """Estimate token count of all messages."""
+        total = 0
+        for msg in self._messages:
+            if msg.content:
+                total += int(len(msg.content) * TOKENS_PER_CHAR)
+            if msg.tool_calls:
+                total += int(len(str(msg.tool_calls)) * TOKENS_PER_CHAR)
+        return total
+
+    def add_message(
+        self,
+        role: Role | str,
+        content: str | None = None,
+        tool_call_id: str | None = None,
+        name: str | None = None,
+    ) -> None:
+        """Add a message to the conversation."""
+        msg = ChatMessage(
+            role=role.value if isinstance(role, Role) else role,
+            content=content,
+            tool_call_id=tool_call_id,
+            name=name,
+        )
+        self._messages.append(msg)
+
+        # Check if compression needed
+        if self.token_count > int(MAX_CONTEXT_TOKENS * COMPRESS_THRESHOLD):
+            self._compress()
+
+    def get_messages(self) -> list[ChatMessage]:
+        """Get all messages for LLM context."""
+        return list(self._messages)
+
+    def _compress(self) -> None:
+        """Compress older messages to save tokens.
+
+        Strategy: keep the system prompt + last 20 messages.
+        Summarize everything else into a single message.
+        """
+        if len(self._messages) <= 22:
+            return  # Not enough to compress
+
+        # System prompt is at index 0, keep it
+        # Keep last 20 messages (index -20 onward)
+        old_messages = self._messages[1:-20]
+
+        # Build summary
+        summary_parts = []
+        for msg in old_messages:
+            role = msg.role
+            content = msg.content or ""
+            if role == "user":
+                summary_parts.append(f"User asked: {content[:200]}")
+            elif role == "assistant" and content:
+                summary_parts.append(f"Assistant responded: {content[:200]}")
+            elif role == "tool":
+                summary_parts.append(f"Tool result ({msg.tool_call_id}): {content[:100]}")
+
+        summary = "[Conversation history compressed]\n" + "\n".join(summary_parts[-20:])
+
+        # Replace old messages with summary
+        self._messages = [
+            self._messages[0],  # system prompt
+            ChatMessage(role="user", content=summary),
+        ] + self._messages[-20:]
+
+    def reset(self) -> None:
+        """Reset conversation, keeping only system prompt."""
+        self._messages = [
+            ChatMessage(role="system", content=self._system_prompt),
+        ]
+
+    def __len__(self) -> int:
+        return len(self._messages)

deepcraft/agent/corrector.py

@@ -0,0 +1,120 @@
+"""Self-correction — analyze errors and retry with adjusted approach."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from deepcraft.agent.llm import DeepSeekLLM
+from deepcraft.agent.types import ChatMessage
+
+CORRECTION_PROMPT = """你是一个调试专家。一个工具执行失败了，请分析错误原因并给出修正后的参数。
+
+原始调用：
+  工具: {tool_name}
+  参数: {tool_args}
+  错误: {error}
+
+请输出 JSON：
+```json
+{{
+  "analysis": "错误原因分析",
+  "retry": true或false,
+  "corrected_args": {{"参数名": "修正后的值"}} 或 {{}},
+  "fix_description": "修正说明"
+}}
+```
+如果错误无法通过修改参数解决（如网络问题、权限问题），retry 设为 false。"""
+
+
+@dataclass
+class CorrectionResult:
+    """Result of error analysis and correction."""
+
+    analysis: str
+    retry: bool
+    corrected_args: dict[str, Any] | None = None
+    fix_description: str = ""
+
+
+class SelfCorrector:
+    """Analyze tool failures and suggest corrections."""
+
+    MAX_RETRIES = 2  # Max retries per step
+
+    def __init__(self, llm: DeepSeekLLM | None = None) -> None:
+        self.llm = llm or DeepSeekLLM()
+        self._retry_counts: dict[str, int] = {}
+
+    async def analyze_error(
+        self,
+        tool_name: str,
+        tool_args: dict[str, Any],
+        error: str,
+    ) -> CorrectionResult:
+        """Analyze a tool failure and suggest a correction.
+
+        Args:
+            tool_name: The tool that failed.
+            tool_args: The arguments that were used.
+            error: The error message.
+
+        Returns:
+            CorrectionResult with analysis and optionally corrected args.
+        """
+        # Check retry limit
+        key = f"{tool_name}:{str(sorted(tool_args.items()))}"
+        count = self._retry_counts.get(key, 0)
+        if count >= self.MAX_RETRIES:
+            return CorrectionResult(
+                analysis=f"已重试 {count} 次，放弃",
+                retry=False,
+            )
+        self._retry_counts[key] = count + 1
+
+        # Ask LLM to analyze
+        prompt = CORRECTION_PROMPT.format(
+            tool_name=tool_name,
+            tool_args=str(tool_args),
+            error=error[:500],
+        )
+
+        messages = [
+            ChatMessage(role="system", content=prompt),
+            ChatMessage(role="user", content="请分析并建议修正"),
+        ]
+
+        response = ""
+        async for chunk in self.llm.chat(messages):
+            if chunk.delta and chunk.delta.content:
+                response += chunk.delta.content
+
+        # Parse response
+        import json
+        import re
+
+        match = re.search(r"```(?:json)?\s*\n(.*?)\n```", response, re.DOTALL)
+        if match:
+            try:
+                data = json.loads(match.group(1))
+                return CorrectionResult(
+                    analysis=data.get("analysis", ""),
+                    retry=data.get("retry", False),
+                    corrected_args=data.get("corrected_args"),
+                    fix_description=data.get("fix_description", ""),
+                )
+            except json.JSONDecodeError:
+                pass
+
+        # Fallback: don't retry
+        return CorrectionResult(
+            analysis=response[:200] if response else "无法分析错误",
+            retry=False,
+        )
+
+    def reset_retries(self) -> None:
+        """Reset retry counters for a new task."""
+        self._retry_counts.clear()
+
+    async def close(self) -> None:
+        await self.llm.close()

deepcraft/agent/llm.py

@@ -0,0 +1,65 @@
+"""DeepSeek API client with streaming and tool-call support."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+
+import httpx
+
+from deepcraft.agent.types import (
+    ChatMessage,
+    LLMResponse,
+    ToolDefinition,
+)
+from deepcraft.config import (
+    DEEPSEEK_API_KEY,
+    DEEPSEEK_BASE_URL,
+    DEEPSEEK_MAX_TOKENS,
+    DEEPSEEK_MODEL,
+)
+
+
+class DeepSeekLLM:
+    """Async DeepSeek chat API client."""
+
+    def __init__(self, model: str | None = None) -> None:
+        self.model = model or DEEPSEEK_MODEL
+        self._client = httpx.AsyncClient(
+            base_url=DEEPSEEK_BASE_URL,
+            headers={
+                "Authorization": f"Bearer {DEEPSEEK_API_KEY}",
+                "Content-Type": "application/json",
+            },
+            timeout=httpx.Timeout(120.0),
+        )
+
+    async def chat(
+        self,
+        messages: list[ChatMessage],
+        tools: list[ToolDefinition] | None = None,
+        stream: bool = True,
+    ) -> AsyncIterator[LLMResponse]:
+        """Send a chat completion request, yielding responses as they stream."""
+        body: dict[str, object] = {
+            "model": self.model,
+            "messages": [m.model_dump(exclude_none=True) for m in messages],
+            "max_tokens": DEEPSEEK_MAX_TOKENS,
+            "stream": stream,
+        }
+        if tools:
+            body["tools"] = [t.model_dump(exclude_none=True) for t in tools]
+
+        async with self._client.stream("POST", "/v1/chat/completions", json=body) as resp:
+            resp.raise_for_status()
+            async for line in resp.aiter_lines():
+                if not line.startswith("data: "):
+                    continue
+                data = line[6:].strip()
+                if data == "[DONE]":
+                    break
+                result = LLMResponse.from_chunk(data)
+                if result is not None:
+                    yield result
+
+    async def close(self) -> None:
+        await self._client.aclose()

deepcraft/agent/loop.py

@@ -0,0 +1,299 @@
+"""Agent main loop — ReAct pattern with safety guards."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from rich.console import Console
+
+from deepcraft.agent.context import ContextManager
+from deepcraft.agent.corrector import SelfCorrector
+from deepcraft.agent.llm import DeepSeekLLM
+from deepcraft.agent.modes import AgentMode, ModeSelector
+from deepcraft.agent.planner import Planner
+from deepcraft.agent.subagent import Delegator, SubTask
+from deepcraft.agent.tools.base import ToolRegistry
+from deepcraft.agent.types import (
+    ChatMessage,
+    Role,
+)
+from deepcraft.agent.types import (
+    ToolResult as TypedToolResult,
+)
+from deepcraft.config import MAX_TURNS
+
+console = Console()
+
+
+class Agent:
+    """ReAct agent with DeepSeek backend."""
+
+    def __init__(
+        self,
+        llm: DeepSeekLLM | None = None,
+        tools: ToolRegistry | None = None,
+        context: ContextManager | None = None,
+    ) -> None:
+        self.llm = llm or DeepSeekLLM()
+        self.tools = tools or ToolRegistry()
+        self.ctx = context or ContextManager()
+        self._turn_count = 0
+        self._recent_actions: list[str] = []
+
+    async def run(self, user_input: str) -> str:
+        """Run the agent loop for a user input. Returns final response."""
+        self._turn_count = 0
+        self._recent_actions = []
+        self.ctx.add_message(Role.USER, user_input)
+
+        while self._turn_count < MAX_TURNS:
+            self._turn_count += 1
+
+            # --- Get LLM response (streaming) ---
+            tool_calls_buffer: dict[int, dict[str, Any]] = {}
+            content_parts: list[str] = []
+
+            tool_defs = self.tools.list_definitions()
+            messages = self.ctx.get_messages()
+
+            async for chunk in self.llm.chat(messages, tools=tool_defs or None):
+                if chunk.delta is None:
+                    continue
+
+                # Collect streaming content
+                if chunk.delta.content:
+                    content_parts.append(chunk.delta.content)
+                    console.print(chunk.delta.content, end="", highlight=False)
+
+                # Collect tool calls — use index from stream chunk, not buffer length
+                if chunk.delta.tool_calls:
+                    for tc in chunk.delta.tool_calls:
+                        # DeepSeek streaming sends "index" in every tool_call chunk
+                        tc_index = tc.get("index")
+                        if tc_index is None:
+                            tc_index = len(tool_calls_buffer)
+                        if tc.get("id"):
+                            tool_calls_buffer[tc_index] = dict(tc)
+                        elif tc_index in tool_calls_buffer:
+                            # Append streaming arguments fragment
+                            tc_args = tc.get("function", {}).get("arguments", "")
+                            tool_calls_buffer[tc_index]["function"]["arguments"] += tc_args
+
+                if chunk.finish_reason:
+                    break
+
+            console.print()  # newline after streaming
+
+            response_text = "".join(content_parts)
+
+            # --- No tool calls: return final response ---
+            if not tool_calls_buffer:
+                self.ctx.add_message(Role.ASSISTANT, response_text)
+                return response_text
+
+            # --- Execute tool calls ---
+            tool_results: list[TypedToolResult] = []
+
+            for tc in tool_calls_buffer.values():
+                tool_name = tc["function"]["name"]
+                tool_id = tc["id"]
+
+                # Parse arguments
+                args_str = tc["function"]["arguments"]
+                try:
+                    arguments = json.loads(args_str) if args_str else {}
+                except json.JSONDecodeError:
+                    arguments = {}
+
+                # Safety: loop detection
+                action_key = f"{tool_name}:{json.dumps(arguments, sort_keys=True)}"
+                self._recent_actions.append(action_key)
+                if self._recent_actions[-3:].count(action_key) == 3:
+                    # 3 consecutive identical calls → force stop
+                    summary = "⚠️ Detected repetitive tool calls. Stopping to avoid loop."
+                    self.ctx.add_message(Role.ASSISTANT, summary)
+                    return summary
+                # Keep only last 10
+                self._recent_actions = self._recent_actions[-10:]
+
+                # Execute
+                args_str = json.dumps(arguments, ensure_ascii=False)
+                console.print(f"  🔧 {tool_name}({args_str})", style="dim")
+                result = await self.tools.execute(tool_name, arguments)
+                tool_results.append(TypedToolResult(
+                    tool_call_id=tool_id,
+                    content=result.content,
+                    is_error=result.is_error,
+                ))
+
+            # --- Add assistant message with tool calls ---
+            assistant_msg = ChatMessage(
+                role="assistant",
+                content=response_text or None,
+                tool_calls=[
+                    {
+                        "id": tc["id"],
+                        "type": "function",
+                        "function": {
+                            "name": tc["function"]["name"],
+                            "arguments": tc["function"]["arguments"],
+                        },
+                    }
+                    for tc in tool_calls_buffer.values()
+                ],
+            )
+            self.ctx._messages.append(assistant_msg)
+
+            # --- Add tool results ---
+            for tr in tool_results:
+                self.ctx.add_message(
+                    Role.TOOL,
+                    tr.content,
+                    tool_call_id=tr.tool_call_id,
+                )
+
+            # Continue loop — LLM will process tool results
+
+        # Max turns reached
+        summary = f"\n⚠️ Reached max turns ({MAX_TURNS}). Summarizing based on current state."
+        return summary
+
+    async def close(self) -> None:
+        await self.llm.close()
+
+    # ------------------------------------------------------------------
+    # Advanced modes
+    # ------------------------------------------------------------------
+
+    async def run_with_mode(
+        self, user_input: str, mode: AgentMode = AgentMode.AUTO
+    ) -> str:
+        """Run the agent loop, auto-selecting or using a specific mode.
+
+        Args:
+            user_input: The user's message.
+            mode: AgentMode to use (AUTO = auto-detect).
+
+        Returns:
+            Final response text.
+        """
+        selected = ModeSelector.select(user_input, prefer=mode)
+
+        console.print(f"  🧠 模式: {selected.value}", style="cyan")
+
+        if selected == AgentMode.PLAN_EXECUTE:
+            return await self._run_plan_execute(user_input)
+        elif selected == AgentMode.SUBAGENT:
+            return await self._run_subagent(user_input)
+        else:
+            return await self.run(user_input)
+
+    async def _run_plan_execute(self, user_input: str) -> str:
+        """Plan-and-Execute: generate a plan, then execute step by step."""
+        self._turn_count = 0
+        self.ctx.add_message(Role.USER, user_input)
+
+        # Step 1: Generate plan
+        planner = Planner(self.llm)
+        plan = await planner.generate_plan(user_input, self.tools)
+        console.print(f"  📋 计划: {plan.goal}")
+        for i, s in enumerate(plan.steps, 1):
+            console.print(f"     {i}. {s.description}", style="dim")
+
+        # Step 2: Execute each step
+        corrector = SelfCorrector(llm=self.llm)
+        try:
+            while not plan.completed and self._turn_count < MAX_TURNS:
+                self._turn_count += 1
+                next_s = plan.next_step()
+                if next_s is None:
+                    break
+
+                from deepcraft.agent.planner import StepStatus
+                next_s.status = StepStatus.RUNNING
+
+                # Pure reasoning step (no tool)
+                if not next_s.tool_name:
+                    next_s.status = StepStatus.DONE
+                    next_s.result = next_s.description
+                    continue
+
+                # Execute tool
+                try:
+                    result = await self.tools.execute(next_s.tool_name, **next_s.tool_args)
+                    if result.is_error:
+                        # Try self-correction
+                        correction = await corrector.analyze_error(
+                            next_s.tool_name, next_s.tool_args, result.content
+                        )
+                        if correction.retry and correction.corrected_args:
+                            desc = correction.fix_description
+                            console.print(f"     🔄 纠错: {desc}", style="yellow")
+                            result = await self.tools.execute(
+                                next_s.tool_name, **correction.corrected_args
+                            )
+
+                        if result.is_error:
+                            next_s.status = StepStatus.FAILED
+                            next_s.error = result.content
+                        else:
+                            next_s.status = StepStatus.DONE
+                            next_s.result = result.content
+                    else:
+                        next_s.status = StepStatus.DONE
+                        next_s.result = result.content
+                except Exception as e:
+                    next_s.status = StepStatus.FAILED
+                    next_s.error = str(e)
+
+            # Step 3: Synthesize results
+            plan_context = plan.format_for_context()
+            self.ctx.add_message(Role.USER, f"执行计划完成。结果：\n{plan_context}\n请总结。")
+
+            # Final summary
+            return await self.run("总结以上执行结果")
+
+        finally:
+            await corrector.close()
+            await planner.close()
+
+    async def _run_subagent(self, user_input: str) -> str:
+        """Sub-agent mode: decompose and delegate to parallel sub-agents."""
+        self._turn_count = 0
+        self.ctx.add_message(Role.USER, user_input)
+
+        # Step 1: Use planner to generate subtasks
+        planner = Planner(self.llm)
+        plan = await planner.generate_plan(user_input, self.tools)
+
+        # Step 2: Convert plan steps to subtasks
+        subtasks = [
+            SubTask(
+                description=step.description,
+                context=f"目标: {plan.goal}",
+            )
+            for step in plan.steps
+        ]
+
+        console.print(f"  🚀 委派 {len(subtasks)} 个子任务...", style="cyan")
+
+        # Step 3: Execute in parallel
+        delegator = Delegator(llm=self.llm, tools=self.tools)
+        try:
+            results = await delegator.delegate(subtasks)
+
+            # Step 4: Synthesize
+            summary_parts = ["## 子代理执行结果\n"]
+            for r in results:
+                status = "✅" if r.success else "❌"
+                summary_parts.append(f"{status} **{r.task}**\n{r.output[:500]}\n")
+
+            summary = "\n".join(summary_parts)
+            self.ctx.add_message(Role.USER, f"子代理执行完成：\n{summary}\n请总结。")
+
+            return await self.run("总结以上子代理的执行结果")
+
+        finally:
+            await delegator.close()
+            await planner.close()

deepcraft/agent/mcp/__init__.py

@@ -0,0 +1,5 @@
+"""MCP（Model Context Protocol）客户端封装。"""
+
+from deepcraft.agent.mcp.client import MCPClient, MCPManager, MCPProtocolError, MCPToolWrapper
+
+__all__ = ["MCPClient", "MCPManager", "MCPProtocolError", "MCPToolWrapper"]