god-code 0.4.0__tar.gz → 0.4.3__tar.gz

{god_code-0.4.0 → god_code-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: god-code
-Version: 0.4.0
+Version: 0.4.3
 Summary: AI coding agent specialized for Godot game development
 Project-URL: Homepage, https://github.com/chuisiufai/god-code
 Project-URL: Repository, https://github.com/chuisiufai/god-code
@@ -13,6 +13,7 @@ Requires-Dist: eval-type-backport>=0.2.0; python_version < '3.10'
 Requires-Dist: httpx>=0.27
 Requires-Dist: packaging>=21.0
 Requires-Dist: pillow>=10.3
+Requires-Dist: prompt-toolkit>=3.0
 Requires-Dist: pydantic>=2.7
 Requires-Dist: rich>=13.0
 Provides-Extra: dev

{god_code-0.4.0 → god_code-0.4.3}/godot_agent/cli.py

@@ -63,7 +63,9 @@ def build_registry() -> ToolRegistry:
 
 def build_engine(config: AgentConfig, project_root: Path) -> ConversationEngine:
     from godot_agent.tools.file_ops import set_project_root
+    from godot_agent.tools.shell import set_safety_level
     set_project_root(project_root)
+    set_safety_level(config.safety)
 
     llm_config = LLMConfig(
         api_key=config.api_key,
@@ -202,7 +204,7 @@ def _run_setup_wizard() -> None:
     click.echo()
 
 
-_VERSION = "0.4.0"
+_VERSION = "0.4.3"
 
 
 def _check_update() -> None:
@@ -343,6 +345,15 @@ def chat(project: str = ".", config: str | None = None):
     engine.on_tool_start = lambda name, args: display.tool_start(name, engine._summarize_args(name, args))
     engine.on_tool_end = lambda name, ok, err: display.tool_result(name, ok, err)
     engine.on_diff = lambda old, new, fn: display.show_diff(old, new, fn)
+    engine.auto_commit = cfg.auto_commit
+    engine.use_streaming = cfg.streaming
+
+    # Streaming callback
+    if cfg.streaming:
+        engine.on_stream_chunk = lambda chunk: display.agent_streaming_chunk(chunk)
+
+    # Auto-commit callback
+    engine.on_commit_suggest = lambda: display.info("Changes made. Run 'git add -A && git commit' to save.")
 
     # Auto-scan project on entry
     if has_project:
@@ -350,8 +361,15 @@ def chat(project: str = ".", config: str | None = None):
         if scan_result:
             display.info(f"Project auto-scanned: {scan_result}")
 
+    # Setup prompt_toolkit for history + autocomplete
+    from godot_agent.tui.input_handler import CommandCompleter, create_session as create_input_session
+    history_file = str(Path.home() / ".config" / "god-code" / "history")
+    Path(history_file).parent.mkdir(parents=True, exist_ok=True)
+    input_session = create_input_session(history_file)
+    completer = CommandCompleter(project_root)
+
     def _rebuild_engine(new_root: Path) -> ConversationEngine:
-        nonlocal project_root, has_project, proj_name
+        nonlocal project_root, has_project, proj_name, completer
         project_root = new_root.resolve()
         has_project = (project_root / "project.godot").exists()
         if has_project:
@@ -363,6 +381,12 @@ def chat(project: str = ".", config: str | None = None):
         eng.on_tool_start = lambda name, args: display.tool_start(name, eng._summarize_args(name, args))
         eng.on_tool_end = lambda name, ok, err: display.tool_result(name, ok, err)
         eng.on_diff = lambda old, new, fn: display.show_diff(old, new, fn)
+        eng.auto_commit = cfg.auto_commit
+        eng.use_streaming = cfg.streaming
+        if cfg.streaming:
+            eng.on_stream_chunk = lambda chunk: display.agent_streaming_chunk(chunk)
+        eng.on_commit_suggest = lambda: display.info("Changes made. Run 'git add -A && git commit' to save.")
+        completer = CommandCompleter(project_root)
         if has_project:
             eng.scan_project()
         return eng
@@ -376,8 +400,9 @@ def chat(project: str = ".", config: str | None = None):
             while True:
                 try:
                     if in_multiline:
-                        line = display.console.input("[dim]...[/] ")
-                        if line.strip() == '"""':
+                        from godot_agent.tui.input_handler import get_multiline_continuation
+                        line = get_multiline_continuation(input_session)
+                        if line is None or line.strip() == '"""':
                             in_multiline = False
                             user_input = "\n".join(multiline_buffer)
                             multiline_buffer = []
@@ -385,7 +410,10 @@ def chat(project: str = ".", config: str | None = None):
                             multiline_buffer.append(line)
                             continue
                     else:
-                        user_input = display.console.input("[green]you>[/] ")
+                        from godot_agent.tui.input_handler import get_input
+                        user_input = get_input(input_session, completer)
+                        if user_input is None:
+                            break
                         if user_input.strip().startswith('"""'):
                             in_multiline = True
                             rest = user_input.strip()[3:]
@@ -406,17 +434,12 @@ def chat(project: str = ".", config: str | None = None):
                     continue
 
                 if cmd == "/load":
-                    from godot_agent.runtime.session import load_session as _load_sess
-                    import os
-                    sess_dir = cfg.session_dir
-                    if os.path.exists(sess_dir):
-                        files = sorted(Path(sess_dir).glob("*.json"), key=lambda f: f.stat().st_mtime, reverse=True)
-                        if files:
-                            display.info(f"Loading: {files[0].name}")
-                            # Note: restore is informational — messages are raw dicts
-                            display.success("Session history loaded for context")
-                        else:
-                            display.error("No saved sessions found")
+                    from godot_agent.runtime.session import load_latest_session
+                    result = load_latest_session(cfg.session_dir)
+                    if result:
+                        old_id, old_messages = result
+                        engine.messages.extend(old_messages[1:])  # Skip system prompt
+                        display.success(f"Restored session {old_id} ({len(old_messages)} messages)")
                     else:
                         display.error("No saved sessions found")
                     continue
@@ -518,14 +541,18 @@ def chat(project: str = ".", config: str | None = None):
 
                 # Regular message → send to LLM
                 try:
-                    with display.thinking():
+                    if cfg.streaming and engine.on_stream_chunk:
+                        display.agent_streaming_start()
                         response = await engine.submit(user_input)
+                        display.agent_streaming_end()
+                    else:
+                        with display.thinking():
+                            response = await engine.submit(user_input)
+                        display.agent_response(response)
                 except KeyboardInterrupt:
                     display.info("Cancelled")
                     continue
 
-                display.agent_response(response)
-
                 # Token usage
                 turn = engine.last_turn
                 sess = engine.session_usage

god_code-0.4.3/godot_agent/llm/streaming.py

@@ -0,0 +1,93 @@
+"""Streaming chat completions with tool call assembly."""
+
+from __future__ import annotations
+
+import json
+from typing import AsyncIterator, Callable
+
+from godot_agent.llm.client import ChatResponse, LLMClient, Message, ToolCall, TokenUsage
+
+
+async def stream_chat_with_callback(
+    client: LLMClient,
+    messages: list[Message],
+    tools: list[dict] | None = None,
+    on_chunk: Callable[[str], None] | None = None,
+) -> ChatResponse:
+    """Stream a chat completion, calling on_chunk for each text delta.
+
+    Returns the complete ChatResponse with assembled tool calls and usage.
+    """
+    body = client._build_request_body(messages, tools)
+    body["stream"] = True
+    body["stream_options"] = {"include_usage": True}
+
+    content_parts: list[str] = []
+    tool_calls_acc: dict[int, dict] = {}  # index -> {id, name, arguments}
+    usage = TokenUsage()
+
+    async with client._http.stream(
+        "POST",
+        f"{client.config.base_url}/chat/completions",
+        headers=client._build_headers(),
+        json=body,
+    ) as resp:
+        resp.raise_for_status()
+        async for line in resp.aiter_lines():
+            if not line.startswith("data: "):
+                continue
+            data_str = line[6:]
+            if data_str.strip() == "[DONE]":
+                break
+
+            chunk = json.loads(data_str)
+
+            # Usage info (comes in final chunk)
+            if "usage" in chunk and chunk["usage"]:
+                u = chunk["usage"]
+                usage = TokenUsage(
+                    prompt_tokens=u.get("prompt_tokens", 0),
+                    completion_tokens=u.get("completion_tokens", 0),
+                    total_tokens=u.get("total_tokens", 0),
+                )
+
+            if not chunk.get("choices"):
+                continue
+            delta = chunk["choices"][0].get("delta", {})
+
+            # Text content
+            if "content" in delta and delta["content"]:
+                text = delta["content"]
+                content_parts.append(text)
+                if on_chunk:
+                    on_chunk(text)
+
+            # Tool calls (streamed incrementally)
+            if "tool_calls" in delta:
+                for tc_delta in delta["tool_calls"]:
+                    idx = tc_delta["index"]
+                    if idx not in tool_calls_acc:
+                        tool_calls_acc[idx] = {
+                            "id": tc_delta.get("id", ""),
+                            "name": tc_delta.get("function", {}).get("name", ""),
+                            "arguments": "",
+                        }
+                    if "id" in tc_delta and tc_delta["id"]:
+                        tool_calls_acc[idx]["id"] = tc_delta["id"]
+                    func = tc_delta.get("function", {})
+                    if "name" in func and func["name"]:
+                        tool_calls_acc[idx]["name"] = func["name"]
+                    if "arguments" in func:
+                        tool_calls_acc[idx]["arguments"] += func["arguments"]
+
+    # Assemble final message
+    content = "".join(content_parts) if content_parts else None
+    tool_calls = None
+    if tool_calls_acc:
+        tool_calls = [
+            ToolCall(id=tc["id"], name=tc["name"], arguments=tc["arguments"])
+            for tc in sorted(tool_calls_acc.values(), key=lambda x: x["id"])
+        ]
+
+    msg = Message.assistant(content=content, tool_calls=tool_calls)
+    return ChatResponse(message=msg, usage=usage)

{god_code-0.4.0 → god_code-0.4.3}/godot_agent/runtime/config.py

@@ -16,7 +16,7 @@ class AgentConfig(BaseModel):
     model: str = "gpt-5.4"
     oauth_token: str | None = None
     max_turns: int = 20
-    max_tokens: int = 4096
+    max_tokens: int = 16384  # gpt-5.4 supports up to 128K output
     temperature: float = 0.0
 
     # Godot

god_code-0.4.3/godot_agent/runtime/context_manager.py

@@ -0,0 +1,231 @@
+"""Smart context window management for long Godot development sessions.
+
+Implements tiered compression that preserves critical context while staying
+within the model's token limit:
+
+1. System prompt — NEVER compressed
+2. Working memory — extracted key facts from old conversations
+3. Recent turns — kept intact (last N messages)
+4. Old turns — compressed into summaries
+
+The key insight: in a coding agent, the most important context is
+"what files did I read/modify and what decisions did I make", not
+the full conversation history.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+from godot_agent.llm.client import Message
+
+# Token estimation: ~3.5 chars per token (conservative for mixed en/zh content)
+_CHARS_PER_TOKEN = 3.5
+
+
+def estimate_tokens(text: str) -> int:
+    """Rough token estimate for mixed English/CJK text."""
+    if not text:
+        return 0
+    return max(1, int(len(text) / _CHARS_PER_TOKEN))
+
+
+def estimate_message_tokens(msg: Message) -> int:
+    """Estimate tokens for a single message including role overhead."""
+    content = msg.content if isinstance(msg.content, str) else str(msg.content or "")
+    base = estimate_tokens(content) + 4  # role + formatting overhead
+    if msg.tool_calls:
+        for tc in msg.tool_calls:
+            base += estimate_tokens(tc.name) + estimate_tokens(tc.arguments) + 10
+    return base
+
+
+@dataclass
+class ContextBudget:
+    max_tokens: int = 1050000  # gpt-5.4: 1.05M context
+    system_prompt_tokens: int = 0
+    message_tokens: int = 0
+    reserved_for_response: int = 4096
+
+    @property
+    def available(self) -> int:
+        return self.max_tokens - self.system_prompt_tokens - self.message_tokens - self.reserved_for_response
+
+    @property
+    def usage_ratio(self) -> float:
+        used = self.system_prompt_tokens + self.message_tokens
+        return used / self.max_tokens if self.max_tokens > 0 else 0.0
+
+    @property
+    def should_compact(self) -> bool:
+        return self.usage_ratio > 0.75
+
+
+@dataclass
+class WorkingMemory:
+    """Extracted key facts from compressed conversation turns."""
+    files_read: list[str] = field(default_factory=list)
+    files_modified: list[str] = field(default_factory=list)
+    decisions: list[str] = field(default_factory=list)
+    errors_encountered: list[str] = field(default_factory=list)
+
+    def to_message(self) -> str:
+        parts = ["[CONTEXT] Working memory from previous conversation:"]
+        if self.files_modified:
+            parts.append(f"Files modified: {', '.join(set(self.files_modified[-20:]))}")
+        if self.files_read:
+            parts.append(f"Files read: {', '.join(set(self.files_read[-20:]))}")
+        if self.decisions:
+            parts.append("Key decisions:\n" + "\n".join(f"  - {d}" for d in self.decisions[-10:]))
+        if self.errors_encountered:
+            parts.append("Errors fixed:\n" + "\n".join(f"  - {e}" for e in self.errors_encountered[-5:]))
+        return "\n".join(parts)
+
+
+def _extract_working_memory(messages: list[Message]) -> WorkingMemory:
+    """Extract key facts from messages for working memory."""
+    memory = WorkingMemory()
+
+    for msg in messages:
+        content = msg.content if isinstance(msg.content, str) else str(msg.content or "")
+
+        # Extract file paths from tool calls
+        if msg.tool_calls:
+            for tc in msg.tool_calls:
+                args_str = tc.arguments
+                # Extract "path" from JSON arguments
+                path_match = re.search(r'"path"\s*:\s*"([^"]+)"', args_str)
+                if path_match:
+                    path = path_match.group(1)
+                    short = path.split("/")[-1] if "/" in path else path
+                    if tc.name in ("write_file", "edit_file"):
+                        memory.files_modified.append(short)
+                    elif tc.name == "read_file":
+                        memory.files_read.append(short)
+
+        # Extract error mentions from tool results
+        if msg.role == "tool" and content:
+            if '"error"' in content:
+                error_match = re.search(r'"error"\s*:\s*"([^"]{1,100})"', content)
+                if error_match:
+                    memory.errors_encountered.append(error_match.group(1)[:80])
+
+        # Extract decisions from assistant messages
+        if msg.role == "assistant" and content:
+            # Look for action statements
+            for pattern in [
+                r"I (?:will|'ll|have) (?:change|modify|update|fix|add|remove|create)\w* (.{10,60})",
+                r"(?:Changed|Modified|Updated|Fixed|Added|Removed|Created) (.{10,60})",
+            ]:
+                for m in re.finditer(pattern, content):
+                    memory.decisions.append(m.group(0)[:80])
+
+    return memory
+
+
+def smart_compact(
+    messages: list[Message],
+    keep_recent: int = 10,
+    target_ratio: float = 0.60,
+    max_tokens: int = 1050000  # gpt-5.4: 1.05M context,
+) -> list[Message]:
+    """Intelligently compact conversation history.
+
+    Strategy:
+    1. ALWAYS keep: system message (index 0)
+    2. Extract working memory from old messages
+    3. Keep recent N messages intact
+    4. Replace everything in between with working memory summary
+
+    This preserves:
+    - Full system prompt (Godot knowledge, build discipline)
+    - What files were modified and why (working memory)
+    - Recent conversation context (for continuity)
+
+    While discarding:
+    - Old tool results (files can be re-read)
+    - Old LLM explanations (decisions captured in memory)
+    - Redundant back-and-forth
+    """
+    total = sum(estimate_message_tokens(m) for m in messages)
+    if total < max_tokens * target_ratio:
+        return messages  # No compaction needed
+
+    if len(messages) <= keep_recent + 1:
+        return messages  # Nothing to compact
+
+    # Split: system | old | recent
+    system = messages[0]  # Always a system message
+    rest = messages[1:]
+
+    if len(rest) <= keep_recent:
+        return messages
+
+    old = rest[:-keep_recent]
+    recent = rest[-keep_recent:]
+
+    # Extract working memory from old messages
+    memory = _extract_working_memory(old)
+    memory_text = memory.to_message()
+
+    # Build compacted message list
+    result = [system]
+
+    # Add working memory as a user context message
+    if memory_text.strip():
+        result.append(Message.user(memory_text))
+
+    # Add brief summary of how many turns were compressed
+    turn_count = sum(1 for m in old if m.role == "user")
+    result.append(Message.user(
+        f"[CONTEXT] {turn_count} previous conversation turns were compressed. "
+        f"Working memory above contains the key facts. "
+        f"If you need file contents, read them again with the read_file tool."
+    ))
+
+    # Add recent messages intact
+    result.extend(recent)
+
+    return result
+
+
+# Legacy aliases for backward compatibility
+def compact_messages(
+    messages: list[Message],
+    keep_recent: int = 8,
+    keep_system: bool = True,
+) -> list[Message]:
+    """Legacy compaction function. Delegates to smart_compact."""
+    return smart_compact(messages, keep_recent=keep_recent)
+
+
+def select_relevant_files(
+    all_files: list[str],
+    user_prompt: str,
+    max_files: int = 10,
+) -> list[str]:
+    """Select the most relevant files to include in context."""
+    prompt_lower = user_prompt.lower()
+    scored: list[tuple[float, str]] = []
+
+    for f in all_files:
+        score = 0.0
+        fname = f.lower()
+        basename = fname.split("/")[-1].replace(".gd", "").replace(".tscn", "")
+        if basename in prompt_lower:
+            score += 10.0
+        if "project.godot" in fname:
+            score += 5.0
+        if "autoload" in fname or "manager" in fname:
+            score += 3.0
+        if "main" in fname or "game" in fname:
+            score += 2.0
+        if fname.endswith(".gd"):
+            score += 1.0
+        if fname.endswith(".tscn"):
+            score += 0.5
+        scored.append((score, f))
+
+    scored.sort(key=lambda x: x[0], reverse=True)
+    return [f for _, f in scored[:max_files]]

{god_code-0.4.0 → god_code-0.4.3}/godot_agent/runtime/engine.py

@@ -9,13 +9,14 @@ from pathlib import Path
 from typing import Callable
 
 from godot_agent.llm.client import ChatResponse, LLMClient, Message, TokenUsage
-from godot_agent.runtime.context_manager import compact_messages, estimate_tokens
+from godot_agent.runtime.context_manager import smart_compact, estimate_message_tokens
 from godot_agent.runtime.error_loop import format_validation_for_llm, validate_project
 from godot_agent.tools.registry import ToolRegistry
 
 log = logging.getLogger(__name__)
 
-_COMPACT_THRESHOLD = 80000
+# Compact at 75% of 1.05M context to leave room for current turn
+_COMPACT_THRESHOLD = 787500  # 75% of 1.05M
 _FILE_MUTATING_TOOLS = {"write_file", "edit_file"}
 
 
@@ -54,10 +55,15 @@ class ConversationEngine:
         self.session_api_calls = 0
         self.last_turn: TurnStats | None = None
 
+        self.auto_commit = False
+        self.use_streaming = False
+
         # TUI callbacks
         self.on_tool_start: ToolStartCallback | None = None
         self.on_tool_end: ToolEndCallback | None = None
         self.on_diff: DiffCallback | None = None
+        self.on_stream_chunk: Callable[[str], None] | None = None
+        self.on_commit_suggest: Callable[[], None] | None = None
 
     def scan_project(self) -> str | None:
         """Auto-scan project for context. Returns summary or None."""
@@ -90,10 +96,16 @@ class ConversationEngine:
         return None
 
     async def _maybe_compact(self) -> None:
-        total = sum(estimate_tokens(str(m.content or "")) for m in self.messages)
+        total = sum(estimate_message_tokens(m) for m in self.messages)
         if total > _COMPACT_THRESHOLD:
-            log.info("Compacting conversation: ~%d tokens", total)
-            self.messages = compact_messages(self.messages, keep_recent=8)
+            before = len(self.messages)
+            log.info("Smart compacting: ~%d tokens, %d messages", total, before)
+            self.messages = smart_compact(
+                self.messages, keep_recent=20, target_ratio=0.60, max_tokens=1050000
+            )
+            after = len(self.messages)
+            after_tokens = sum(estimate_message_tokens(m) for m in self.messages)
+            log.info("Compacted: %d → %d messages, ~%d tokens", before, after, after_tokens)
 
     async def _post_tool_validate(self, tool_names: set[str]) -> str | None:
         if not self.project_path or not self.auto_validate:
@@ -127,12 +139,21 @@ class ConversationEngine:
             return args.get("command", "")[:40]
         return ""
 
-    async def _run_loop(self, tools: list[dict] | None) -> str:
+    async def _run_loop(self, tools: list[dict] | None, use_streaming: bool = False) -> str:
         turn = TurnStats()
 
         for _ in range(self.max_tool_rounds + 1):
             await self._maybe_compact()
-            chat_resp: ChatResponse = await self.client.chat(self.messages, tools)
+
+            # Use streaming for the final text response (no tool calls expected after tools done)
+            if use_streaming and self.on_stream_chunk:
+                from godot_agent.llm.streaming import stream_chat_with_callback
+                chat_resp = await stream_chat_with_callback(
+                    self.client, self.messages, tools,
+                    on_chunk=self.on_stream_chunk,
+                )
+            else:
+                chat_resp = await self.client.chat(self.messages, tools)
             response = chat_resp.message
 
             turn.usage = turn.usage + chat_resp.usage
@@ -198,13 +219,18 @@ class ConversationEngine:
                     f"Fix the errors before proceeding."
                 ))
 
+            # Auto-commit suggestion after successful file mutations
+            if self.auto_commit and (tool_names_used & _FILE_MUTATING_TOOLS) and not validation_report:
+                if self.on_commit_suggest:
+                    self.on_commit_suggest()
+
         self.last_turn = turn
         return "Tool call limit reached. Please simplify the request."
 
     async def submit(self, user_input: str) -> str:
         self.messages.append(Message.user(user_input))
         tools = self.registry.to_openai_tools() or None
-        return await self._run_loop(tools)
+        return await self._run_loop(tools, use_streaming=self.use_streaming)
 
     async def submit_with_images(self, text: str, images_b64: list[str]) -> str:
         self.messages.append(Message.user_with_images(text, images_b64))

{god_code-0.4.0 → god_code-0.4.3}/godot_agent/runtime/session.py

@@ -35,3 +35,24 @@ def load_session(session_dir: str, session_id: str) -> list[dict] | None:
         return None
     data = json.loads(file_path.read_text())
     return data.get("messages", [])
+
+
+def load_latest_session(session_dir: str) -> tuple[str, list[Message]] | None:
+    """Load the most recent session. Returns (session_id, messages) or None."""
+    dir_path = Path(session_dir)
+    if not dir_path.exists():
+        return None
+    files = sorted(dir_path.glob("*.json"), key=lambda f: f.stat().st_mtime, reverse=True)
+    if not files:
+        return None
+    data = json.loads(files[0].read_text())
+    session_id = data.get("session_id", files[0].stem)
+    raw_messages = data.get("messages", [])
+    messages: list[Message] = []
+    for m in raw_messages:
+        messages.append(Message(
+            role=m.get("role", "user"),
+            content=m.get("content"),
+            tool_call_id=m.get("tool_call_id"),
+        ))
+    return session_id, messages

{god_code-0.4.0 → god_code-0.4.3}/godot_agent/tools/shell.py

@@ -13,22 +13,47 @@ from godot_agent.tools.file_ops import _project_root
 
 log = logging.getLogger(__name__)
 
-# Commands that are never allowed
-_BLOCKED_PATTERNS = [
+# Safety level — set by CLI on startup
+_safety_level: str = "normal"  # strict, normal, permissive
+
+def set_safety_level(level: str) -> None:
+    global _safety_level
+    _safety_level = level
+
+# Patterns blocked at each safety level
+_ALWAYS_BLOCKED = [
     r'\brm\s+-rf\s+/',        # rm -rf /
     r'\brm\s+-rf\s+~',        # rm -rf ~
+    r'\bmkfs\b',              # format disk
+    r'\bdd\s+if=',            # dd disk operations
+]
+
+_NORMAL_BLOCKED = _ALWAYS_BLOCKED + [
     r'\bcurl\b.*\|.*\bsh\b',  # curl | sh
     r'\bwget\b.*\|.*\bsh\b',  # wget | sh
     r'\bchmod\s+777\b',       # chmod 777
     r'\bsudo\b',              # sudo anything
-    r'\bmkfs\b',              # format disk
-    r'\bdd\s+if=',            # dd disk operations
+]
+
+_STRICT_BLOCKED = _NORMAL_BLOCKED + [
+    r'\bcurl\b',              # any curl
+    r'\bwget\b',              # any wget
+    r'\bnpm\s+install\b',     # npm install
+    r'\bpip\s+install\b',     # pip install
+    r'\bgit\s+push\b',        # git push
+    r'\bgit\s+reset\b',       # git reset
 ]
 
 
 def _is_blocked(command: str) -> str | None:
-    """Check if a command matches blocked patterns. Returns reason or None."""
-    for pattern in _BLOCKED_PATTERNS:
+    """Check if a command matches blocked patterns based on safety level."""
+    if _safety_level == "permissive":
+        patterns = _ALWAYS_BLOCKED
+    elif _safety_level == "strict":
+        patterns = _STRICT_BLOCKED
+    else:
+        patterns = _NORMAL_BLOCKED
+    for pattern in patterns:
         if re.search(pattern, command):
             return f"Blocked: command matches dangerous pattern '{pattern}'"
     return None

god_code-0.4.3/godot_agent/tui/input_handler.py

@@ -0,0 +1,100 @@
+"""Rich input with history, auto-complete, and multi-line support."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.formatted_text import HTML
+
+
+class CommandCompleter(Completer):
+    """Auto-complete for / commands and file paths."""
+
+    COMMANDS = [
+        ("/cd ", "change project directory"),
+        ("/info", "show project details"),
+        ("/status", "show model & auth"),
+        ("/usage", "show token usage"),
+        ("/settings", "show all settings"),
+        ("/set ", "change a setting"),
+        ("/save", "save session"),
+        ("/load", "restore session"),
+        ("/help", "show commands"),
+        ("/quit", "exit"),
+    ]
+
+    SETTINGS = [
+        "language", "verbosity", "auto_validate", "auto_commit",
+        "token_budget", "safety", "streaming", "extra_prompt",
+    ]
+
+    def __init__(self, project_root: Path | None = None):
+        self.project_root = project_root
+
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        word = document.get_word_before_cursor()
+
+        # Command completion
+        if text.startswith("/"):
+            for cmd, desc in self.COMMANDS:
+                if cmd.startswith(text):
+                    yield Completion(cmd, start_position=-len(text), display_meta=desc)
+            return
+
+        # /set <key> completion
+        if text.startswith("/set "):
+            parts = text.split()
+            if len(parts) == 2:
+                prefix = parts[1]
+                for s in self.SETTINGS:
+                    if s.startswith(prefix):
+                        yield Completion(s, start_position=-len(prefix))
+            return
+
+        # cd/path completion
+        if text.startswith("cd ") or text.startswith("/cd "):
+            prefix = text.split(None, 1)[1] if " " in text else ""
+            path = Path(prefix).expanduser()
+            parent = path.parent if not path.is_dir() else path
+            stem = path.name if not path.is_dir() else ""
+            try:
+                for item in sorted(parent.iterdir()):
+                    if item.name.startswith("."):
+                        continue
+                    if item.name.lower().startswith(stem.lower()):
+                        suffix = "/" if item.is_dir() else ""
+                        yield Completion(
+                            item.name + suffix,
+                            start_position=-len(stem),
+                        )
+            except (PermissionError, FileNotFoundError):
+                pass
+
+
+def create_session(history_file: str | None = None) -> PromptSession:
+    """Create a PromptSession with file history."""
+    history = FileHistory(history_file) if history_file else None
+    return PromptSession(history=history)
+
+
+def get_input(session: PromptSession, completer: CommandCompleter | None = None) -> str | None:
+    """Get user input with history and completion. Returns None on EOF/interrupt."""
+    try:
+        return session.prompt(
+            HTML("<green>you&gt;</green> "),
+            completer=completer,
+        )
+    except (EOFError, KeyboardInterrupt):
+        return None
+
+
+def get_multiline_continuation(session: PromptSession) -> str | None:
+    """Get continuation line for multi-line input."""
+    try:
+        return session.prompt(HTML("<dim>...</dim> "))
+    except (EOFError, KeyboardInterrupt):
+        return None

{god_code-0.4.0 → god_code-0.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "god-code"
-version = "0.4.0"
+version = "0.4.3"
 description = "AI coding agent specialized for Godot game development"
 requires-python = ">=3.9"
 license = {text = "GPL-3.0-or-later"}
@@ -12,6 +12,7 @@ dependencies = [
     "Pillow>=10.3",
     "rich>=13.0",
     "packaging>=21.0",
+    "prompt_toolkit>=3.0",
     "eval_type_backport>=0.2.0; python_version < '3.10'",
 ]
 

{god_code-0.4.0 → god_code-0.4.3}/tests/runtime/test_context_manager.py

@@ -20,14 +20,17 @@ class TestCompactMessages:
         assert len(result) == 3  # unchanged
 
     def test_compact_old_messages(self):
+        # Use small max_tokens to force compaction even with small messages
+        from godot_agent.runtime.context_manager import smart_compact
         msgs = [Message.system("sys")]
         for i in range(20):
             msgs.append(Message.user(f"question {i}"))
             msgs.append(Message.assistant(content=f"answer {i}"))
-        result = compact_messages(msgs, keep_recent=4)
+        # Force compaction with a tiny max_tokens
+        result = smart_compact(msgs, keep_recent=4, target_ratio=0.01, max_tokens=100)
         assert len(result) < len(msgs)
-        assert result[0].role == "system"  # system kept
-        assert result[-1].content == "answer 19"  # recent kept
+        assert result[0].role == "system"
+        assert result[-1].content == "answer 19"
 
 
 class TestSelectRelevantFiles:

god_code-0.4.0/godot_agent/llm/streaming.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-import json
-from typing import AsyncIterator
-from godot_agent.llm.client import LLMClient, Message
-
-
-async def stream_chat(
-    client: LLMClient,
-    messages: list[Message],
-    tools: list[dict] | None = None,
-) -> AsyncIterator[dict]:
-    body = client._build_request_body(messages, tools)
-    body["stream"] = True
-    async with client._http.stream(
-        "POST",
-        f"{client.config.base_url}/chat/completions",
-        headers=client._build_headers(),
-        json=body,
-    ) as resp:
-        resp.raise_for_status()
-        async for line in resp.aiter_lines():
-            if line.startswith("data: "):
-                data = line[6:]
-                if data.strip() == "[DONE]":
-                    break
-                yield json.loads(data)

god_code-0.4.0/godot_agent/runtime/context_manager.py

@@ -1,135 +0,0 @@
-"""Context window management for multi-file Godot projects.
-
-Prevents context overflow by:
-- Summarizing old conversation turns
-- Selecting which files to include based on relevance
-- Tracking token usage estimates
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-
-from godot_agent.llm.client import Message
-
-
-@dataclass
-class ContextBudget:
-    max_tokens: int = 128000
-    system_prompt_tokens: int = 0
-    message_tokens: int = 0
-    reserved_for_response: int = 4096
-
-    @property
-    def available(self) -> int:
-        return self.max_tokens - self.system_prompt_tokens - self.message_tokens - self.reserved_for_response
-
-    @property
-    def usage_ratio(self) -> float:
-        used = self.system_prompt_tokens + self.message_tokens
-        return used / self.max_tokens if self.max_tokens > 0 else 0.0
-
-    @property
-    def should_compact(self) -> bool:
-        return self.usage_ratio > 0.7
-
-
-def estimate_tokens(text: str) -> int:
-    """Rough token estimate: ~4 chars per token for English, ~2 for CJK."""
-    return len(text) // 3  # Conservative estimate
-
-
-def compact_messages(
-    messages: list[Message],
-    keep_recent: int = 6,
-    keep_system: bool = True,
-) -> list[Message]:
-    """Compact conversation history by summarizing old turns.
-
-    Keeps:
-    - System message (always)
-    - Last N messages (recent context)
-    - Summarizes everything in between
-    """
-    if len(messages) <= keep_recent + 1:
-        return messages  # Nothing to compact
-
-    result: list[Message] = []
-
-    # Keep system message
-    if keep_system and messages and messages[0].role == "system":
-        result.append(messages[0])
-        rest = messages[1:]
-    else:
-        rest = messages
-
-    if len(rest) <= keep_recent:
-        return result + rest
-
-    # Summarize old messages
-    old = rest[:-keep_recent]
-    recent = rest[-keep_recent:]
-
-    summary_parts: list[str] = []
-    for msg in old:
-        if msg.role == "user":
-            content = msg.content if isinstance(msg.content, str) else "[image+text message]"
-            summary_parts.append(f"User asked: {content[:100]}...")
-        elif msg.role == "assistant":
-            if msg.tool_calls:
-                tools = ", ".join(tc.name for tc in msg.tool_calls)
-                summary_parts.append(f"Agent used tools: {tools}")
-            elif msg.content:
-                summary_parts.append(f"Agent replied: {msg.content[:100]}...")
-        elif msg.role == "tool":
-            summary_parts.append(f"Tool returned result")
-
-    summary = "[Conversation history summary]\n" + "\n".join(summary_parts)
-    result.append(Message.user(summary))
-    result.extend(recent)
-
-    return result
-
-
-def select_relevant_files(
-    all_files: list[str],
-    user_prompt: str,
-    max_files: int = 10,
-) -> list[str]:
-    """Select the most relevant files to include in context.
-
-    Prioritizes:
-    1. Files mentioned in the prompt
-    2. Recently modified files
-    3. Core files (project.godot, autoloads, main scene)
-    """
-    prompt_lower = user_prompt.lower()
-    scored: list[tuple[float, str]] = []
-
-    for f in all_files:
-        score = 0.0
-        fname = f.lower()
-
-        # Direct mention in prompt
-        basename = fname.split("/")[-1].replace(".gd", "").replace(".tscn", "")
-        if basename in prompt_lower:
-            score += 10.0
-
-        # Core files always relevant
-        if "project.godot" in fname:
-            score += 5.0
-        if "autoload" in fname or "manager" in fname:
-            score += 3.0
-        if "main" in fname or "game" in fname:
-            score += 2.0
-
-        # File type relevance
-        if fname.endswith(".gd"):
-            score += 1.0
-        if fname.endswith(".tscn"):
-            score += 0.5
-
-        scored.append((score, f))
-
-    scored.sort(key=lambda x: x[0], reverse=True)
-    return [f for _, f in scored[:max_files]]