nimcode 0.8.3__tar.gz → 0.8.6__tar.gz

{nimcode-0.8.3 → nimcode-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.8.3
+Version: 0.8.6
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent
@@ -193,12 +193,14 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ## 📋 Changelog
 
-### 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.8.6 (Latest)
+- 🚀 **Default Model Bump**: Made `deepseek-ai/deepseek-v4-pro` the default model across the entire agent for superior reasoning and tool performance.
+
+### v0.8.4
+- 🧠 **Native DeepSeek XML Support**: Re-engineered the internal parser (`lenient_parser.py`) into a hybrid parser that seamlessly handles both strict JSON (`<tool_call>`) and fine-tuned XML formats (`<tool_call name=\"...\">`). DeepSeek V4 Pro, Mistral Large 2, and others now work flawlessly out of the box!
+- 🧪 **224 tests passing**
+
+### v0.8.0
 
 ### 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`).

{nimcode-0.8.3 → nimcode-0.8.6}/README.md

@@ -172,12 +172,14 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ## 📋 Changelog
 
-### 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.8.6 (Latest)
+- 🚀 **Default Model Bump**: Made `deepseek-ai/deepseek-v4-pro` the default model across the entire agent for superior reasoning and tool performance.
+
+### v0.8.4
+- 🧠 **Native DeepSeek XML Support**: Re-engineered the internal parser (`lenient_parser.py`) into a hybrid parser that seamlessly handles both strict JSON (`<tool_call>`) and fine-tuned XML formats (`<tool_call name=\"...\">`). DeepSeek V4 Pro, Mistral Large 2, and others now work flawlessly out of the box!
+- 🧪 **224 tests passing**
+
+### v0.8.0
 
 ### 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`).

nimcode-0.8.6/src/nimcode/__version__.py

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

{nimcode-0.8.3 → nimcode-0.8.6}/src/nimcode/agent.py

@@ -188,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.3-70b-instruct")
+        self.model = model or self.settings.get("model", "deepseek-ai/deepseek-v4-pro")
         api_base_url = self.settings.get("api_base_url", "https://integrate.api.nvidia.com/v1")
         self.client = NimClient(
             api_key=api_key, 
@@ -373,7 +373,7 @@ class Agent:
                         else:
                             display_text = parts[0]
                             
-                    tool_tag_idx = display_text.find("<tool_call>")
+                    tool_tag_idx = display_text.find("<tool_call")
                     if tool_tag_idx != -1:
                         display_text = display_text[:tool_tag_idx] + "\n\n*[dim]⚙️ Preparing tool execution...[/dim]*"
                         

{nimcode-0.8.3 → nimcode-0.8.6}/src/nimcode/agents/qa_agent.py

@@ -19,7 +19,7 @@ class QAAgent:
         import json
         settings_path = os.path.join(self.cwd, ".nimcode", "settings.json")
         api_key = os.environ.get("NVIDIA_API_KEY")
-        model = "meta/llama-3.3-70b-instruct"
+        model = "deepseek-ai/deepseek-v4-pro"
         if os.path.exists(settings_path):
             try:
                 with open(settings_path, "r") as f:

{nimcode-0.8.3 → nimcode-0.8.6}/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.3-70b-instruct", help="Model ID to use from NIM.")
+    parser.add_argument("--model", "-m", default="deepseek-ai/deepseek-v4-pro", 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.8.3 → nimcode-0.8.6}/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.3-70b-instruct",
+        "model": "deepseek-ai/deepseek-v4-pro",
         "api_base_url": "https://integrate.api.nvidia.com/v1",
         "mcp_servers": {},
         # Timeouts (0 = disabled/infinite)

{nimcode-0.8.3 → nimcode-0.8.6}/src/nimcode/lenient_parser.py

@@ -7,17 +7,22 @@ logger = logging.getLogger(__name__)
 
 class LenientParser:
     @staticmethod
-    def extract_tool_calls(text: str) -> List[str]:
-        """Extracts JSON strings from <tool_call> fenced blocks."""
-        # The model might forget the closing tag, or put markdown fences around it.
-        # We look for <tool_call> and extract everything until </tool_call> or EOF.
-        pattern = re.compile(r"<tool_call>\s*(.*?)(?:</tool_call>|\Z)", re.DOTALL | re.IGNORECASE)
+    def extract_tool_calls(text: str) -> List[Tuple[str, str]]:
+        """Extracts tool names and JSON strings from <tool_call> fenced blocks."""
+        # We look for <tool_call> or <tool_call name="..."> and extract everything until </tool_call> or EOF.
+        pattern = re.compile(r"<tool_call([^>]*)>\s*(.*?)(?:</tool_call>|\Z)", re.DOTALL | re.IGNORECASE)
         matches = pattern.findall(text)
         
         # Clean up markdown code blocks if the model wrapped the JSON in them
         cleaned_matches = []
-        for match in matches:
-            match = match.strip()
+        for attr_str, inner_text in matches:
+            # Parse name from attributes if it exists (e.g., name="Read")
+            name = ""
+            name_match = re.search(r'name=["\'](.*?)["\']', attr_str, re.IGNORECASE)
+            if name_match:
+                name = name_match.group(1).strip()
+
+            match = inner_text.strip()
             if match.startswith("```json"):
                 match = match[7:]
             elif match.startswith("```"):
@@ -26,7 +31,7 @@ class LenientParser:
             if match.endswith("```"):
                 match = match[:-3]
                 
-            cleaned_matches.append(match.strip())
+            cleaned_matches.append((name, match.strip()))
             
         return cleaned_matches
 
@@ -86,14 +91,19 @@ class LenientParser:
         Returns (plain_text_message, list_of_tool_calls).
         """
         # First, extract the tool calls
-        tool_call_strings = cls.extract_tool_calls(text)
+        tool_call_tuples = cls.extract_tool_calls(text)
         
         tool_calls = []
-        for tc_str in tool_call_strings:
+        for name, tc_str in tool_call_tuples:
             if not tc_str:
                 continue
             try:
-                tc = cls.parse_tool_call(tc_str)
+                tc_json = cls.parse_tool_call(tc_str)
+                # If model used <tool_call name="..."> and provided raw arguments in JSON
+                if isinstance(tc_json, dict) and "tool" not in tc_json and name:
+                    tc = {"tool": name, "args": tc_json}
+                else:
+                    tc = tc_json
                 tool_calls.append(tc)
             except ValueError:
                 # We could append an error message or raise. We'll raise to let the agent loop handle it and re-prompt.
@@ -101,7 +111,7 @@ class LenientParser:
                 
         # The plain text is whatever is not in the tool_call blocks.
         # We remove the tool call blocks from the original text to get the assistant's prose.
-        plain_text = re.sub(r"<tool_call>\s*(.*?)(?:</tool_call>|\Z)", "", text, flags=re.DOTALL | re.IGNORECASE)
+        plain_text = re.sub(r"<tool_call[^>]*>\s*(.*?)(?:</tool_call>|\Z)", "", text, flags=re.DOTALL | re.IGNORECASE)
         plain_text = plain_text.strip()
         
         return plain_text, tool_calls

{nimcode-0.8.3 → nimcode-0.8.6}/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.3-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 = "deepseek-ai/deepseek-v4-pro", 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.8.3 → nimcode-0.8.6}/src/nimcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.8.3
+Version: 0.8.6
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent
@@ -193,12 +193,14 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ## 📋 Changelog
 
-### 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.8.6 (Latest)
+- 🚀 **Default Model Bump**: Made `deepseek-ai/deepseek-v4-pro` the default model across the entire agent for superior reasoning and tool performance.
+
+### v0.8.4
+- 🧠 **Native DeepSeek XML Support**: Re-engineered the internal parser (`lenient_parser.py`) into a hybrid parser that seamlessly handles both strict JSON (`<tool_call>`) and fine-tuned XML formats (`<tool_call name=\"...\">`). DeepSeek V4 Pro, Mistral Large 2, and others now work flawlessly out of the box!
+- 🧪 **224 tests passing**
+
+### v0.8.0
 
 ### 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`).

{nimcode-0.8.3 → nimcode-0.8.6}/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.3-70b-instruct"
+        assert settings["model"] == "deepseek-ai/deepseek-v4-pro"
         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.3-70b-instruct"
+            assert settings["model"] == "deepseek-ai/deepseek-v4-pro"

{nimcode-0.8.3 → nimcode-0.8.6}/tests/test_lenient_parser.py

@@ -5,7 +5,7 @@ def test_extract_tool_calls_clean():
     text = "Here is my tool call:\n<tool_call>\n{\"tool\": \"Read\", \"args\": {}}\n</tool_call>\nAnd some prose."
     calls = LenientParser.extract_tool_calls(text)
     assert len(calls) == 1
-    assert calls[0] == "{\"tool\": \"Read\", \"args\": {}}"
+    assert calls[0] == ("", "{\"tool\": \"Read\", \"args\": {}}")
 
 def test_repair_truncated_json():
     # Test unclosed quote
@@ -19,19 +19,19 @@ def test_extract_tool_calls_unclosed():
     text = "Here is my tool call:\n<tool_call>\n{\"tool\": \"Read\"}"
     calls = LenientParser.extract_tool_calls(text)
     assert len(calls) == 1
-    assert calls[0] == "{\"tool\": \"Read\"}"
+    assert calls[0] == ("", "{\"tool\": \"Read\"}")
 
 def test_extract_tool_calls_markdown_wrapped():
     text = "<tool_call>\n```json\n{\"tool\": \"Read\"}\n```\n</tool_call>"
     calls = LenientParser.extract_tool_calls(text)
     assert len(calls) == 1
-    assert calls[0] == "{\"tool\": \"Read\"}"
+    assert calls[0] == ("", "{\"tool\": \"Read\"}")
 
 def test_extract_tool_calls_markdown_wrapped_no_lang():
     text = "<tool_call>\n```\n{\"tool\": \"Read\"}\n```\n</tool_call>"
     calls = LenientParser.extract_tool_calls(text)
     assert len(calls) == 1
-    assert calls[0] == "{\"tool\": \"Read\"}"
+    assert calls[0] == ("", "{\"tool\": \"Read\"}")
 
 def test_repair_trailing_comma():
     bad_json = '{"tool": "Read", "args": {"file": "a.txt",},}'
@@ -65,3 +65,18 @@ def test_process_model_response_raises_on_invalid():
     text = "<tool_call>\n{invalid}\n</tool_call>"
     with pytest.raises(ValueError, match="Malformed tool call JSON"):
         LenientParser.process_model_response(text)
+
+def test_extract_tool_calls_with_name_attr():
+    text = "Here is DeepSeek output:\n<tool_call name=\"Read\">\n{\"file_path\": \"a.txt\"}\n</tool_call>"
+    calls = LenientParser.extract_tool_calls(text)
+    assert len(calls) == 1
+    assert calls[0] == ("Read", "{\"file_path\": \"a.txt\"}")
+
+def test_process_model_response_deepseek_format():
+    text = "Thinking... <tool_call name=\"Write\">\n{\"file_path\": \"a.txt\", \"content\": \"hello\"}\n</tool_call>"
+    prose, calls = LenientParser.process_model_response(text)
+    assert prose == "Thinking..."
+    assert len(calls) == 1
+    assert calls[0]["tool"] == "Write"
+    assert calls[0]["args"]["file_path"] == "a.txt"
+    assert calls[0]["args"]["content"] == "hello"

nimcode-0.8.3/src/nimcode/__version__.py

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