alpiecode 0.9.7__tar.gz → 0.9.8__tar.gz

{alpiecode-0.9.7 → alpiecode-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 0.9.7
+Version: 0.9.8
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-0.9.7 → alpiecode-0.9.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "0.9.7"
+version = "0.9.8"
 description = "AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-0.9.7 → alpiecode-0.9.8}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 0.9.7
+Version: 0.9.8
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-0.9.7 → alpiecode-0.9.8}/src/codeagent/compaction.py

@@ -20,7 +20,7 @@ MAX_CONTEXT_TOKENS = 262_144
 # Start compacting when we hit this percentage of the context window
 COMPACT_THRESHOLD = 0.70
 # Number of recent turns to always keep intact
-KEEP_RECENT_TURNS = 10
+KEEP_RECENT_TURNS = 20
 # Approximate chars per token (rough heuristic)
 CHARS_PER_TOKEN = 4
 
@@ -52,6 +52,10 @@ def needs_compaction(messages: List[dict], max_tokens: int = MAX_CONTEXT_TOKENS)
 
 def _summarize_tool_result(tool_name: str, content: str) -> str:
     """Create a compact summary of a tool result."""
+    # NEVER truncate the execution plan — it's critical architectural context
+    if tool_name == "update_plan":
+        return content
+
     if len(content) <= 300:
         return content
 

{alpiecode-0.9.7 → alpiecode-0.9.8}/src/codeagent/config.py

@@ -26,9 +26,9 @@ DEFAULTS = {
     "model_repo": "169Pi/Alpie_learn_prototype_GGUF_NEW",
     "api_key": "not-needed",
     "hf_token": None,
-    "max_turns": 30,
+    "max_turns": 50,
     "temperature": 0.2,
-    "max_tokens": 16384,
+    "max_tokens": 32768,
     "enable_thinking": True,
     "n_ctx": 32768,  # 32k context window (model supports up to 131k)
     "n_gpu_layers": None,  # None = auto-detect GPU
@@ -88,9 +88,9 @@ class Config:
     model_repo: str = "169Pi/Alpie_learn_prototype_GGUF_NEW"  # HuggingFace repo for offline GGUF
     api_key: str = "not-needed"
     hf_token: Optional[str] = None
-    max_turns: int = 30
+    max_turns: int = 50
     temperature: float = 0.2
-    max_tokens: int = 16384
+    max_tokens: int = 32768
     enable_thinking: bool = True
     n_ctx: int = 32768
     n_gpu_layers: Optional[int] = None

{alpiecode-0.9.7 → alpiecode-0.9.8}/src/codeagent/memory.py

@@ -104,26 +104,52 @@ def extract_and_save_memories(workdir: Path, messages: list) -> None:
     After a session ends, extract key learnings from the conversation
     and save them as memories.
 
-    This scans tool results for commonly useful information like:
+    Scans tool results for commonly useful information like:
+    - Successful build/test commands
     - Project structure (from list_files results)
-    - Test commands (from bash results running tests)
-    - Build commands (from bash results running builds)
+    - Completion summaries
     """
-    for msg in messages:
+    saved_cmds = set()  # Avoid duplicate command memories
+
+    for idx, msg in enumerate(messages):
         if not isinstance(msg, dict):
             continue
 
-        # Look for tool results
+        # ── Save successful build/test commands ──
         if msg.get("role") == "tool":
             content = msg.get("content", "")
-
-            # Detect test commands that succeeded
-            if '"exit_code": 0' in content and any(kw in content.lower() for kw in
-                    ["pytest", "test", "passed", "ok", "success"]):
-                # Find the corresponding tool call to get the command
-                pass  # Would need more context to extract command
-
-        # Look for assistant messages with DONE
+            if '"exit_code": 0' in content:
+                # Walk backwards to find the bash tool_call that produced this result
+                tool_call_id = msg.get("tool_call_id", "")
+                for prev in reversed(messages[:idx]):
+                    if prev.get("role") == "assistant" and prev.get("tool_calls"):
+                        for tc in prev["tool_calls"]:
+                            tc_dict = tc if isinstance(tc, dict) else {}
+                            if tc_dict.get("id") == tool_call_id:
+                                fn = tc_dict.get("function", {})
+                                if fn.get("name") == "bash":
+                                    try:
+                                        args = fn.get("arguments", "{}")
+                                        if isinstance(args, str):
+                                            args = json.loads(args)
+                                        cmd = args.get("command", "")
+                                    except (json.JSONDecodeError, AttributeError):
+                                        cmd = ""
+                                    if cmd and cmd not in saved_cmds:
+                                        if any(kw in cmd for kw in ["pytest", "test", "unittest", "npm run test", "cargo test", "go test"]):
+                                            save_memory(workdir, f"Working test command: {cmd}", "command")
+                                            saved_cmds.add(cmd)
+                                        elif any(kw in cmd for kw in ["build", "compile", "g++", "gcc", "make", "cargo build", "npm run build"]):
+                                            save_memory(workdir, f"Working build command: {cmd}", "command")
+                                            saved_cmds.add(cmd)
+                        break
+
+            # ── Save project structure from list_files / tree output ──
+            if "├" in content or "└" in content:
+                if len(content) < 2000:
+                    save_memory(workdir, f"Project structure:\n{content[:500]}", "structure")
+
+        # ── Save completion summaries ──
         if msg.get("role") == "assistant" and msg.get("content"):
             content = msg["content"]
             if content.strip().startswith("DONE"):

{alpiecode-0.9.7 → alpiecode-0.9.8}/src/codeagent/prompt.py

@@ -135,6 +135,61 @@ Before the first edit, write down:
   ("the test suite passes with 0 failures", not "validate the output")
 Use the update_plan tool to record this.
 
+## Complex Project Workflow (Multi-File Projects)
+When building a game, website, full-stack app, or any multi-file project:
+
+### Step 1: Architecture Plan (MANDATORY)
+Before writing ANY code, use update_plan to document:
+- ALL files that need to be created (with their purposes)
+- Dependencies between files (what imports what, what links with what)
+- The exact build/run command
+- Data structures and state management approach
+- How you will verify each component works
+
+### Step 2: Build Foundation First
+- Create the project skeleton (directory structure, config files, Makefile)
+- Write shared utilities / data structures / header files FIRST
+- Then write the main entry point / core module
+- Then write secondary modules and UI components
+- For games: implement game state → physics → rendering → input → game loop (in that order)
+- For websites: implement HTML structure → CSS styling → JS interactivity (in that order)
+- For APIs: implement models → routes → middleware → tests (in that order)
+
+### Step 3: Incremental Verification
+After writing EACH file:
+- For C/C++: compile immediately with `g++ -Wall -Wextra -std=c++17 -c file.cpp` to catch errors early
+- For Python: run `python -c "import module_name"` to verify syntax and imports
+- For web: verify HTML is well-formed, CSS selectors exist, JS has no syntax errors
+- Fix ALL errors in the current file before moving to the next file
+
+### Step 4: Integration Build & Test
+After all files are written:
+- Build/compile the complete project end-to-end
+- Run the primary user flow / test suite
+- Fix any linker errors, import errors, or integration issues
+- For games: verify all game elements render (player, enemies, score, boundaries)
+
+### Step 5: Polish & Deliver
+- Read back key functions to verify logical correctness
+- Ensure ALL features mentioned in the user's request are implemented
+- Tell the user exactly how to build and run the project
+
+## Writing Complete, Working Code — CRITICAL
+When creating a file, you MUST:
+1. Think through the ENTIRE implementation BEFORE calling write_file
+2. Include ALL necessary imports / includes / headers at the top
+3. Implement EVERY function completely — no stubs, no TODOs, no "implement later"
+4. Handle edge cases and error conditions properly
+5. For games: implement ALL game mechanics — physics, collision, scoring, rendering, \
+   input handling, game over, restart. A game with missing mechanics is broken.
+6. For websites: include ALL routes, complete HTML pages, CSS styling, JS interactivity, \
+   and error pages. A website with missing pages is broken.
+7. For APIs: implement ALL endpoints with proper request validation, error handling, \
+   and response formatting. An API with missing endpoints is broken.
+
+NEVER write partial code and say "I'll add the rest later" — write it ALL in one go. \
+The user expects a COMPLETE, WORKING program on the first delivery.
+
 ## Working with files
 - Always read_file before editing — never edit a file you haven't read
 - Use edit_file for targeted changes (preferred), write_file only for new files
@@ -328,17 +383,39 @@ Rules:
 
 
 def is_simple_task(task: str) -> bool:
-    """Detect simple tasks that don't benefit from deep reasoning traces."""
+    """Detect simple tasks that don't benefit from deep reasoning traces.
+
+    IMPORTANT: Complex project requests (games, websites, APIs, full-stack apps)
+    must ALWAYS get thinking mode enabled, regardless of prompt length.
+    """
     task_lower = task.lower().strip()
-    if len(task_lower) < 80:
-        return True
-    simple_patterns = [
-        "fix typo", "add comment", "rename", "format", "add docstring",
-        "remove unused", "add import", "update version", "change color",
-        "fix indent", "add logging", "hello world", "fibonacci",
-        "print ", "add a test", "calculator",
+
+    # Complex task keywords — ALWAYS need thinking regardless of length
+    complex_patterns = [
+        "build", "create", "implement", "develop", "design", "make",
+        "game", "website", "webapp", "web app", "full stack", "fullstack",
+        "api", "server", "database", "authentication", "deploy",
+        "refactor", "migrate", "architecture", "system",
+        "flappy", "snake", "tetris", "chess", "pong", "sudoku",
+        "todo app", "portfolio", "dashboard", "e-commerce", "ecommerce",
+        "crud", "rest api", "graphql", "microservice",
+        "project", "application", "framework", "library", "package",
+        "html", "css", "react", "flask", "django", "fastapi", "express",
+        "multi-file", "multifile", "full", "complete",
     ]
-    return any(pat in task_lower for pat in simple_patterns)
+    if any(pat in task_lower for pat in complex_patterns):
+        return False  # Complex task — needs deep thinking
+
+    # Only treat as simple if short AND matches trivial edit patterns
+    if len(task_lower) < 50:
+        simple_patterns = [
+            "fix typo", "add comment", "rename", "format", "add docstring",
+            "remove unused", "add import", "update version", "change color",
+            "fix indent", "add logging", "hello world",
+        ]
+        return any(pat in task_lower for pat in simple_patterns)
+
+    return False
 
 
 class PromptBuilder: