nimcode 0.7.0__tar.gz → 0.8.0__tar.gz

{nimcode-0.7.0 → nimcode-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.7.0
+Version: 0.8.0
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent
@@ -157,7 +157,7 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ```json
 {
-    "model": "meta/llama-3.1-70b-instruct",
+    "model": "meta/llama-3.3-70b-instruct",
     "api_base_url": "https://integrate.api.nvidia.com/v1",
     "timeout_command": 1200,
     "timeout_llm": 120,
@@ -175,7 +175,7 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 | Setting | Default | Description |
 |---------|---------|-------------|
-| `model` | `meta/llama-3.1-70b-instruct` | Default LLM model |
+| `model` | `meta/llama-3.3-70b-instruct` | Default LLM model |
 | `api_base_url` | NVIDIA NIM endpoint | Switch to Ollama/vLLM by changing this |
 | `timeout_command` | 1200 | Max seconds for bash commands (0 = infinite) |
 | `timeout_llm` | 120 | Max seconds for LLM API calls (0 = infinite) |
@@ -193,7 +193,24 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ## 📋 Changelog
 
-### v0.5.5 (Latest)
+### v0.8.0 (Latest)
+- 📝 **SDD-Style Planning**: `/plan` mode now forces the LLM to output Software Design Document (SDD) style templates with specific dependency graphs, timelines, and rigorous phase tracking (the "Empty Recursive Goblet" approach).
+- 🧱 **Physical Exit Blockers for Tasks**: If the LLM tries to call `TASK_COMPLETE` but still has pending or in_progress tasks in its `.nimcode/tasks.json` file, it will physically intercept the tool call, throw a `SYSTEM ERROR`, and force the LLM to finish the open tasks.
+- 🛡️ **Ultimate Anti-Lazy Shield**: Expanded AST and regex blockers that catch semantic laziness (e.g., `"// rest of the code remains unchanged"`, `"logic goes here"`, or using `...` / Ellipsis in Python). A zero-tolerance policy that forces the LLM to rewrite incomplete code.
+- 🧩 **Chunked Generation (Append Tool)**: A new `Append` tool allows the LLM to write massive documents and code files in chunks over multiple turns without hitting context token limits, directly curing "Lazy Coder Syndrome".
+- 🧪 **205 tests passing**
+
+### v0.7.0
+- 🛡️ **Strict Markdown Validator**: `/plan` mode now physically blocks tasks that are under 150 characters or missing required Markdown headers (`Target Files`, `Implementation Details`, `Checklist`).
+- 🧠 **Context Amnesia Shield (AST Diff)**: When modifying Python files, the `ReplaceBlock` tool compares the Abstract Syntax Tree (AST) before and after. If the LLM accidentally deletes over 30% or 2+ top-level functions (truncation hallucination), it instantly blocks the write and forces a fix.
+- 🔗 **Task Linearity Guard**: `TaskManager` enforces strict order. The agent cannot start Task 1.2 until Task 1.1 is fully completed.
+
+### v0.6.0
+- 🛡️ **Anti-Laziness AST Blockers**: Native AST checking explicitly intercepts `pass` blocks, empty classes, and lazy placeholder comments (like `// TODO`), forcing the LLM to write full implementations.
+- 🕵️ **Adversarial QA Gate**: Built a multi-agent validation layer (`qa_agent.py`) that strictly critiques the main agent's work. The main agent cannot complete tasks without receiving a `VERDICT: PASS` from the QA Agent.
+- 💾 **Task State Machine**: Replaced in-memory lists with `.nimcode/tasks.json` persistent storage via `TaskManager`, allowing robust restartability and task state tracking (`pending`, `in_progress`, `completed`).
+
+### v0.5.5
 - 🐛 **UI Bug Fix**: Fixed a visual bug where the CLI welcome banner hardcoded `NimCode v0.2.0` despite the user having updated to a newer version.
 
 ### v0.5.4

{nimcode-0.7.0 → nimcode-0.8.0}/README.md

@@ -136,7 +136,7 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ```json
 {
-    "model": "meta/llama-3.1-70b-instruct",
+    "model": "meta/llama-3.3-70b-instruct",
     "api_base_url": "https://integrate.api.nvidia.com/v1",
     "timeout_command": 1200,
     "timeout_llm": 120,
@@ -154,7 +154,7 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 | Setting | Default | Description |
 |---------|---------|-------------|
-| `model` | `meta/llama-3.1-70b-instruct` | Default LLM model |
+| `model` | `meta/llama-3.3-70b-instruct` | Default LLM model |
 | `api_base_url` | NVIDIA NIM endpoint | Switch to Ollama/vLLM by changing this |
 | `timeout_command` | 1200 | Max seconds for bash commands (0 = infinite) |
 | `timeout_llm` | 120 | Max seconds for LLM API calls (0 = infinite) |
@@ -172,7 +172,24 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ## 📋 Changelog
 
-### v0.5.5 (Latest)
+### v0.8.0 (Latest)
+- 📝 **SDD-Style Planning**: `/plan` mode now forces the LLM to output Software Design Document (SDD) style templates with specific dependency graphs, timelines, and rigorous phase tracking (the "Empty Recursive Goblet" approach).
+- 🧱 **Physical Exit Blockers for Tasks**: If the LLM tries to call `TASK_COMPLETE` but still has pending or in_progress tasks in its `.nimcode/tasks.json` file, it will physically intercept the tool call, throw a `SYSTEM ERROR`, and force the LLM to finish the open tasks.
+- 🛡️ **Ultimate Anti-Lazy Shield**: Expanded AST and regex blockers that catch semantic laziness (e.g., `"// rest of the code remains unchanged"`, `"logic goes here"`, or using `...` / Ellipsis in Python). A zero-tolerance policy that forces the LLM to rewrite incomplete code.
+- 🧩 **Chunked Generation (Append Tool)**: A new `Append` tool allows the LLM to write massive documents and code files in chunks over multiple turns without hitting context token limits, directly curing "Lazy Coder Syndrome".
+- 🧪 **205 tests passing**
+
+### v0.7.0
+- 🛡️ **Strict Markdown Validator**: `/plan` mode now physically blocks tasks that are under 150 characters or missing required Markdown headers (`Target Files`, `Implementation Details`, `Checklist`).
+- 🧠 **Context Amnesia Shield (AST Diff)**: When modifying Python files, the `ReplaceBlock` tool compares the Abstract Syntax Tree (AST) before and after. If the LLM accidentally deletes over 30% or 2+ top-level functions (truncation hallucination), it instantly blocks the write and forces a fix.
+- 🔗 **Task Linearity Guard**: `TaskManager` enforces strict order. The agent cannot start Task 1.2 until Task 1.1 is fully completed.
+
+### v0.6.0
+- 🛡️ **Anti-Laziness AST Blockers**: Native AST checking explicitly intercepts `pass` blocks, empty classes, and lazy placeholder comments (like `// TODO`), forcing the LLM to write full implementations.
+- 🕵️ **Adversarial QA Gate**: Built a multi-agent validation layer (`qa_agent.py`) that strictly critiques the main agent's work. The main agent cannot complete tasks without receiving a `VERDICT: PASS` from the QA Agent.
+- 💾 **Task State Machine**: Replaced in-memory lists with `.nimcode/tasks.json` persistent storage via `TaskManager`, allowing robust restartability and task state tracking (`pending`, `in_progress`, `completed`).
+
+### v0.5.5
 - 🐛 **UI Bug Fix**: Fixed a visual bug where the CLI welcome banner hardcoded `NimCode v0.2.0` despite the user having updated to a newer version.
 
 ### v0.5.4

nimcode-0.8.0/src/nimcode/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.8.0"

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode/agent.py

@@ -34,6 +34,7 @@ Available Tools:
 - Bash: {{"tool": "Bash", "args": {{"command": "string"}}}}
 - Read: {{"tool": "Read", "args": {{"file_path": "string", "offset": "int (optional, 1-based line number to start from)", "limit": "int (optional, max number of lines to return)"}}}}
 - Write: {{"tool": "Write", "args": {{"file_path": "string", "content": "string"}}}}
+- Append: {{"tool": "Append", "args": {{"file_path": "string", "content": "string"}}}} — Append content to a file (great for chunking large files).
 - Replace: {{"tool": "Replace", "args": {{"file_path": "string", "replacements": [{{"old_string": "string", "new_string": "string"}}]}}}}
 - ReplaceBlock: {{"tool": "ReplaceBlock", "args": {{"file_path": "string", "start_line": "int", "end_line": "int", "replacement_content": "string"}}}}
 - Glob: {{"tool": "Glob", "args": {{"pattern": "string"}}}}
@@ -106,10 +107,13 @@ If you can say it in one sentence, don't use three. Prefer short, direct sentenc
 - When referencing specific functions or pieces of code include the pattern file_path:line_number to allow the user to easily navigate to the source code location.
 - Do not use a colon before tool calls.
 
-# Anti-Laziness Policy (STRICT)
+# Chunked Generation & Lazy Coding Prevention (STRICT)
 - You are strictly FORBIDDEN from using placeholders like `// TODO`, `pass`, `$(cat secret.txt)`, `[Insert code here]`.
 - You MUST write complete, full implementations for all functions.
-- If you use placeholders, the system will detect it and reject your turn via Physical Blockers in your Write tool.
+- If you use placeholders, the system will detect it and reject your turn via Physical Blockers in your Write/Append tools.
+- NEVER try to `Write` a massive file (like a large code file or a huge markdown plan) in a single tool call. You will hit token limits and generate lazy code.
+- Instead, use the `Append` tool to write large documents/plans chapter by chapter over multiple turns.
+- For code editing, DO NOT use `Write` to rewrite an existing file. You MUST use `Replace` or `ReplaceBlock` to perform surgical edits (multi-patching).
 
 # Planning Mode Instructions
 When in /plan mode or asked to create a plan:
@@ -184,7 +188,7 @@ class Agent:
     def __init__(self, api_key: str, model: str = None, max_turns: int = None, permission_mode: PermissionMode = PermissionMode.DEFAULT, max_tokens: int = None):
         # Load global settings
         self.settings = load_settings()
-        self.model = model or self.settings.get("model", "meta/llama-3.1-70b-instruct")
+        self.model = model or self.settings.get("model", "meta/llama-3.3-70b-instruct")
         api_base_url = self.settings.get("api_base_url", "https://integrate.api.nvidia.com/v1")
         self.client = NimClient(
             api_key=api_key, 
@@ -524,6 +528,20 @@ class Agent:
                 logger.error(f"Failed to log to NIMCODE.md: {e}")
             
             if "TASK_COMPLETE" in full_content:
+                from .task_manager import TaskManager
+                tm = TaskManager()
+                incomplete = [t for t in tm.get_all_tasks() if t.get("status") in ("pending", "in_progress")]
+                
+                if incomplete:
+                    logger.warning("Agent attempted TASK_COMPLETE but tasks are incomplete.")
+                    from rich.console import Console
+                    Console().print(f"[bold red]🚨 PHYSICAL BLOCK: Agent tried to exit but {len(incomplete)} tasks are still pending/in_progress. Forcing retry.[/bold red]")
+                    self.messages.append({
+                        "role": "user",
+                        "content": f"SYSTEM ERROR: You attempted to use TASK_COMPLETE, but you still have {len(incomplete)} unfinished tasks. You MUST use tools to complete all tasks before finishing. Please continue working."
+                    })
+                    continue
+                    
                 logger.info("Agent finished task.")
                 break
 

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode/agents/qa_agent.py

@@ -8,11 +8,18 @@ class QAAgent:
         self.cwd = cwd
 
     def run(self, instructions: str) -> str:
+        # Check if tasks are completed first (Physical blocker)
+        from ..task_manager import TaskManager
+        tm = TaskManager()
+        incomplete = [t for t in tm.get_all_tasks() if t.get("status") in ("pending", "in_progress")]
+        if incomplete:
+            return f"VERDICT: FAIL\nYou cannot pass QA. There are still {len(incomplete)} unfinished tasks in tasks.json. Go back and complete them."
+            
         # Load API key
         import json
         settings_path = os.path.join(self.cwd, ".nimcode", "settings.json")
         api_key = os.environ.get("NVIDIA_API_KEY")
-        model = "meta/llama-3.1-70b-instruct"
+        model = "meta/llama-3.3-70b-instruct"
         if os.path.exists(settings_path):
             try:
                 with open(settings_path, "r") as f:

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode/cli.py

@@ -101,7 +101,7 @@ def main():
     # Main CLI arguments
     parser.add_argument("prompt", nargs="?", default=None, help="The task you want NimCode to accomplish. If omitted, starts interactive REPL.")
     parser.add_argument("--api-key", "-k", default=None, help="NVIDIA NIM API Key. Can also be set via NIM_API_KEY environment variable.")
-    parser.add_argument("--model", "-m", default="meta/llama-3.1-70b-instruct", help="Model ID to use from NIM.")
+    parser.add_argument("--model", "-m", default="meta/llama-3.3-70b-instruct", help="Model ID to use from NIM.")
     parser.add_argument("--max-turns", "-t", type=int, default=None, help="Maximum number of turns the agent is allowed to run. If omitted, uses settings.json max_turns (default 200; 0 = unlimited).")
     parser.add_argument("--permission-mode", "-p", type=PermissionMode, choices=list(PermissionMode), default=PermissionMode.DEFAULT, help="Permission mode for mutating tools.")
     parser.add_argument("--resume", "-r", action="store_true", help="Resume from the last session stored in .nimcode/sessions/session.json.")

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode/config.py

@@ -8,7 +8,7 @@ logger = logging.getLogger(__name__)
 def load_settings() -> Dict[str, Any]:
     """Loads configuration from ~/.nimcode/settings.json and .nimcode/settings.json"""
     settings = {
-        "model": "meta/llama-3.1-70b-instruct",
+        "model": "meta/llama-3.3-70b-instruct",
         "api_base_url": "https://integrate.api.nvidia.com/v1",
         "mcp_servers": {},
         # Timeouts (0 = disabled/infinite)

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode/model_registry.py

@@ -11,7 +11,7 @@ logger = logging.getLogger(__name__)
 MODEL_CONTEXT_WINDOWS = {
     # Llama 3.1 family
     "meta/llama-3.1-8b-instruct": 128000,
-    "meta/llama-3.1-70b-instruct": 128000,
+    "meta/llama-3.3-70b-instruct": 128000,
     "meta/llama-3.1-405b-instruct": 128000,
     # Llama 3.2 family
     "meta/llama-3.2-1b-instruct": 128000,
@@ -38,7 +38,7 @@ DEFAULT_CONTEXT_WINDOW = 8192
 
 # Hardcoded fallback model list (used when API is unreachable)
 FALLBACK_MODELS = [
-    "meta/llama-3.1-70b-instruct",
+    "meta/llama-3.3-70b-instruct",
     "meta/llama-3.1-8b-instruct",
     "meta/llama-3.1-405b-instruct",
     "meta/llama-3.3-70b-instruct",

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode/nim_client.py

@@ -8,7 +8,7 @@ from typing import List, Dict, Any, Optional, AsyncGenerator
 logger = logging.getLogger(__name__)
 
 class NimClient:
-    def __init__(self, api_key: str, base_url: str = "https://integrate.api.nvidia.com/v1", model: str = "meta/llama-3.1-70b-instruct", timeout: float = 120.0, max_retries: int = 15, retry_base_delay: float = 2.0, retry_max_delay: float = 60.0):
+    def __init__(self, api_key: str, base_url: str = "https://integrate.api.nvidia.com/v1", model: str = "meta/llama-3.3-70b-instruct", timeout: float = 120.0, max_retries: int = 15, retry_base_delay: float = 2.0, retry_max_delay: float = 60.0):
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
         self.model = model

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode/repl.py

@@ -446,24 +446,52 @@ class NimcodeREPL:
                         "   - Use this strict technical structure: # Title, ## Context, ## Root Cause Analysis, ## Execution Plan (file-by-file with line numbers/snippets), ## Verification.\n"
                         "3. IF it is a 'From-Scratch / Major Architecture' task:\n"
                         "   - Generate a SINGLE, EXTREMELY DETAILED master plan file (e.g. '.nimcode/plans/<name>.md').\n"
-                        "   - You MUST format the plan using EXACTLY this markdown template. Do not skip any sections. Do not summarize.\n\n"
+                        "   - You MUST format the plan using EXACTLY this recursive SDD-style markdown template. Do not skip any sections. Do not summarize.\n\n"
                         "   ```markdown\n"
-                        "   # [Project Name] Master Plan\n\n"
-                        "   ## Phase 1: [Phase Name]\n"
-                        "   ### Task 1.1: [Specific Task Name]\n"
-                        "   **Target Files**:\n"
-                        "   - `[exact/file/path.ext]`\n"
-                        "   **Dependencies/Commands**:\n"
-                        "   - `npm install xyz` or `cargo add xyz`\n"
-                        "   **Implementation Details**:\n"
-                        "   [Write exact code snippets, full function signatures, complete DB schemas, and exact logic here. This MUST NOT be a summary. It must be actual code and technical specs.]\n"
+                        "   # [Project Name] — Full Implementation Plan\n\n"
+                        "   **Source:** [Design doc reference]\n"
+                        "   **Stack:** [Tech Stack summary]\n"
+                        "   **Workspace:** [Root directory]\n\n"
+                        "   ## Context\n"
+                        "   [Detailed project context and requirements]\n\n"
+                        "   ## Environment\n"
+                        "   | Item | Status |\n"
+                        "   |------|--------|\n"
+                        "   | **OS** | [OS details] |\n"
+                        "   | **Language/Framework** | [Versions] |\n"
+                        "   | **Dependencies** | [Key libs] |\n\n"
+                        "   ## Phase 0 — Project Scaffolding\n"
+                        "   **Goal:** [Phase Goal]\n"
+                        "   ### 0.1 [Step Name]\n"
+                        "   [Code snippets, commands, implementation details]\n\n"
+                        "   ## Phase 1 — [Phase Name]\n"
+                        "   **Goal:** [Phase Goal]\n"
+                        "   ### 1.1 [Task Name]\n"
+                        "   [Code snippets, complete DB schemas, function signatures, exact logic. MUST NOT be a summary.]\n"
                         "   **Checklist**:\n"
                         "   - [ ] [Micro-step 1]\n"
                         "   - [ ] [Micro-step 2]\n\n"
-                        "   ### Task 1.2: [Next Task]\n"
-                        "   ... (Repeat this strict structure for EVERY feature in the project)\n"
+                        "   ## CI/CD & Packaging\n"
+                        "   [Details on Github Actions, builds, installers]\n\n"
+                        "   ## Testing Strategy\n"
+                        "   [Unit, Integration, E2E plan]\n\n"
+                        "   ## Key Architecture Patterns\n"
+                        "   [Core rules to follow]\n\n"
+                        "   ## Development Setup\n"
+                        "   [Commands to start dev server/tests]\n\n"
+                        "   ## Verification\n"
+                        "   [Steps to verify each phase]\n\n"
+                        "   ## Dependency Graph\n"
+                        "   ```text\n"
+                        "   [ASCII Map of modules/components]\n"
                         "   ```\n\n"
-                        "   - Under NO CIRCUMSTANCES should you write superficial steps like 'Initialize app' without providing the exact commands and code snippets in the Implementation Details.\n"
+                        "   ## Weekly Execution Schedule\n"
+                        "   ### Week X-Y: Phase Z\n"
+                        "   | Day | Tasks |\n"
+                        "   |-----|-------|\n"
+                        "   | **Day 1** | [Tasks] |\n"
+                        "   ```\n\n"
+                        "   - Under NO CIRCUMSTANCES should you write superficial steps like 'Initialize app' without providing the exact commands and code snippets in the Phase Implementation Details.\n"
                         "   - Write the entire exhaustive plan into the file using your file-writing tools.\n"
                         "4. General Rules:\n"
                         "   - STRICT FIDELITY: You MUST absolutely respect the languages, frameworks, endpoints, tables, and features mentioned in the user's project files or SDD.\n"

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode/task_manager.py

@@ -93,6 +93,9 @@ class TaskManager:
     def get_task(self, task_id: str) -> Optional[Task]:
         return self.tasks.get(task_id)
 
+    def get_all_tasks(self) -> List[Dict]:
+        return [t.to_dict() for t in self.tasks.values()]
+
     def list_tasks(self) -> str:
         if not self.tasks:
             return "No tasks found."

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode/tools.py

@@ -37,6 +37,14 @@ class ToolRegistry:
                 },
                 "required": ["file_path", "content"]
             },
+            "Append": {
+                "description": "Append content to the end of an existing file. Ideal for building large plans or documents chunk by chunk without hitting token limits.",
+                "parameters": {
+                    "file_path": {"type": "string", "description": "Path to the file."},
+                    "content": {"type": "string", "description": "Content to append to the file. A newline is automatically added."}
+                },
+                "required": ["file_path", "content"]
+            },
             "Replace": {
                 "description": "Edit an existing file by replacing exact strings. Allows multiple non-contiguous edits in one call.",
                 "parameters": {
@@ -227,6 +235,8 @@ class ToolRegistry:
                 return cls._execute_read(args["file_path"], cwd, args.get("offset", 1), args.get("limit", 0))
             elif tool_name == "Write":
                 return cls._execute_write(args["file_path"], args["content"], cwd)
+            elif tool_name == "Append":
+                return cls._execute_append(args["file_path"], args["content"], cwd)
             elif tool_name == "Replace":
                 return cls._execute_replace(args["file_path"], args["replacements"], cwd)
             elif tool_name == "ReplaceBlock":
@@ -296,18 +306,41 @@ class ToolRegistry:
 
     @staticmethod
     def _check_lazy_code(content: str, file_path: str):
-        lazy_patterns = ["// TODO", "# TODO", "// FIXME", "# FIXME", "Insert code here", "pass\n"]
-        for p in lazy_patterns:
+        import re
+        # Broad regex for // TO DO, // TODO, # TODO, // FIXME, etc. with flexible spaces
+        if re.search(r'(?i)(?://|#)\s*(?:to\s*do|fix\s*me)', content):
+            raise ToolError("Validation Error: Lazy code detected (TODO/FIXME). You must provide the full implementation.")
+            
+        # Semantic lazy patterns
+        if re.search(r'(?i)(?:rest of|existing).*?(?:code|file).*?(?:remains|is unchanged|here)', content):
+            raise ToolError("Validation Error: Lazy code detected ('rest of code remains' or similar). Do not skip code.")
+            
+        if re.search(r'(?i)(?:\.\.\.|…)\s*(?:existing|rest of|your)', content):
+            raise ToolError("Validation Error: Lazy code detected ('... existing code' or similar). Do not skip code.")
+            
+        if re.search(r'(?i)(?:logic goes here|implement (?:this|the rest)|your code here|add your logic)', content):
+            raise ToolError("Validation Error: Lazy code detected ('logic goes here' or similar). Do not use placeholders.")
+            
+        if re.search(r'(?i)(?://|#)\s*(?:unchanged|\.\.\.)', content) or re.search(r'(?m)^\s*\.\.\.\s*$', content):
+            raise ToolError("Validation Error: Lazy code detected (ellipsis placeholder '...' or 'unchanged'). You must provide the full implementation.")
+        
+        # Rust/Python stubs
+        stub_patterns = ["todo!()", "unimplemented!()", "Insert code here", "pass\n", "PdfDocument::empty()", "return empty()"]
+        for p in stub_patterns:
             if p in content:
                 raise ToolError(f"Validation Error: Lazy code detected ('{p}'). You must provide the full implementation.")
+                
         if file_path.endswith('.py'):
             import ast
             try:
                 tree = ast.parse(content)
                 for node in ast.walk(tree):
-                    if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
-                        if len(node.body) == 1 and isinstance(node.body[0], ast.Pass):
-                            raise ToolError("Validation Error: Lazy code detected (empty function/class with 'pass'). You must provide the full implementation.")
+                    if isinstance(node, (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef)):
+                        if len(node.body) == 1:
+                            if isinstance(node.body[0], ast.Pass):
+                                raise ToolError("Validation Error: Lazy code detected (empty function/class with 'pass'). You must provide the full implementation.")
+                            elif isinstance(node.body[0], ast.Expr) and isinstance(node.body[0].value, ast.Constant) and node.body[0].value.value is Ellipsis:
+                                raise ToolError("Validation Error: Lazy code detected (empty function/class with '...'). You must provide the full implementation.")
             except SyntaxError:
                 pass
 
@@ -615,6 +648,31 @@ class ToolRegistry:
         diff_str = f"\nDiff:\n{diff}" if diff else ""
         return f"Successfully wrote to {file_path}.{diff_str}"
 
+    @staticmethod
+    def _execute_append(file_path: str, content: str, cwd: str) -> str:
+        # Physical Blocker for Lazy Code
+        ToolRegistry._check_lazy_code(content, file_path)
+
+        # Run Secret Scanner
+        try:
+            from .secret_scanner import SecretScanner
+            findings = SecretScanner.scan(content)
+            if findings:
+                raise ToolError(f"SecretScanner blocked write: {len(findings)} secrets detected ({', '.join(findings)})")
+        except ImportError:
+            pass
+
+        full_path = os.path.join(cwd, file_path)
+        os.makedirs(os.path.dirname(os.path.abspath(full_path)) or ".", exist_ok=True)
+
+        ToolRegistry._backup_file(full_path, cwd)
+        with open(full_path, "a", encoding="utf-8") as f:
+            if not content.startswith("\n"):
+                f.write("\n")
+            f.write(content)
+            
+        return f"Successfully appended to {file_path}."
+
     @staticmethod
     def _execute_replace(file_path: str, replacements: list, cwd: str) -> str:
         

{nimcode-0.7.0 → nimcode-0.8.0}/src/nimcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.7.0
+Version: 0.8.0
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent
@@ -157,7 +157,7 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ```json
 {
-    "model": "meta/llama-3.1-70b-instruct",
+    "model": "meta/llama-3.3-70b-instruct",
     "api_base_url": "https://integrate.api.nvidia.com/v1",
     "timeout_command": 1200,
     "timeout_llm": 120,
@@ -175,7 +175,7 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 | Setting | Default | Description |
 |---------|---------|-------------|
-| `model` | `meta/llama-3.1-70b-instruct` | Default LLM model |
+| `model` | `meta/llama-3.3-70b-instruct` | Default LLM model |
 | `api_base_url` | NVIDIA NIM endpoint | Switch to Ollama/vLLM by changing this |
 | `timeout_command` | 1200 | Max seconds for bash commands (0 = infinite) |
 | `timeout_llm` | 120 | Max seconds for LLM API calls (0 = infinite) |
@@ -193,7 +193,24 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ## 📋 Changelog
 
-### v0.5.5 (Latest)
+### v0.8.0 (Latest)
+- 📝 **SDD-Style Planning**: `/plan` mode now forces the LLM to output Software Design Document (SDD) style templates with specific dependency graphs, timelines, and rigorous phase tracking (the "Empty Recursive Goblet" approach).
+- 🧱 **Physical Exit Blockers for Tasks**: If the LLM tries to call `TASK_COMPLETE` but still has pending or in_progress tasks in its `.nimcode/tasks.json` file, it will physically intercept the tool call, throw a `SYSTEM ERROR`, and force the LLM to finish the open tasks.
+- 🛡️ **Ultimate Anti-Lazy Shield**: Expanded AST and regex blockers that catch semantic laziness (e.g., `"// rest of the code remains unchanged"`, `"logic goes here"`, or using `...` / Ellipsis in Python). A zero-tolerance policy that forces the LLM to rewrite incomplete code.
+- 🧩 **Chunked Generation (Append Tool)**: A new `Append` tool allows the LLM to write massive documents and code files in chunks over multiple turns without hitting context token limits, directly curing "Lazy Coder Syndrome".
+- 🧪 **205 tests passing**
+
+### v0.7.0
+- 🛡️ **Strict Markdown Validator**: `/plan` mode now physically blocks tasks that are under 150 characters or missing required Markdown headers (`Target Files`, `Implementation Details`, `Checklist`).
+- 🧠 **Context Amnesia Shield (AST Diff)**: When modifying Python files, the `ReplaceBlock` tool compares the Abstract Syntax Tree (AST) before and after. If the LLM accidentally deletes over 30% or 2+ top-level functions (truncation hallucination), it instantly blocks the write and forces a fix.
+- 🔗 **Task Linearity Guard**: `TaskManager` enforces strict order. The agent cannot start Task 1.2 until Task 1.1 is fully completed.
+
+### v0.6.0
+- 🛡️ **Anti-Laziness AST Blockers**: Native AST checking explicitly intercepts `pass` blocks, empty classes, and lazy placeholder comments (like `// TODO`), forcing the LLM to write full implementations.
+- 🕵️ **Adversarial QA Gate**: Built a multi-agent validation layer (`qa_agent.py`) that strictly critiques the main agent's work. The main agent cannot complete tasks without receiving a `VERDICT: PASS` from the QA Agent.
+- 💾 **Task State Machine**: Replaced in-memory lists with `.nimcode/tasks.json` persistent storage via `TaskManager`, allowing robust restartability and task state tracking (`pending`, `in_progress`, `completed`).
+
+### v0.5.5
 - 🐛 **UI Bug Fix**: Fixed a visual bug where the CLI welcome banner hardcoded `NimCode v0.2.0` despite the user having updated to a newer version.
 
 ### v0.5.4

{nimcode-0.7.0 → nimcode-0.8.0}/tests/test_agent.py

@@ -7,7 +7,8 @@ import json
 
 @pytest.fixture
 def agent():
-    return Agent(api_key="test_key", max_turns=3, permission_mode=PermissionMode.BYPASS)
+    with patch("nimcode.task_manager.TaskManager.get_all_tasks", return_value=[]):
+        yield Agent(api_key="test_key", max_turns=3, permission_mode=PermissionMode.BYPASS)
 
 def test_agent_init(agent):
     assert agent.client.api_key == "test_key"

{nimcode-0.7.0 → nimcode-0.8.0}/tests/test_config.py

@@ -7,7 +7,7 @@ from nimcode.config import load_settings, save_global_setting
 def test_load_settings_default():
     with patch("os.path.exists", return_value=False):
         settings = load_settings()
-        assert settings["model"] == "meta/llama-3.1-70b-instruct"
+        assert settings["model"] == "meta/llama-3.3-70b-instruct"
         assert settings["mcp_servers"] == {}
         # New configurable settings
         assert settings["max_turns"] == 200
@@ -74,4 +74,4 @@ def test_load_settings_error_handling():
     with patch("os.path.exists", return_value=True):
         with patch("builtins.open", side_effect=Exception("Read error")):
             settings = load_settings()
-            assert settings["model"] == "meta/llama-3.1-70b-instruct"
+            assert settings["model"] == "meta/llama-3.3-70b-instruct"

{nimcode-0.7.0 → nimcode-0.8.0}/tests/test_lazy_blockers.py

@@ -79,3 +79,34 @@ def test_strict_markdown_validator():
     out = ToolRegistry.execute({"tool": "TaskCreate", "args": {"task_id": "test_valid", "subject": "S", "description": valid_desc}}, cwd=".")
     assert "Validation Error" not in out
 
+def test_ast_blocker_rejects_ellipsis():
+    content = "def test():\n    ...\n"
+    try:
+        ToolRegistry._check_lazy_code(content, "dummy.py")
+        pytest.fail("Failed to block Ellipsis")
+    except Exception as e:
+        assert "Lazy code detected" in str(e)
+
+def test_regex_blocker_rejects_rest_of_code():
+    content = "def test():\n    print('test')\n# rest of the code remains unchanged\n"
+    try:
+        ToolRegistry._check_lazy_code(content, "dummy.py")
+        pytest.fail("Failed to block 'rest of the code'")
+    except Exception as e:
+        assert "Lazy code detected" in str(e)
+
+def test_regex_blocker_rejects_ellipsis_comment():
+    content = "def test():\n    print('test')\n# ...\n"
+    try:
+        ToolRegistry._check_lazy_code(content, "dummy.py")
+        pytest.fail("Failed to block '# ...'")
+    except Exception as e:
+        assert "Lazy code detected" in str(e)
+        
+def test_regex_blocker_rejects_logic_goes_here():
+    content = "def test():\n    # logic goes here\n"
+    try:
+        ToolRegistry._check_lazy_code(content, "dummy.py")
+        pytest.fail("Failed to block 'logic goes here'")
+    except Exception as e:
+        assert "Lazy code detected" in str(e)

{nimcode-0.7.0 → nimcode-0.8.0}/tests/test_model_registry.py

@@ -10,7 +10,7 @@ from nimcode.model_registry import (
 
 def test_get_context_window_known_model():
     """Known models should return their specific context window size."""
-    assert get_context_window("meta/llama-3.1-70b-instruct") == 128000
+    assert get_context_window("meta/llama-3.3-70b-instruct") == 128000
     assert get_context_window("nvidia/nemotron-4-340b-instruct") == 4096
     assert get_context_window("mistralai/mixtral-8x22b-instruct-v0.1") == 65536
 

{nimcode-0.7.0 → nimcode-0.8.0}/tests/test_qa_agent.py

@@ -4,7 +4,8 @@ from unittest.mock import patch
 from nimcode.agents.qa_agent import QAAgent
 
 @patch("nimcode.nim_client.NimClient.chat")
-def test_qa_agent_verdict_pass(mock_chat):
+@patch("nimcode.task_manager.TaskManager.get_all_tasks", return_value=[])
+def test_qa_agent_verdict_pass(mock_get_tasks, mock_chat):
     # Mocking the async chat function
     async def mock_chat_return(*args, **kwargs):
         return "I have tested the code. VERDICT: PASS"
@@ -18,7 +19,8 @@ def test_qa_agent_verdict_pass(mock_chat):
         assert "QA Agent VERDICT: PASS" in result
 
 @patch("nimcode.nim_client.NimClient.chat")
-def test_qa_agent_verdict_fail(mock_chat):
+@patch("nimcode.task_manager.TaskManager.get_all_tasks", return_value=[])
+def test_qa_agent_verdict_fail(mock_get_tasks, mock_chat):
     async def mock_chat_return(*args, **kwargs):
         return "The test failed. VERDICT: FAIL"
     mock_chat.side_effect = mock_chat_return

{nimcode-0.7.0 → nimcode-0.8.0}/tests/test_repl.py

@@ -6,8 +6,9 @@ from nimcode.agent import Agent
 
 @pytest.fixture
 def agent():
-    with patch("nimcode.agent.NimClient") as mock_client:
-        a = Agent(api_key="test_key")
+    with patch("nimcode.task_manager.TaskManager.get_all_tasks", return_value=[]):
+        with patch("nimcode.agent.NimClient") as mock_client:
+            a = Agent(api_key="test_key")
         # Ensure we have a mock for chat_one_shot and chat
         a.client.chat_one_shot = AsyncMock(return_value="I am done. TASK_COMPLETE")
         a.client.get_available_models = AsyncMock(return_value=["model1", "model2"])
@@ -16,7 +17,7 @@ def agent():
             yield "Hello"
             yield " World"
         a.client.chat = MagicMock(side_effect=lambda *args, **kwargs: mock_chat_generator(*args, **kwargs))
-        return a
+        yield a
 
 def test_save_load_history(agent):
     agent.messages = [{"role": "user", "content": "hello"}]
@@ -47,7 +48,8 @@ def test_load_history_error(agent):
                 mock_log.assert_called_once()
 
 @pytest.mark.asyncio
-async def test_run_complete(agent):
+@patch("nimcode.task_manager.TaskManager.get_all_tasks", return_value=[])
+async def test_run_complete(mock_get_tasks, agent):
     agent.mcp = MagicMock()
     agent.mcp.connect_all = AsyncMock()
     

{nimcode-0.7.0 → nimcode-0.8.0}/tests/test_tools.py

@@ -41,6 +41,19 @@ def test_execute_read_write(tmp_path):
     res_r = ToolRegistry.execute({"tool": "Read", "args": {"file_path": "test.txt"}}, cwd)
     assert res_r == "Hello World"
 
+def test_execute_append(tmp_path):
+    cwd = str(tmp_path)
+    # Write initial content
+    ToolRegistry.execute({"tool": "Write", "args": {"file_path": "test.txt", "content": "Hello"}}, cwd)
+    
+    # Append content
+    res_a = ToolRegistry.execute({"tool": "Append", "args": {"file_path": "test.txt", "content": " World"}}, cwd)
+    assert "Successfully" in res_a
+    
+    # Read and verify
+    res_r = ToolRegistry.execute({"tool": "Read", "args": {"file_path": "test.txt"}}, cwd)
+    assert res_r == "Hello\n World"
+
 def test_execute_replace_success(tmp_path):
     cwd = str(tmp_path)
     file_path = os.path.join(cwd, "test.txt")

nimcode-0.7.0/src/nimcode/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.7.0"