nimcode 0.3.3__tar.gz → 0.4.0__tar.gz

{nimcode-0.3.3 → nimcode-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.3.3
+Version: 0.4.0
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Author: Autonomous Agent
 Requires-Dist: httpx>=0.27.0

{nimcode-0.3.3 → nimcode-0.4.0}/README.md

@@ -121,6 +121,40 @@ NimCode creates a `.nimcode` directory inside your projects. This directory acts
 - `.nimcode/skills/`: Any custom guidelines, framework rules, or memories you teach the agent.
 - `.nimcode/history/`: File backups for `/undo` capabilities.
 
+### Advanced Configuration
+
+NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (global) or `.nimcode/settings.json` (per-project). Setting any timeout to `0` disables it (infinite).
+
+```json
+{
+    "timeout_command": 1200,
+    "timeout_llm": 120,
+    "timeout_format": 10,
+    "timeout_browser": 15000,
+    "timeout_updater": 3,
+    "max_turns": 200,
+    "max_tokens": 120000,
+    "max_retries": 15,
+    "retry_base_delay": 2.0,
+    "retry_max_delay": 60.0,
+    "allow_bash_non_interactive": false
+}
+```
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `timeout_command` | 1200 | Max seconds for bash commands (0 = infinite) |
+| `timeout_llm` | 120 | Max seconds for LLM API calls (0 = infinite) |
+| `timeout_format` | 10 | Max seconds for formatters like black/prettier |
+| `timeout_browser` | 15000 | Max ms for browser actions |
+| `timeout_updater` | 3 | Max seconds for update checks |
+| `max_turns` | 200 | Max agent turns per session (0 = unlimited) |
+| `max_tokens` | 120000 | Token budget before auto-compact |
+| `max_retries` | 15 | Max API retry attempts on transient errors |
+| `retry_base_delay` | 2.0 | Base delay for exponential backoff (seconds) |
+| `retry_max_delay` | 60.0 | Max delay cap for backoff (seconds) |
+| `allow_bash_non_interactive` | false | Allow Bash commands in non-interactive/CI mode |
+
 ## 🛡️ Requirements
 
 - Python 3.8+

{nimcode-0.3.3 → nimcode-0.4.0}/setup.py

@@ -1,8 +1,14 @@
 from setuptools import setup, find_packages
+import os
+
+# Single source of truth for version
+version = {}
+with open(os.path.join("src", "nimcode", "__version__.py")) as f:
+    exec(f.read(), version)
 
 setup(
     name="nimcode",
-    version="0.3.3",
+    version=version["__version__"],
     packages=find_packages(where="src"),
     package_dir={"": "src"},
     install_requires=[

nimcode-0.4.0/src/nimcode/__version__.py

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

{nimcode-0.3.3 → nimcode-0.4.0}/src/nimcode/agent.py

@@ -11,8 +11,13 @@ from .memory import MemoryManager
 
 logger = logging.getLogger(__name__)
 
-SYSTEM_PROMPT = """You are nimcode, an autonomous AI coding assistant.
-You have access to a set of tools to read, write, and execute code.
+import platform
+
+SYSTEM_PROMPT_TEMPLATE = """You are nimcode, an autonomous AI coding assistant. You are a senior-level developer who writes production-ready code.
+
+OPERATING SYSTEM: {os_name}
+SHELL: {shell_info}
+WORKING DIRECTORY: {cwd}
 
 CRITICAL INSTRUCTION FOR TOOL CALLING:
 You must output exactly ONE tool call per turn, formatted exactly as a fenced XML block.
@@ -20,49 +25,120 @@ DO NOT use Markdown code blocks for the tool call. DO NOT output multiple tool c
 
 Format:
 <tool_call>
-{"tool": "ToolName", "args": {"arg1": "val1"}}
+{{"tool": "ToolName", "args": {{"arg1": "val1"}}}}
 </tool_call>
 
 Available Tools:
-- Bash: {"tool": "Bash", "args": {"command": "string"}}
-- Read: {"tool": "Read", "args": {"file_path": "string"}}
-- Write: {"tool": "Write", "args": {"file_path": "string", "content": "string"}}
-- Edit: {"tool": "Edit", "args": {"file_path": "string", "old_string": "string", "new_string": "string"}}
-- Glob: {"tool": "Glob", "args": {"pattern": "string"}}
-- Grep: {"tool": "Grep", "args": {"query": "string", "directory": "string"}}
-
-Before calling a tool, you may optionally use a <think> block to reason about your plan. This helps you execute complex tasks correctly.
-For example:
+- Bash: {{"tool": "Bash", "args": {{"command": "string"}}}}
+- Read: {{"tool": "Read", "args": {{"file_path": "string"}}}}
+- Write: {{"tool": "Write", "args": {{"file_path": "string", "content": "string"}}}}
+- Edit: {{"tool": "Edit", "args": {{"file_path": "string", "old_string": "string", "new_string": "string"}}}}
+- Glob: {{"tool": "Glob", "args": {{"pattern": "string"}}}}
+- Grep: {{"tool": "Grep", "args": {{"query": "string", "directory": "string"}}}}
+
+Before calling a tool, you may optionally use a <think> block to reason about your plan.
 <think>
 I need to check the file contents first to see where the function is defined.
 </think>
 <tool_call>
-{"tool": "Read", "args": {"file_path": "main.py"}}
+{{"tool": "Read", "args": {{"file_path": "main.py"}}}}
 </tool_call>
 
-Workspace Guidelines:
-- When creating plans, store them inside the `.nimcode/plans/` directory (e.g., `.nimcode/plans/dino_game_plan.md`). Create this directory if it doesn't exist.
-- When creating or learning new skills/memories, store them as markdown files inside the `.nimcode/skills/` directory.
+WORKSPACE STRUCTURE:
+- The `.nimcode/` directory is YOUR workspace for plans, skills, and logs. It is NOT where user project code lives.
+  - `.nimcode/plans/` — Store step-by-step markdown plans here.
+  - `.nimcode/skills/` — Store custom guidelines, framework rules, or memories as markdown files.
+  - `.nimcode/history/` — File backups for /undo capabilities.
+- User's project code lives in the WORKING DIRECTORY root and its subdirectories.
+- NEVER write user's source code files inside `.nimcode/`. That directory is only for your internal data.
+- When the user asks you to create a file like `main.py`, `app.js`, etc., write it to the WORKING DIRECTORY, not `.nimcode/`.
+
+{os_specific_instructions}
+
+PLANNING MODE INSTRUCTIONS:
+When in /plan mode or asked to create a plan:
+1. FIRST: Read the project structure using Glob and Read tools. Understand what already exists.
+2. SECOND: Analyze the codebase — read key files, understand the architecture, dependencies, and patterns.
+3. THIRD: Write a DETAILED, ACTIONABLE plan that references actual files and code in the project.
+4. Your plan must include:
+   - Specific files to create/modify (with full paths)
+   - Actual code snippets or pseudocode for each change
+   - Dependencies to install
+   - Testing strategy
+   - Step-by-step execution order
+5. NEVER write generic project management templates (stakeholders, timelines, resources).
+6. NEVER use placeholders like [Insert Date] or [Insert Dependencies].
+7. A good plan is one that another developer could follow to implement the feature without asking questions.
+
+CODE EXECUTION INSTRUCTIONS:
+When asked to "execute", "implement", or "build" something:
+1. Write REAL, WORKING code — not echo statements or placeholder scripts.
+2. Create actual source files with production-quality code.
+3. Install dependencies, run tests, and verify your work.
+4. If a plan exists in `.nimcode/plans/`, follow it step by step.
 
 When you have completely fulfilled the user's request and have no more tools to run, output the word TASK_COMPLETE.
 """
 
+OS_INSTRUCTIONS_WINDOWS = """WINDOWS-SPECIFIC RULES:
+- Use backslash (\\) for file paths in Bash commands, or use forward slash (/) which also works on Windows.
+- Use PowerShell or cmd syntax: `mkdir .nimcode\\plans` (NOT `mkdir -p .nimcode/plans`).
+- Use `type` instead of `cat`, `dir` instead of `ls`, `copy` instead of `cp`.
+- Use `python` instead of `python3`.
+- For creating nested directories, use: `mkdir .nimcode\\plans 2>nul` or `New-Item -ItemType Directory -Force -Path .nimcode\\plans`
+- DO NOT use Unix-only commands like chmod, grep (use findstr), sed, awk.
+"""
+
+OS_INSTRUCTIONS_UNIX = """UNIX-SPECIFIC RULES:
+- Use forward slash (/) for file paths.
+- Use standard Unix commands: mkdir -p, cat, ls, cp, chmod.
+- Use `python3` if `python` is not available.
+"""
+
+
+def _build_system_prompt(cwd: str) -> str:
+    """Builds the system prompt with OS-aware instructions."""
+    os_name = platform.system()
+    if os_name == "Windows":
+        shell_info = "PowerShell / cmd.exe"
+        os_specific = OS_INSTRUCTIONS_WINDOWS
+    else:
+        shell_info = "bash / zsh"
+        os_specific = OS_INSTRUCTIONS_UNIX
+
+    return SYSTEM_PROMPT_TEMPLATE.format(
+        os_name=os_name,
+        shell_info=shell_info,
+        cwd=cwd,
+        os_specific_instructions=os_specific,
+    )
+
+
 class Agent:
-    def __init__(self, api_key: str, model: str = None, max_turns: int = 30, permission_mode: PermissionMode = PermissionMode.DEFAULT, max_tokens: int = 4000):
+    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")
         api_base_url = self.settings.get("api_base_url", "https://integrate.api.nvidia.com/v1")
-        self.client = NimClient(api_key=api_key, base_url=api_base_url, model=self.model)
+        self.client = NimClient(
+            api_key=api_key, 
+            base_url=api_base_url, 
+            model=self.model,
+            timeout=self.settings.get("timeout_llm", 120.0),
+            max_retries=self.settings.get("max_retries", 15),
+            retry_base_delay=self.settings.get("retry_base_delay", 2.0),
+            retry_max_delay=self.settings.get("retry_max_delay", 60.0),
+        )
         
         # Initialize MCP Manager
         self.mcp = MCPManager(self.settings)
         
-        # Base system prompt
-        final_prompt = SYSTEM_PROMPT + self.mcp.get_system_prompt_additions()
+        # Build OS-aware system prompt
+        cwd = os.getcwd()
+        final_prompt = _build_system_prompt(cwd) + self.mcp.get_system_prompt_additions()
         
         # Load skills if present
-        skills_dir = os.path.join(os.getcwd(), ".nimcode", "skills")
+        skills_dir = os.path.join(cwd, ".nimcode", "skills")
         if os.path.exists(skills_dir) and os.path.isdir(skills_dir):
             loaded_skills = []
             for filename in os.listdir(skills_dir):
@@ -86,9 +162,16 @@ class Agent:
         self.messages: List[Dict[str, Any]] = [
             {"role": "system", "content": final_prompt}
         ]
-        self.max_turns = max_turns
+        
+        # Use config values with parameter overrides
+        cfg_max_turns = self.settings.get("max_turns", 200)
+        self.max_turns = max_turns if max_turns is not None else (0 if cfg_max_turns == 0 else cfg_max_turns)
+        
+        cfg_max_tokens = self.settings.get("max_tokens", 120000)
+        effective_max_tokens = max_tokens if max_tokens is not None else cfg_max_tokens
+        self.memory = MemoryManager(max_tokens=effective_max_tokens)
+        
         self.permission_engine = PermissionEngine(mode=permission_mode)
-        self.memory = MemoryManager(max_tokens=max_tokens)
 
     def save_history(self):
         """Saves current conversation to NIMCODE.md"""
@@ -185,7 +268,8 @@ class Agent:
         import json
         total_context_chars = sum(len(str(m.get("content", ""))) for m in self.messages)
         total_est_tokens = total_context_chars // 4
-        max_context = 128000  # Assume standard Llama-3.1 128k context for now
+        from .model_registry import get_context_window
+        max_context = get_context_window(self.model)
         if total_est_tokens > max_context * 0.8:
             c.print("[bold yellow]⚠️ Context window is over 80% full. Consider running /compact or /clear.[/bold yellow]")
             
@@ -199,7 +283,9 @@ class Agent:
         while turn < max_turns:
             turn += 1
             try:
-                response_text = await self.client.chat_one_shot(self.messages)
+                # Build a combined prompt from messages for one-shot call
+                combined = "\n".join(f"{m['role'].upper()}: {m.get('content','')}" for m in self.messages)
+                response_text = await self.client.chat_one_shot(combined)
             except Exception as e:
                 return f"Subagent error: {e}"
                 
@@ -228,13 +314,12 @@ class Agent:
         if not old_msgs:
             return self.messages
             
-        summary_prompt = "Please summarize the following conversation concisely. Focus on the final state, any completed goals, and any context needed for the next steps:\n\n"
+        summary_prompt = "You are a summarization AI. Please summarize the following conversation concisely. Focus on the final state, any completed goals, and any context needed for the next steps:\n\n"
         for m in old_msgs:
             summary_prompt += f"{m['role'].upper()}: {str(m['content'])[:500]}...\n"
             
-        messages = [{"role": "system", "content": "You are a summarization AI."}, {"role": "user", "content": summary_prompt}]
         try:
-            summary = await self.client.chat_one_shot(messages)
+            summary = await self.client.chat_one_shot(summary_prompt)
             system_msg["content"] += f"\n\n[PREVIOUS MEMORY SUMMARY]\n{summary}"
         except Exception as e:
             logger.error(f"Distillation failed: {e}")
@@ -251,7 +336,7 @@ class Agent:
         
         cwd = os.getcwd()
         turn = 0
-        while turn < self.max_turns:
+        while self.max_turns == 0 or turn < self.max_turns:
             turn += 1
             logger.info(f"--- Turn {turn} ---")
             
@@ -338,8 +423,10 @@ class Agent:
                             if file_path.endswith(".py"):
                                 import subprocess
                                 try:
-                                    subprocess.run(["black", "-q", file_path], capture_output=True, timeout=10)
-                                    lint = subprocess.run(["flake8", "--select=E9,F821,F822,F823", file_path], capture_output=True, text=True, timeout=10)
+                                    t_fmt = self.settings.get("timeout_format", 10)
+                                    t_fmt = None if t_fmt == 0 else t_fmt
+                                    subprocess.run(["black", "-q", file_path], capture_output=True, timeout=t_fmt)
+                                    lint = subprocess.run(["flake8", "--select=E9,F821,F822,F823", file_path], capture_output=True, text=True, timeout=t_fmt)
                                     if lint.returncode != 0:
                                         import sys
                                         if sys.stdin.isatty():
@@ -357,7 +444,9 @@ class Agent:
                             elif file_path.endswith((".js", ".ts", ".jsx", ".tsx")):
                                 import subprocess
                                 try:
-                                    subprocess.run(["npx", "--yes", "prettier", "--write", file_path], capture_output=True, timeout=10)
+                                    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)
                                 except Exception:
                                     pass
                 except KeyboardInterrupt:

{nimcode-0.3.3 → nimcode-0.4.0}/src/nimcode/config.py

@@ -10,7 +10,21 @@ def load_settings() -> Dict[str, Any]:
     settings = {
         "model": "meta/llama-3.1-70b-instruct",
         "api_base_url": "https://integrate.api.nvidia.com/v1",
-        "mcp_servers": {}
+        "mcp_servers": {},
+        # Timeouts (0 = disabled/infinite)
+        "timeout_command": 1200,    # Timeout for bash commands (seconds)
+        "timeout_llm": 120,         # Timeout for LLM API calls (seconds)
+        "timeout_format": 10,       # Timeout for formatting/linting tools (seconds)
+        "timeout_browser": 15000,   # Timeout for browser actions (milliseconds)
+        "timeout_updater": 3,       # Timeout for update checks (seconds)
+        # Agent behavior
+        "max_turns": 200,           # Max agent turns per session (0 = unlimited)
+        "max_tokens": 120000,       # Token budget before auto-compact kicks in
+        "max_retries": 15,          # Max LLM API retry attempts on transient errors
+        "retry_base_delay": 2.0,    # Base delay for exponential backoff (seconds)
+        "retry_max_delay": 60.0,    # Max delay cap for exponential backoff (seconds)
+        # Security
+        "allow_bash_non_interactive": False,  # Allow Bash in non-interactive (CI) mode
     }
     
     # Global settings

nimcode-0.4.0/src/nimcode/model_registry.py

@@ -0,0 +1,54 @@
+"""
+Model registry with context window sizes and metadata.
+Used for auto-compact thresholds and dynamic model listing.
+"""
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Known NVIDIA NIM models and their context window sizes (in tokens)
+# This acts as a fallback + enrichment layer when API is unavailable
+MODEL_CONTEXT_WINDOWS = {
+    # Llama 3.1 family
+    "meta/llama-3.1-8b-instruct": 128000,
+    "meta/llama-3.1-70b-instruct": 128000,
+    "meta/llama-3.1-405b-instruct": 128000,
+    # Llama 3.2 family
+    "meta/llama-3.2-1b-instruct": 128000,
+    "meta/llama-3.2-3b-instruct": 128000,
+    "meta/llama-3.2-11b-vision-instruct": 128000,
+    "meta/llama-3.2-90b-vision-instruct": 128000,
+    # Llama 3.3 family
+    "meta/llama-3.3-70b-instruct": 128000,
+    # Nemotron
+    "nvidia/nemotron-4-340b-instruct": 4096,
+    "nvidia/llama-3.1-nemotron-70b-instruct": 128000,
+    # Mistral
+    "mistralai/mixtral-8x22b-instruct-v0.1": 65536,
+    "mistralai/mistral-large-2-instruct": 128000,
+    # DeepSeek
+    "deepseek-ai/deepseek-r1": 128000,
+    # Qwen
+    "qwen/qwen2.5-72b-instruct": 128000,
+    "qwen/qwq-32b": 128000,
+}
+
+# Default context window for unknown models
+DEFAULT_CONTEXT_WINDOW = 8192
+
+# Hardcoded fallback model list (used when API is unreachable)
+FALLBACK_MODELS = [
+    "meta/llama-3.1-70b-instruct",
+    "meta/llama-3.1-8b-instruct",
+    "meta/llama-3.1-405b-instruct",
+    "meta/llama-3.3-70b-instruct",
+    "nvidia/llama-3.1-nemotron-70b-instruct",
+    "deepseek-ai/deepseek-r1",
+    "mistralai/mixtral-8x22b-instruct-v0.1",
+    "qwen/qwen2.5-72b-instruct",
+]
+
+
+def get_context_window(model_id: str) -> int:
+    """Returns the context window size for a given model ID."""
+    return MODEL_CONTEXT_WINDOWS.get(model_id, DEFAULT_CONTEXT_WINDOW)

{nimcode-0.3.3 → nimcode-0.4.0}/src/nimcode/nim_client.py

@@ -8,10 +8,14 @@ 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"):
+    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):
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
         self.model = model
+        self.timeout = None if timeout == 0 else timeout
+        self.max_retries = max_retries
+        self.retry_base_delay = retry_base_delay
+        self.retry_max_delay = retry_max_delay
         self.headers = {
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json",
@@ -19,13 +23,25 @@ class NimClient:
         }
         
     async def get_available_models(self) -> List[str]:
-        return [
-            "meta/llama-3.1-70b-instruct",
-            "meta/llama-3.1-8b-instruct",
-            "meta/llama-3.1-405b-instruct",
-            "nvidia/nemotron-4-340b-instruct",
-            "mistralai/mixtral-8x22b-instruct-v0.1"
-        ]
+        """Fetches available models from the NIM API. Falls back to known models on error."""
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{self.base_url}/models",
+                    headers=self.headers,
+                    timeout=10.0
+                )
+                if response.status_code == 200:
+                    data = response.json()
+                    models = [m["id"] for m in data.get("data", []) if m.get("id")]
+                    if models:
+                        return sorted(models)
+        except Exception as e:
+            logger.debug(f"Failed to fetch models from API: {e}")
+        
+        # Fallback to known model list
+        from .model_registry import FALLBACK_MODELS
+        return FALLBACK_MODELS
 
     async def chat_one_shot(self, prompt: str) -> str:
         payload = {
@@ -39,7 +55,7 @@ class NimClient:
                 f"{self.base_url}/chat/completions",
                 headers=self.headers,
                 json=payload,
-                timeout=60.0
+                timeout=self.timeout
             )
             response.raise_for_status()
             data = response.json()
@@ -70,7 +86,7 @@ class NimClient:
                     f"{self.base_url}/chat/completions",
                     headers=self.headers,
                     json=payload,
-                    timeout=60.0
+                    timeout=self.timeout
                 )
                 response.raise_for_status()
                 data = response.json()
@@ -90,15 +106,15 @@ class NimClient:
             "stream": stream
         }
         
-        max_retries = 15
-        base_delay = 2.0
-        max_delay = 60.0
+        max_retries = self.max_retries
+        base_delay = self.retry_base_delay
+        max_delay = self.retry_max_delay
         
         for attempt in range(max_retries):
             chunk_yielded = False
             try:
                 async with httpx.AsyncClient() as client:
-                    async with client.stream("POST", f"{self.base_url}/chat/completions", headers=self.headers, json=payload, timeout=120.0) as response:
+                    async with client.stream("POST", f"{self.base_url}/chat/completions", headers=self.headers, json=payload, timeout=self.timeout) as response:
                         if response.status_code in [408, 429, 500, 502, 503, 504, 529]:
                             raise httpx.HTTPStatusError(f"Temporary server error {response.status_code}", request=response.request, response=response)
                         

{nimcode-0.3.3 → nimcode-0.4.0}/src/nimcode/permissions.py

@@ -39,8 +39,18 @@ class PermissionEngine:
         args = tool_call.get("args", {})
         
         if not sys.stdin.isatty():
-            console.print(f"[yellow]Running non-interactive. Approving {tool_name} for tests.[/yellow]")
-            return True
+            # Non-interactive mode: only auto-approve safe tools + writes.
+            # Bash requires explicit opt-in via config.
+            from .config import load_settings
+            settings = load_settings()
+            safe_non_interactive = {"Read", "Glob", "Grep", "Write", "Edit", "ASTReplace"}
+            if tool_name in safe_non_interactive:
+                return True
+            if tool_name == "Bash" and settings.get("allow_bash_non_interactive", False):
+                console.print(f"[yellow]Non-interactive: Bash auto-approved via config.[/yellow]")
+                return True
+            console.print(f"[red]Non-interactive: {tool_name} DENIED (enable 'allow_bash_non_interactive' in settings to allow).[/red]")
+            return False
             
         while True:
             content = ""

{nimcode-0.3.3 → nimcode-0.4.0}/src/nimcode/repl.py

@@ -531,17 +531,30 @@ class NimcodeREPL:
                     self.messages.append({"role": "system", "content": "You are the Application Guardian. Your sole priority is preventing regressions. Before making any code changes, ensure you write a test first. If a user asks for a breaking change, warn them aggressively."})
                     continue
                 elif user_input.strip() == "/thinkback":
-                    console.print("[bold blue]⏪ Entering Agent Replay Mode (Thinkback)[/bold blue]")
+                    console.print("[bold blue]⏪ Agent Replay (Thinkback)[/bold blue]")
                     from rich.table import Table
-                    table = Table(title="Recent Agent Actions")
+                    table = Table(title="Session History")
                     table.add_column("Turn", style="cyan")
-                    table.add_column("Tokens", style="yellow")
-                    table.add_column("Tools Called", style="green")
-                    table.add_row("1", "450", "Read, Glob")
-                    table.add_row("2", "1200", "Bash, Write")
-                    table.add_row("3", "300", "StartTerminal")
-                    console.print(table)
-                    console.print("[dim]Note: Full replay logs are stored in .nimcode/logs/[/dim]")
+                    table.add_column("Role", style="yellow")
+                    table.add_column("Tokens (est.)", style="green")
+                    table.add_column("Preview", style="dim", max_width=60)
+                    turn_num = 0
+                    for msg in self.messages[1:]:  # Skip system prompt
+                        role = msg.get("role", "?")
+                        content = str(msg.get("content", ""))
+                        est_tokens = len(content) // 4 + 1
+                        preview = content[:80].replace("\n", " ")
+                        if len(content) > 80:
+                            preview += "..."
+                        if role == "user":
+                            turn_num += 1
+                        table.add_row(str(turn_num), role, str(est_tokens), preview)
+                    if turn_num == 0:
+                        console.print("[dim]No conversation history yet.[/dim]")
+                    else:
+                        console.print(table)
+                        total_tokens = sum(len(str(m.get("content", ""))) // 4 + 1 for m in self.messages)
+                        console.print(f"[dim]Total messages: {len(self.messages)} | Est. total tokens: {total_tokens}[/dim]")
                     continue
                 elif user_input.strip().startswith("/fix"):
                     parts = user_input.strip().split(" ", 1)

nimcode-0.4.0/src/nimcode/repo_map.py

@@ -0,0 +1,97 @@
+"""
+Lightweight repository mapper.
+Generates a tree-style overview of the project structure.
+Used by watcher.py for Live Sync updates.
+"""
+import os
+import logging
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Directories to always skip
+IGNORE_DIRS = {
+    ".git", ".nimcode", "__pycache__", "node_modules", ".venv", "venv",
+    ".tox", ".mypy_cache", ".pytest_cache", "dist", "build", ".egg-info",
+    ".idea", ".vscode", "env", ".env",
+}
+
+# File extensions to include in the map
+CODE_EXTENSIONS = {
+    ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".go", ".rs", ".rb",
+    ".c", ".cpp", ".h", ".cs", ".php", ".swift", ".kt", ".scala",
+    ".html", ".css", ".scss", ".vue", ".svelte",
+    ".json", ".yaml", ".yml", ".toml", ".md", ".txt",
+    ".sql", ".sh", ".bat", ".ps1", ".dockerfile",
+}
+
+MAX_FILES = 500  # Safety limit
+
+
+class RepoMapper:
+    def __init__(self, root_dir: str, max_depth: int = 6):
+        self.root_dir = os.path.abspath(root_dir)
+        self.max_depth = max_depth
+        self._file_count = 0
+
+    def generate_map(self) -> str:
+        """Generates a tree-style string of the repository structure."""
+        self._file_count = 0
+        lines = [f"📁 {os.path.basename(self.root_dir)}/"]
+        self._walk(self.root_dir, lines, prefix="", depth=0)
+        
+        if self._file_count >= MAX_FILES:
+            lines.append(f"\n... (truncated at {MAX_FILES} files)")
+        
+        return "\n".join(lines)
+
+    def _walk(self, directory: str, lines: List[str], prefix: str, depth: int) -> None:
+        if depth >= self.max_depth or self._file_count >= MAX_FILES:
+            return
+
+        try:
+            entries = sorted(os.listdir(directory))
+        except PermissionError:
+            return
+
+        # Separate dirs and files
+        dirs = []
+        files = []
+        for entry in entries:
+            full_path = os.path.join(directory, entry)
+            if os.path.isdir(full_path):
+                if entry not in IGNORE_DIRS and not entry.startswith("."):
+                    dirs.append(entry)
+            else:
+                ext = os.path.splitext(entry)[1].lower()
+                if ext in CODE_EXTENSIONS or entry in {"Makefile", "Dockerfile", "Procfile", ".gitignore"}:
+                    files.append(entry)
+
+        all_entries = dirs + files
+        for i, entry in enumerate(all_entries):
+            is_last = (i == len(all_entries) - 1)
+            connector = "└── " if is_last else "├── "
+            
+            full_path = os.path.join(directory, entry)
+            
+            if entry in dirs:
+                lines.append(f"{prefix}{connector}📁 {entry}/")
+                extension = "    " if is_last else "│   "
+                self._walk(full_path, lines, prefix + extension, depth + 1)
+            else:
+                self._file_count += 1
+                if self._file_count > MAX_FILES:
+                    return
+                size = os.path.getsize(full_path)
+                size_str = _format_size(size)
+                lines.append(f"{prefix}{connector}{entry} ({size_str})")
+
+
+def _format_size(size_bytes: int) -> str:
+    """Formats file size in human-readable format."""
+    if size_bytes < 1024:
+        return f"{size_bytes}B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f}KB"
+    else:
+        return f"{size_bytes / (1024 * 1024):.1f}MB"

{nimcode-0.3.3 → nimcode-0.4.0}/src/nimcode/tools.py

@@ -239,6 +239,8 @@ class ToolRegistry:
             return f"Started task '{task_id}' in the background. Check logs at {log_file}. Use /tasks to manage."
             
         try:
+            t_cmd = settings.get("timeout_command", 1200)
+            t_cmd = None if t_cmd == 0 else t_cmd
             result = subprocess.run(
                 command,
                 shell=True,
@@ -246,7 +248,7 @@ class ToolRegistry:
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 text=True,
-                timeout=1200
+                timeout=t_cmd
             )
             out = result.stdout + "\n" + result.stderr
             out = out.strip()
@@ -257,7 +259,7 @@ class ToolRegistry:
             
             return out if out else "Command executed successfully with no output."
         except subprocess.TimeoutExpired:
-            return "Error: Command timed out after 1200 seconds."
+            return f"Error: Command timed out after {t_cmd} seconds."
         except Exception as e:
             return f"Error running bash: {e}"
 
@@ -565,11 +567,16 @@ class ToolRegistry:
         try:
             from playwright.sync_api import sync_playwright
             import base64
+            from .config import load_settings
+            
+            settings = load_settings()
+            t_browser = settings.get("timeout_browser", 15000)
+            t_browser = 0 if t_browser == 0 else t_browser
             
             with sync_playwright() as p:
                 browser = p.chromium.launch(headless=True)
                 page = browser.new_page()
-                page.goto(url, wait_until="networkidle", timeout=15000)
+                page.goto(url, wait_until="networkidle", timeout=t_browser)
                 
                 screenshot_bytes = page.screenshot(type="jpeg", quality=50)
                 b64_img = base64.b64encode(screenshot_bytes).decode('utf-8')

{nimcode-0.3.3 → nimcode-0.4.0}/src/nimcode/updater.py

@@ -3,7 +3,7 @@ import logging
 
 logger = logging.getLogger(__name__)
 
-CURRENT_VERSION = "3.0.0"
+from .__version__ import __version__ as CURRENT_VERSION
 
 class AutoUpdater:
     @staticmethod
@@ -13,7 +13,12 @@ class AutoUpdater:
         Returns the latest version string if > CURRENT_VERSION, else None.
         """
         try:
-            async with httpx.AsyncClient(timeout=3.0) as client:
+            from .config import load_settings
+            settings = load_settings()
+            t_upd = settings.get("timeout_updater", 3.0)
+            t_upd = None if t_upd == 0 else t_upd
+            
+            async with httpx.AsyncClient(timeout=t_upd) as client:
                 response = await client.get("https://pypi.org/pypi/nimcode/json")
                 if response.status_code == 200:
                     data = response.json()

{nimcode-0.3.3 → nimcode-0.4.0}/src/nimcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.3.3
+Version: 0.4.0
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Author: Autonomous Agent
 Requires-Dist: httpx>=0.27.0

{nimcode-0.3.3 → nimcode-0.4.0}/src/nimcode.egg-info/SOURCES.txt

@@ -1,17 +1,20 @@
 README.md
 setup.py
 src/nimcode/__init__.py
+src/nimcode/__version__.py
 src/nimcode/agent.py
 src/nimcode/cli.py
 src/nimcode/config.py
 src/nimcode/lenient_parser.py
 src/nimcode/mcp_client.py
 src/nimcode/memory.py
+src/nimcode/model_registry.py
 src/nimcode/nim_client.py
 src/nimcode/permissions.py
 src/nimcode/plugin_manager.py
 src/nimcode/rag.py
 src/nimcode/repl.py
+src/nimcode/repo_map.py
 src/nimcode/tools.py
 src/nimcode/updater.py
 src/nimcode/watcher.py
@@ -27,11 +30,14 @@ tests/test_config.py
 tests/test_lenient_parser.py
 tests/test_mcp_client.py
 tests/test_memory.py
+tests/test_model_registry.py
 tests/test_nim_client.py
 tests/test_permissions.py
 tests/test_plugin_manager.py
 tests/test_repl.py
 tests/test_repl_extra.py
 tests/test_repl_trust.py
+tests/test_repo_map.py
 tests/test_tools.py
-tests/test_updater.py
+tests/test_updater.py
+tests/test_version.py

{nimcode-0.3.3 → nimcode-0.4.0}/tests/test_config.py

@@ -9,6 +9,16 @@ def test_load_settings_default():
         settings = load_settings()
         assert settings["model"] == "meta/llama-3.1-70b-instruct"
         assert settings["mcp_servers"] == {}
+        # New configurable settings
+        assert settings["max_turns"] == 200
+        assert settings["max_tokens"] == 120000
+        assert settings["max_retries"] == 15
+        assert settings["retry_base_delay"] == 2.0
+        assert settings["retry_max_delay"] == 60.0
+        assert settings["allow_bash_non_interactive"] == False
+        # Timeouts
+        assert settings["timeout_command"] == 1200
+        assert settings["timeout_llm"] == 120
 
 def test_load_settings_global_only():
     mock_global = '{"model": "global_model", "mcp_servers": {"global": {}}}'

nimcode-0.4.0/tests/test_model_registry.py

@@ -0,0 +1,38 @@
+"""Tests for the model_registry module."""
+import pytest
+from nimcode.model_registry import (
+    MODEL_CONTEXT_WINDOWS,
+    FALLBACK_MODELS,
+    DEFAULT_CONTEXT_WINDOW,
+    get_context_window,
+)
+
+
+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("nvidia/nemotron-4-340b-instruct") == 4096
+    assert get_context_window("mistralai/mixtral-8x22b-instruct-v0.1") == 65536
+
+
+def test_get_context_window_unknown_model():
+    """Unknown models should return the default context window."""
+    assert get_context_window("some/unknown-model") == DEFAULT_CONTEXT_WINDOW
+    assert get_context_window("") == DEFAULT_CONTEXT_WINDOW
+
+
+def test_fallback_models_not_empty():
+    """Fallback model list should have entries."""
+    assert len(FALLBACK_MODELS) > 0
+
+
+def test_fallback_models_all_in_context_windows():
+    """All fallback models should have a known context window entry."""
+    for model in FALLBACK_MODELS:
+        assert model in MODEL_CONTEXT_WINDOWS, f"Fallback model {model} missing from context windows"
+
+
+def test_context_windows_positive():
+    """All context window values should be positive integers."""
+    for model, ctx in MODEL_CONTEXT_WINDOWS.items():
+        assert isinstance(ctx, int) and ctx > 0, f"Invalid context window for {model}: {ctx}"

{nimcode-0.3.3 → nimcode-0.4.0}/tests/test_permissions.py

@@ -8,8 +8,10 @@ def test_permission_bypass():
 
 def test_permission_readonly_blocked():
     engine = PermissionEngine(mode=PermissionMode.AUTO)
-    # Bash should still be checked (not returned True immediately) and if not interactive, returns True for now (which is a flaw but let's test current behavior)
-    assert engine.check_permission({"tool": "Bash", "args": {}}) == True
+    # In non-interactive mode (tests), Bash is now DENIED by default.
+    # Safe tools (Read, Glob, Grep) and Write/Edit are still auto-approved.
+    assert engine.check_permission({"tool": "Read", "args": {}}) == True
+    assert engine.check_permission({"tool": "Bash", "args": {}}) == False
 
 def test_permission_safe_tools():
     engine = PermissionEngine(mode=PermissionMode.DEFAULT)

nimcode-0.4.0/tests/test_repo_map.py

@@ -0,0 +1,93 @@
+"""Tests for repo_map module."""
+import os
+import pytest
+import tempfile
+from nimcode.repo_map import RepoMapper, _format_size
+
+
+def test_format_size_bytes():
+    assert _format_size(500) == "500B"
+    assert _format_size(0) == "0B"
+
+
+def test_format_size_kb():
+    result = _format_size(2048)
+    assert "KB" in result
+
+
+def test_format_size_mb():
+    result = _format_size(2 * 1024 * 1024)
+    assert "MB" in result
+
+
+def test_generate_map_basic(tmp_path):
+    """Test basic tree generation with files and directories."""
+    # Create a simple project structure
+    (tmp_path / "main.py").write_text("print('hello')")
+    (tmp_path / "utils.py").write_text("def helper(): pass")
+    sub = tmp_path / "src"
+    sub.mkdir()
+    (sub / "app.py").write_text("class App: pass")
+    
+    mapper = RepoMapper(str(tmp_path))
+    result = mapper.generate_map()
+    
+    assert "main.py" in result
+    assert "utils.py" in result
+    assert "src" in result
+    assert "app.py" in result
+
+
+def test_generate_map_ignores_pycache(tmp_path):
+    """Test that __pycache__ directories are ignored."""
+    (tmp_path / "main.py").write_text("x = 1")
+    cache = tmp_path / "__pycache__"
+    cache.mkdir()
+    (cache / "main.cpython-311.pyc").write_bytes(b"bytecode")
+    
+    mapper = RepoMapper(str(tmp_path))
+    result = mapper.generate_map()
+    
+    assert "main.py" in result
+    assert "__pycache__" not in result
+
+
+def test_generate_map_ignores_node_modules(tmp_path):
+    """Test that node_modules is ignored."""
+    (tmp_path / "index.js").write_text("console.log('hi')")
+    nm = tmp_path / "node_modules"
+    nm.mkdir()
+    (nm / "package.json").write_text("{}")
+    
+    mapper = RepoMapper(str(tmp_path))
+    result = mapper.generate_map()
+    
+    assert "index.js" in result
+    assert "node_modules" not in result
+
+
+def test_generate_map_max_depth(tmp_path):
+    """Test that max_depth is respected."""
+    # Create a deeply nested structure
+    current = tmp_path
+    for i in range(10):
+        current = current / f"level{i}"
+        current.mkdir()
+        (current / "file.py").write_text(f"level {i}")
+    
+    mapper = RepoMapper(str(tmp_path), max_depth=3)
+    result = mapper.generate_map()
+    
+    assert "level0" in result
+    assert "level1" in result
+    # Deep levels should NOT appear
+    assert "level8" not in result
+
+
+def test_generate_map_empty_dir(tmp_path):
+    """Empty directory should still generate valid output."""
+    mapper = RepoMapper(str(tmp_path))
+    result = mapper.generate_map()
+    
+    # Should at least have the root directory name
+    assert tmp_path.name in result

nimcode-0.4.0/tests/test_version.py

@@ -0,0 +1,24 @@
+"""Tests for __version__ single source of truth."""
+import pytest
+
+
+def test_version_format():
+    """Version should be a valid semver string."""
+    from nimcode.__version__ import __version__
+    parts = __version__.split(".")
+    assert len(parts) == 3, f"Version should be x.y.z, got {__version__}"
+    for part in parts:
+        assert part.isdigit(), f"Version part '{part}' is not a digit"
+
+
+def test_version_is_0_4_0():
+    """Current version should be 0.4.0."""
+    from nimcode.__version__ import __version__
+    assert __version__ == "0.4.0"
+
+
+def test_updater_uses_version():
+    """updater.py should use the same version as __version__.py."""
+    from nimcode.__version__ import __version__
+    from nimcode.updater import CURRENT_VERSION
+    assert CURRENT_VERSION == __version__