nimcode 0.4.10__tar.gz → 0.5.0__tar.gz

{nimcode-0.4.10 → nimcode-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.4.10
+Version: 0.5.0
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent

nimcode-0.5.0/src/nimcode/__version__.py

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

{nimcode-0.4.10 → nimcode-0.5.0}/src/nimcode/agent.py

@@ -32,7 +32,8 @@ 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"}}}}
-- Edit: {{"tool": "Edit", "args": {{"file_path": "string", "old_string": "string", "new_string": "string"}}}}
+- 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"}}}}
 - Grep: {{"tool": "Grep", "args": {{"query": "string", "directory": "string"}}}}
 - AskQuestion: {{"tool": "AskQuestion", "args": {{"question": "string", "options": ["string (optional list of choices)"]}}}} — Ask the USER a clarifying question when requirements are ambiguous. Wait for their reply before continuing. Preferred in /grill-me, /plan, and whenever you lack information.
@@ -78,6 +79,11 @@ When asked to "execute", "implement", or "build" something:
 3. Install dependencies, run tests, and verify your work.
 4. If a plan exists in `.nimcode/plans/`, follow it step by step.
 
+ANTI-LAZINESS POLICY (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.
+
 When you have completely fulfilled the user's request and have no more tools to run, output the word TASK_COMPLETE.
 """
 
@@ -134,6 +140,9 @@ class Agent:
         # Initialize MCP Manager
         self.mcp = MCPManager(self.settings)
         
+        # Stuck-Loop Breaker State
+        self.tool_error_counts = {}
+        
         # Build OS-aware system prompt
         cwd = os.getcwd()
         final_prompt = _build_system_prompt(cwd) + self.mcp.get_system_prompt_additions()
@@ -171,6 +180,31 @@ class Agent:
             except Exception as e:
                 logger.error(f"Failed to load git context: {e}")
 
+        # Context Injection (Anti-Amnesia RAG)
+        try:
+            # 1. Directory Tree
+            tree_output = ToolRegistry._execute_read_architecture(".", cwd)
+            if len(tree_output) > 2000:
+                tree_output = tree_output[:2000] + "\n... [TRUNCATED]"
+            final_prompt += f"\n\nPROJECT DIRECTORY STRUCTURE:\n{tree_output}"
+            
+            # 2. Schema Injection
+            schema_files = ["schema.sql", "models.py", "prisma/schema.prisma", "db.py"]
+            schema_contents = []
+            for sf in schema_files:
+                sf_path = os.path.join(cwd, sf)
+                if os.path.exists(sf_path):
+                    with open(sf_path, "r", encoding="utf-8") as f:
+                        content = f.read()
+                        if len(content) > 3000:
+                            content = content[:3000] + "\n... [TRUNCATED]"
+                        schema_contents.append(f"--- {sf} ---\n{content}")
+                        
+            if schema_contents:
+                final_prompt += "\n\nCRITICAL DATABASE SCHEMAS:\n" + "\n".join(schema_contents)
+        except Exception as e:
+            logger.error(f"Failed to inject semantic context: {e}")
+
         self.messages: List[Dict[str, Any]] = [
             {"role": "system", "content": final_prompt}
         ]
@@ -378,6 +412,13 @@ class Agent:
             turn += 1
             logger.info(f"--- Turn {turn} ---")
             
+            # Plan-Drift Radar
+            if turn > 0 and turn % 15 == 0:
+                self.messages.append({
+                    "role": "user",
+                    "content": "🧭 PLAN RADAR: You have been running for 15 turns. Please read '.nimcode/active_plan.txt' (if it exists) and verify you are strictly following the current phase. If you have drifted, return to the main objective immediately."
+                })
+            
             # Compact context before calling API
             from rich.console import Console
             if self.memory.count_messages_tokens(self.messages) > self.memory.max_tokens:
@@ -396,6 +437,25 @@ class Agent:
             
             self.messages.append({"role": "assistant", "content": full_content})
             
+            # Anti-Laziness Interceptor
+            import re
+            lazy_patterns = [r"//\s*TODO", r"#\s*TODO", r"\$\(cat", r"\[Insert", r"\[Your code", r"pass\s*#"]
+            lazy_detected = False
+            for pat in lazy_patterns:
+                if re.search(pat, full_content, re.IGNORECASE):
+                    lazy_detected = True
+                    break
+                    
+            if lazy_detected:
+                logger.warning("Agent attempted to use placeholder code. Rejecting turn.")
+                from rich.console import Console
+                Console().print("[bold red]🚨 ANTI-LAZINESS SYSTEM TRIGGERED! Agent tried to use placeholders. Forcing retry.[/bold red]")
+                self.messages.append({
+                    "role": "user",
+                    "content": "ERROR: You violated the ANTI-LAZINESS POLICY by using placeholders, TODOs, or mock strings. You must write the REAL, COMPLETE logic. Re-do this action properly."
+                })
+                continue
+            
             # Log turn to NIMCODE.md
             try:
                 # We log the user's latest prompt, or the tool output
@@ -450,7 +510,7 @@ class Agent:
                             result = ToolRegistry.execute(tool_call)
                             
                         # Auto-Linting & Diff Printing
-                        if tool_name in ["Write", "Edit"] and "Error" not in result:
+                        if tool_name in ["Write", "Edit", "Replace", "ReplaceBlock"] and "Error" not in result:
                             if "Diff:\n" in result:
                                 parts = result.split("Diff:\n", 1)
                                 diff_text = parts[1]
@@ -485,6 +545,22 @@ class Agent:
                                     t_fmt = self.settings.get("timeout_format", 10)
                                     t_fmt = None if t_fmt == 0 else t_fmt
                                     subprocess.run(["npx", "--yes", "prettier", "--write", file_path], capture_output=True, timeout=t_fmt)
+                                    # Basic syntax check for JS
+                                    if file_path.endswith(".js"):
+                                        lint = subprocess.run(["node", "--check", file_path], capture_output=True, text=True, timeout=t_fmt)
+                                        if lint.returncode != 0:
+                                            result += f"\n\nAuto-Linter found errors:\n{lint.stderr}\nPlease fix them."
+                                except Exception:
+                                    pass
+                            elif file_path.endswith(".go"):
+                                import subprocess
+                                try:
+                                    t_fmt = self.settings.get("timeout_format", 10)
+                                    t_fmt = None if t_fmt == 0 else t_fmt
+                                    subprocess.run(["go", "fmt", file_path], capture_output=True, timeout=t_fmt)
+                                    lint = subprocess.run(["go", "vet", file_path], capture_output=True, text=True, timeout=t_fmt)
+                                    if lint.returncode != 0:
+                                        result += f"\n\nAuto-Linter found errors:\n{lint.stderr}\nPlease fix them."
                                 except Exception:
                                     pass
                 except KeyboardInterrupt:
@@ -530,13 +606,33 @@ class Agent:
                     from rich.panel import Panel
                     c.print(Panel(preview, title=f"Output: {tool_name}", border_style="dim", padding=(0, 1)))
 
-                # We simulate tool messages by adding a user message with the tool result.
-                # In native mode this would be a "tool" role message, but for fallback mode, 
-                # passing it as a user message makes it explicit.
-                self.messages.append({
-                    "role": "user", 
-                    "content": f"Tool {tool_name} returned:\n{result}"
-                })
+                # Stuck-Loop Breaker
+                is_error = False
+                if isinstance(result, str) and ("Error" in result or "Auto-Linter found errors:" in result or "Traceback" in result):
+                    is_error = True
+                    
+                if is_error:
+                    error_hash = hash(tool_name + str(result)[:200])
+                    self.tool_error_counts[error_hash] = self.tool_error_counts.get(error_hash, 0) + 1
+                    
+                    if self.tool_error_counts[error_hash] >= 3:
+                        from rich.console import Console
+                        Console().print("[bold red]🚨 STUCK-LOOP BREAKER TRIGGERED! Forcing agent to change strategy.[/bold red]")
+                        self.messages.append({
+                            "role": "user", 
+                            "content": f"Tool {tool_name} returned:\n{result}\n\n🚨 SYSTEM OVERRIDE: You have triggered this exact error 3 times in a row! DO NOT repeat the same action. Use GetCodeOutline, Read, or grep to understand what is wrong, or ask the user for help."
+                        })
+                        self.tool_error_counts[error_hash] = 0
+                    else:
+                        self.messages.append({
+                            "role": "user", 
+                            "content": f"Tool {tool_name} returned:\n{result}"
+                        })
+                else:
+                    self.messages.append({
+                        "role": "user", 
+                        "content": f"Tool {tool_name} returned:\n{result}"
+                    })
 
             except Exception as e:
                 logger.error(f"Error parsing/executing tool: {e}")

{nimcode-0.4.10 → nimcode-0.5.0}/src/nimcode/repl.py

@@ -450,6 +450,8 @@ class NimcodeREPL:
                         "   - Step C: Repeat Step B for Phase 2, Phase 3, etc., updating the same single file until all phases are fully detailed in Project Manager style.\n"
                         "   - Step D: After all phases are detailed, overwrite '.nimcode/active_plan.txt' with the master plan's path.\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. Do NOT default to Python/Pytest if another language is specified. Do NOT omit database tables. Do NOT generalize specific endpoints into 'REST API'.\n"
+                        "   - BUSINESS LOGIC: Do not ignore 'non-technical' sections like Monetization, ASO, or Affiliate integrations. They MUST be included as explicit tasks.\n"
                         "   - Quote real names, modules, and requirements. Do not invent generic projects.\n"
                         "   - NEVER output a generic software-lifecycle template (Phase1: MVP / Design / Development) unless instructed. Focus on code, DB schemas, and technical choices.\n"
                         "   - After writing any plan file, overwrite '.nimcode/active_plan.txt' with the file's path."

{nimcode-0.4.10 → nimcode-0.5.0}/src/nimcode/tools.py

@@ -56,6 +56,16 @@ class ToolRegistry:
                 },
                 "required": ["file_path", "replacements"]
             },
+            "ReplaceBlock": {
+                "description": "Edit an existing file by replacing a block of lines. Solves whitespace and indentation issues by targeting exact line numbers.",
+                "parameters": {
+                    "file_path": {"type": "string", "description": "Path to the file."},
+                    "start_line": {"type": "integer", "description": "The 1-based starting line number of the block to replace."},
+                    "end_line": {"type": "integer", "description": "The 1-based ending line number of the block to replace (inclusive)."},
+                    "replacement_content": {"type": "string", "description": "The content to insert in place of the specified lines."}
+                },
+                "required": ["file_path", "start_line", "end_line", "replacement_content"]
+            },
             "StartTerminal": {
                 "description": "Start a persistent interactive terminal session. Useful for running long-lived commands or commands that prompt for user input (y/n).",
                 "parameters": {
@@ -133,6 +143,20 @@ class ToolRegistry:
                     }
                 },
                 "required": ["question"]
+            },
+            "GetCodeOutline": {
+                "description": "Get the structural outline (functions, classes) of a code file with line numbers. Use this to quickly navigate large files.",
+                "parameters": {
+                    "file_path": {"type": "string", "description": "Path to the code file."}
+                },
+                "required": ["file_path"]
+            },
+            "TestRunner": {
+                "description": "Run a test suite and capture the output to verify code correctness.",
+                "parameters": {
+                    "command": {"type": "string", "description": "The test command (e.g., 'pytest', 'npm test', 'go test')"}
+                },
+                "required": ["command"]
             }
         }
         return schemas.get(tool_name)
@@ -176,6 +200,8 @@ class ToolRegistry:
                 return cls._execute_write(args["file_path"], args["content"], cwd)
             elif tool_name == "Replace":
                 return cls._execute_replace(args["file_path"], args["replacements"], cwd)
+            elif tool_name == "ReplaceBlock":
+                return cls._execute_replace_block(args["file_path"], args["start_line"], args["end_line"], args["replacement_content"], cwd)
             elif tool_name == "StartTerminal":
                 return cls._execute_start_terminal(args["command"], args["term_id"], cwd)
             elif tool_name == "TerminalInput":
@@ -196,6 +222,10 @@ class ToolRegistry:
                 return cls._execute_read_active_editor(cwd)
             elif tool_name == "AskQuestion":
                 return cls._execute_ask_question(args["question"], args.get("options", []))
+            elif tool_name == "GetCodeOutline":
+                return cls._execute_get_code_outline(args["file_path"], cwd)
+            elif tool_name == "TestRunner":
+                return cls._execute_test_runner(args["command"], cwd)
             else:
                 raise ToolError(f"Tool {tool_name} is registered but execution is not implemented.")
         except Exception as e:
@@ -497,6 +527,46 @@ class ToolRegistry:
             
         return f"Successfully applied {applied} replacements in {file_path}.\nDiff:\n{diff}"
 
+    @staticmethod
+    def _execute_replace_block(file_path: str, start_line: int, end_line: int, replacement_content: str, cwd: str) -> str:
+        full_path = os.path.join(cwd, file_path)
+        if not os.path.exists(full_path):
+            raise ToolError(f"File not found: {file_path}")
+            
+        with open(full_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+            
+        total_lines = len(lines)
+        if start_line < 1 or start_line > total_lines:
+            raise ToolError(f"start_line {start_line} is out of bounds (1-{total_lines}).")
+        if end_line < start_line or end_line > total_lines:
+            raise ToolError(f"end_line {end_line} is out of bounds or less than start_line.")
+            
+        # Run Secret Scanner
+        try:
+            from .secret_scanner import SecretScanner
+            findings = SecretScanner.scan(replacement_content)
+            if findings:
+                raise ToolError(f"SecretScanner blocked replace: {len(findings)} secrets detected ({', '.join(findings)})")
+        except ImportError:
+            pass
+            
+        new_lines_to_insert = replacement_content.splitlines(keepends=True)
+        if new_lines_to_insert and not new_lines_to_insert[-1].endswith('\n'):
+            new_lines_to_insert[-1] += '\n'
+            
+        new_content_lines = lines[:start_line-1] + new_lines_to_insert + lines[end_line:]
+        new_content = "".join(new_content_lines)
+        
+        import difflib
+        diff = "".join(difflib.unified_diff(lines, new_content_lines, fromfile=file_path, tofile=file_path))
+        
+        ToolRegistry._backup_file(full_path, cwd)
+        with open(full_path, "w", encoding="utf-8") as f:
+            f.write(new_content)
+            
+        return f"Successfully replaced lines {start_line}-{end_line} in {file_path}.\nDiff:\n{diff}"
+
     @staticmethod
     def _execute_glob(pattern: str, cwd: str) -> str:
         # We need to support recursive globbing
@@ -802,3 +872,44 @@ class ToolRegistry:
                     pass
                     
         return "Timed out waiting for VS Code extension. Make sure NimCode is running inside VS Code."
+
+    @classmethod
+    def _execute_get_code_outline(cls, file_path: str, cwd: str) -> str:
+        """Extracts class/function signatures with line numbers."""
+        import os, re
+        full_path = os.path.join(cwd, file_path)
+        if not os.path.exists(full_path):
+            return f"Error: File {file_path} not found."
+            
+        try:
+            with open(full_path, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+                
+            outline = []
+            pattern = re.compile(r"^\s*(def |class |function |const \w+\s*=\s*\(|type |func |struct |interface )")
+            for i, line in enumerate(lines):
+                if pattern.search(line):
+                    outline.append(f"Line {i+1}: {line.strip()}")
+                    
+            if not outline:
+                return f"No major structural blocks (functions/classes) found in {file_path} using generic regex."
+            return "\n".join(outline)
+        except Exception as e:
+            return f"Error reading {file_path}: {e}"
+
+    @classmethod
+    def _execute_test_runner(cls, command: str, cwd: str) -> str:
+        """Runs test commands safely and captures output."""
+        import subprocess
+        try:
+            result = subprocess.run(command, shell=True, cwd=cwd, capture_output=True, text=True, timeout=60)
+            output = f"Command: {command}\nExit Code: {result.returncode}\n"
+            if result.stdout:
+                output += f"\nSTDOUT:\n{result.stdout}"
+            if result.stderr:
+                output += f"\nSTDERR:\n{result.stderr}"
+            return output
+        except subprocess.TimeoutExpired:
+            return f"Error: Test command '{command}' timed out after 60 seconds."
+        except Exception as e:
+            return f"Error running tests: {e}"

{nimcode-0.4.10 → nimcode-0.5.0}/src/nimcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.4.10
+Version: 0.5.0
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent

{nimcode-0.4.10 → nimcode-0.5.0}/tests/test_agent.py

@@ -282,8 +282,8 @@ async def test_agent_auto_linting_js(agent):
                 with patch("nimcode.tools.ToolRegistry.execute", return_value="Output"):
                     with patch("subprocess.run") as mock_run:
                         await agent.run("Hi")
-                        assert mock_run.call_count == 1
-                        assert "prettier" in mock_run.call_args[0][0]
+                        assert mock_run.call_count >= 1
+                        assert any("prettier" in call[0][0] for call in mock_run.call_args_list)
 
 @pytest.mark.asyncio
 async def test_distill_memory_context_full(agent):

nimcode-0.4.10/src/nimcode/__version__.py

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