nimcode 0.1.12__tar.gz → 0.1.13__tar.gz

{nimcode-0.1.12 → nimcode-0.1.13}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.1.12
+Version: 0.1.13
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Author: Autonomous Agent
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: prompt_toolkit>=3.0.0
 Requires-Dist: mcp>=1.2.0
+Requires-Dist: keyring>=24.0.0
+Requires-Dist: watchdog>=4.0.0
 Dynamic: author
 Dynamic: requires-dist
 Dynamic: summary

{nimcode-0.1.12 → nimcode-0.1.13}/setup.py

@@ -2,14 +2,16 @@ from setuptools import setup, find_packages
 
 setup(
     name="nimcode",
-    version="0.1.12",
+    version="0.1.13",
     packages=find_packages(where="src"),
     package_dir={"": "src"},
     install_requires=[
         "httpx>=0.27.0",
         "rich>=13.7.0",
         "prompt_toolkit>=3.0.0",
-        "mcp>=1.2.0"
+        "mcp>=1.2.0",
+        "keyring>=24.0.0",
+        "watchdog>=4.0.0"
     ],
     entry_points={
         "console_scripts": [

{nimcode-0.1.12 → nimcode-0.1.13}/src/nimcode/agent.py

@@ -8,6 +8,7 @@ from .permissions import PermissionEngine, PermissionMode
 from .config import load_settings, save_global_setting
 from .mcp_client import MCPManager
 from .memory import MemoryManager
+from .analytics import AnalyticsEngine
 
 logger = logging.getLogger(__name__)
 
@@ -27,7 +28,7 @@ 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"}}
+- Replace: {"tool": "Replace", "args": {"file_path": "string", "replacements": [{"old_string": "exact old", "new_string": "exact new"}]}}
 - Glob: {"tool": "Glob", "args": {"pattern": "string"}}
 - Grep: {"tool": "Grep", "args": {"query": "string", "directory": "string"}}
 
@@ -48,18 +49,42 @@ When you have completely fulfilled the user's request and have no more tools to
 """
 
 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 = 30, permission_mode: PermissionMode = PermissionMode.DEFAULT, max_tokens: int = 100000):
         # Load global settings
         self.settings = load_settings()
         self.model = model or self.settings.get("model", "meta/llama-3.1-70b-instruct")
-        self.client = NimClient(api_key=api_key, model=self.model)
+        self.is_local = self.settings.get("is_local", False)
+        self.base_url = self.settings.get("base_url", None)
+        self.client = NimClient(api_key=api_key, base_url=self.base_url, model=self.model, is_local=self.is_local)
         
         # Initialize MCP Manager
         self.mcp = MCPManager(self.settings)
+        self.analytics = AnalyticsEngine()
+        self.memory = MemoryManager(model_name=model, fallback_max_tokens=max_tokens)
         
         # Base system prompt
         final_prompt = SYSTEM_PROMPT + self.mcp.get_system_prompt_additions()
         
+        # Inject Repo Map
+        try:
+            from .repo_map import RepoMapper
+            mapper = RepoMapper(os.getcwd())
+            repo_map = mapper.generate_map()
+            final_prompt += f"\n\n--- REPOSITORY MAP ---\n{repo_map}\n----------------------\n"
+        except Exception as e:
+            logger.error(f"Failed to generate repo map: {e}")
+        
+        # Load .nimcoderules if present
+        rules_path = os.path.join(os.getcwd(), ".nimcoderules")
+        if os.path.exists(rules_path):
+            try:
+                with open(rules_path, "r", encoding="utf-8") as f:
+                    rules = f.read()
+                final_prompt += f"\n\nPROJECT-SPECIFIC RULES (.nimcoderules):\n{rules}\n"
+                logger.info("Loaded .nimcoderules")
+            except Exception as e:
+                logger.error(f"Failed to load .nimcoderules: {e}")
+        
         # Load skills if present
         skills_dir = os.path.join(os.getcwd(), ".nimcode", "skills")
         if os.path.exists(skills_dir) and os.path.isdir(skills_dir):
@@ -81,13 +106,18 @@ class Agent:
                 final_prompt += f"\n\nGIT CONTEXT:\nBranch: {branch}\nUncommitted changes:\n{status if status else 'None'}"
             except Exception as e:
                 logger.error(f"Failed to load git context: {e}")
+                
+        # Repo Map
+        repo_map = self._generate_repo_map(os.getcwd())
+        if repo_map:
+            final_prompt += f"\n\nREPOSITORY MAP:\n{repo_map}"
 
         self.messages: List[Dict[str, Any]] = [
             {"role": "system", "content": final_prompt}
         ]
         self.max_turns = max_turns
         self.permission_engine = PermissionEngine(mode=permission_mode)
-        self.memory = MemoryManager(max_tokens=max_tokens)
+        self.memory = MemoryManager(model_name=model, fallback_max_tokens=max_tokens)
 
     def save_history(self):
         """Saves current conversation to NIMCODE.md"""
@@ -108,6 +138,28 @@ class Agent:
         except Exception as e:
             logger.error(f"Failed to load history: {e}")
 
+    def _generate_repo_map(self, cwd: str) -> str:
+        """Generates a fast, lightweight file tree map."""
+        ignore_dirs = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', 'env', '.nimcode'}
+        tree = []
+        for root, dirs, files in os.walk(cwd):
+            dirs[:] = [d for d in dirs if d not in ignore_dirs and not d.startswith('.')]
+            level = root.replace(cwd, '').count(os.sep)
+            indent = ' ' * 4 * level
+            basename = os.path.basename(root)
+            if basename:
+                tree.append(f"{indent}{basename}/")
+            subindent = ' ' * 4 * (level + 1)
+            for f in files:
+                if not f.endswith('.pyc') and not f.startswith('.'):
+                    tree.append(f"{subindent}{f}")
+                    
+        # Limit to 500 lines to save context
+        if len(tree) > 500:
+            tree = tree[:500] + ["... (truncated for context limit)"]
+            
+        return "\n".join(tree)
+
     async def _stream_response(self) -> str:
         from rich.live import Live
         from rich.markdown import Markdown
@@ -170,23 +222,16 @@ class Agent:
                 live.update(Markdown(response_text + "\n\n*[yellow]Stream interrupted by user.[/yellow]*", code_theme=code_theme))
                 c.print("\n[yellow]Generation interrupted.[/yellow]")
                 
-        # Approximate Token Tracker Update
-        est_tokens = len(response_text) // 4
-        if not hasattr(self, "session_tokens"):
-            self.session_tokens = 0
-        self.session_tokens += est_tokens
+        # Analytics Token Tracker Update
+        est_prompt_tokens = self.client.count_tokens_approx(self.messages)
+        est_completion_tokens = len(response_text) // 4
         
-        # Approximate cost based on 70B typical rates ($3/1M tokens)
-        cost = (self.session_tokens / 1000000) * 3.0
-        c.print(f"[dim]Output est. tokens: {est_tokens} | Session Cost: ~${cost:.4f}[/dim]")
+        self.analytics.log_usage(self.model, est_prompt_tokens, est_completion_tokens)
         
-        # Context usage warning
-        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
-        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]")
+        # Display today's cost
+        stats = self.analytics.get_summary()
+        today_cost = stats["today"]["cost_usd"]
+        c.print(f"[dim]Output est. tokens: {est_completion_tokens} | Today's Cost: ~${today_cost:.4f}[/dim]")
             
         return response_text
 
@@ -197,6 +242,10 @@ class Agent:
         from .tools import ToolRegistry
         while turn < max_turns:
             turn += 1
+            if self.memory.count_messages_tokens(self.messages) > (self.memory.max_tokens * 0.8):
+                logger.info("Context full in headless mode. Distilling memory via LLM...")
+                self.messages = await self._distill_memory()
+                
             try:
                 response_text = await self.client.chat_one_shot(self.messages)
             except Exception as e:
@@ -256,7 +305,7 @@ class Agent:
             
             # Compact context before calling API
             from rich.console import Console
-            if self.memory.count_messages_tokens(self.messages) > self.memory.max_tokens:
+            if self.memory.count_messages_tokens(self.messages) > (self.memory.max_tokens * 0.8):
                 logger.info("Context full. Distilling memory via LLM...")
                 Console().print("[dim italic]🧠 Context full. Distilling memory into a summary to save tokens...[/dim italic]")
                 self.messages = await self._distill_memory()
@@ -297,7 +346,7 @@ class Agent:
                 tool_name = tool_call.get("tool", "Unknown")
                 
                 logger.info(f"Checking permissions for tool: {tool_name}")
-                if not self.permission_engine.check_permission(tool_call):
+                if not await self.permission_engine.check_permission(tool_call):
                     self.messages.append({
                         "role": "user",
                         "content": f"User explicitly denied permission to execute {tool_name}. Please choose another approach."

nimcode-0.1.13/src/nimcode/analytics.py

@@ -0,0 +1,68 @@
+import sqlite3
+import os
+import time
+
+class AnalyticsEngine:
+    def __init__(self, db_path=None):
+        if not db_path:
+            global_dir = os.path.expanduser("~/.nimcode")
+            os.makedirs(global_dir, exist_ok=True)
+            self.db_path = os.path.join(global_dir, "analytics.db")
+        else:
+            self.db_path = db_path
+            
+        self._init_db()
+
+    def _init_db(self):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS token_usage (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp REAL,
+                    model TEXT,
+                    prompt_tokens INTEGER,
+                    completion_tokens INTEGER,
+                    cost_usd REAL
+                )
+            ''')
+            conn.commit()
+
+    def log_usage(self, model: str, prompt_tokens: int, completion_tokens: int):
+        # Calculate cost based on current NIM pricing (estimated)
+        # e.g., $0.50 per 1M prompt, $1.50 per 1M completion for llama3-70b
+        cost_usd = (prompt_tokens / 1_000_000) * 0.50 + (completion_tokens / 1_000_000) * 1.50
+        
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO token_usage (timestamp, model, prompt_tokens, completion_tokens, cost_usd) VALUES (?, ?, ?, ?, ?)",
+                (time.time(), model, prompt_tokens, completion_tokens, cost_usd)
+            )
+            conn.commit()
+
+    def get_summary(self):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Total stats
+            cursor.execute("SELECT SUM(prompt_tokens), SUM(completion_tokens), SUM(cost_usd) FROM token_usage")
+            total_stats = cursor.fetchone()
+            
+            # Today's stats
+            today_start = time.time() - (time.time() % 86400) # Start of UTC day approx
+            cursor.execute("SELECT SUM(prompt_tokens), SUM(completion_tokens), SUM(cost_usd) FROM token_usage WHERE timestamp >= ?", (today_start,))
+            today_stats = cursor.fetchone()
+            
+        return {
+            "total": {
+                "prompt_tokens": total_stats[0] or 0,
+                "completion_tokens": total_stats[1] or 0,
+                "cost_usd": total_stats[2] or 0.0
+            },
+            "today": {
+                "prompt_tokens": today_stats[0] or 0,
+                "completion_tokens": today_stats[1] or 0,
+                "cost_usd": today_stats[2] or 0.0
+            }
+        }

{nimcode-0.1.12 → nimcode-0.1.13}/src/nimcode/cli.py

@@ -14,13 +14,15 @@ def run_login():
     console.print("Get your API key from [bold underline blue]https://build.nvidia.com/[/bold underline blue]")
     
     import getpass
+    import keyring
+    
     api_key = getpass.getpass("Enter your NVIDIA NIM API Key: ")
     if not api_key.strip():
         console.print("[red]API Key cannot be empty.[/red]")
         return
         
-    save_global_setting("api_key", api_key.strip())
-    console.print("[green][OK] API Key saved successfully to ~/.nimcode/settings.json[/green]")
+    keyring.set_password("nimcode", "api_key", api_key.strip())
+    console.print("[green][OK] API Key saved securely to OS Keyring[/green]")
 
 def run_doctor():
     console.print("[bold cyan]NimCode Doctor[/bold cyan] - Diagnostics")
@@ -74,28 +76,53 @@ 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=None, help="Model ID to use from NIM (e.g. meta/llama-3.1-70b-instruct).")
     parser.add_argument("--max-turns", "-t", type=int, default=30, help="Maximum number of turns the agent is allowed to run.")
     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.md.")
+    parser.add_argument("--stdio", action="store_true", help="Run NimCode as a JSON-RPC server over stdio for IDE integration.")
     
     args = parser.parse_args()
     
     settings = load_settings()
     
-    final_key = args.api_key or os.environ.get("NIM_API_KEY") or settings.get("api_key")
+    import keyring
+    final_key = args.api_key or os.environ.get("NIM_API_KEY") or keyring.get_password("nimcode", "api_key") or settings.get("api_key")
     if not final_key:
         console.print("[yellow]No API Key found. Let's get you set up![/yellow]")
         run_login()
         settings = load_settings()
-        final_key = settings.get("api_key")
+        final_key = keyring.get_password("nimcode", "api_key") or settings.get("api_key")
         if not final_key:
             console.print("[bold red]API Key is required to use NimCode. Exiting.[/bold red]")
             sys.exit(1)
         
+    model = args.model or settings.get("model")
+    if not model and not args.stdio:
+        from rich.prompt import Prompt
+        from .nim_client import NimClient
+        import asyncio
+        client = NimClient(api_key=final_key)
+        console.print("[yellow]Fetching available models from NVIDIA NIM...[/yellow]")
+        models = asyncio.run(client.get_available_models())
+        console.print("\n[bold cyan]Available Models:[/bold cyan]")
+        for i, m in enumerate(models):
+            console.print(f"[{i+1}] {m}")
+        
+        choice = Prompt.ask("Select a model number", choices=[str(i) for i in range(1, len(models)+1)], default="1")
+        model = models[int(choice) - 1]
+        
+        from .config import save_global_setting
+        if Prompt.ask("Save this model as default?", choices=["y", "n"], default="y") == "y":
+            save_global_setting("model", model)
+            console.print(f"[green]Saved {model} as default model.[/green]")
+            
+    if not model:
+        model = "meta/llama-3.1-70b-instruct" # ultimate fallback
+
     agent = Agent(
         api_key=final_key,
-        model=args.model,
+        model=model,
         max_turns=args.max_turns,
         permission_mode=args.permission_mode
     )
@@ -117,6 +144,10 @@ def main():
         console.print(f"[bold green]Starting NimCode[/bold green] with model [cyan]{args.model}[/cyan]")
         console.print(f"Task: {args.prompt}")
         asyncio.run(agent.run(args.prompt))
+    elif args.stdio:
+        from .stdio_server import StdioServer
+        server = StdioServer(agent)
+        asyncio.run(server.start())
     else:
         from .repl import NimcodeREPL
         repl = NimcodeREPL(agent)

{nimcode-0.1.12 → nimcode-0.1.13}/src/nimcode/config.py

@@ -21,6 +21,20 @@ def load_settings() -> Dict[str, Any]:
                 settings.update(global_settings)
         except Exception as e:
             logger.error(f"Failed to load global settings: {e}")
+            
+    # Scrub legacy api_key if found to ensure it uses keyring
+    if "api_key" in settings:
+        import keyring
+        try:
+            if not keyring.get_password("nimcode", "api_key"):
+                keyring.set_password("nimcode", "api_key", settings["api_key"])
+            
+            # Remove from file
+            del settings["api_key"]
+            with open(global_path, "w", encoding="utf-8") as f:
+                json.dump(settings, f, indent=4)
+        except Exception:
+            pass
 
     # Local settings
     local_path = os.path.join(os.getcwd(), ".nimcode", "settings.json")

nimcode-0.1.13/src/nimcode/memory.py

@@ -0,0 +1,140 @@
+import os
+import json
+import time
+import urllib.request
+import logging
+from typing import List, Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+class DynamicContextFetcher:
+    CACHE_FILE = os.path.expanduser('~/.nimcode/context_map.json')
+    CACHE_EXPIRY = 24 * 3600 # 24 hours
+    URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json'
+
+    @classmethod
+    def get_max_tokens(cls, model_name: str, default_limit: int = 8000) -> int:
+        if not model_name:
+            return default_limit
+            
+        data = cls._load_map()
+        if not data:
+            return default_limit
+        
+        # Exact match
+        for k, v in data.items():
+            if model_name.lower() == k.lower():
+                return v.get('max_tokens', default_limit) or default_limit
+                
+        # Heuristic matching
+        clean_model = model_name.split('/')[-1].lower()
+        
+        matches = []
+        for k, v in data.items():
+            if clean_model in k.lower():
+                tokens = v.get('max_tokens')
+                if tokens:
+                    matches.append(tokens)
+                    
+        if matches:
+            return max(matches)
+            
+        from .nim_client import NimClient
+        return NimClient.get_model_context_length(model_name)
+
+    @classmethod
+    def _load_map(cls) -> Optional[dict]:
+        if os.path.exists(cls.CACHE_FILE):
+            if time.time() - os.path.getmtime(cls.CACHE_FILE) < cls.CACHE_EXPIRY:
+                try:
+                    with open(cls.CACHE_FILE, 'r', encoding='utf-8') as f:
+                        return json.load(f)
+                except:
+                    pass
+                    
+        # Fetch live
+        try:
+            req = urllib.request.Request(cls.URL, headers={'User-Agent': 'Mozilla/5.0'})
+            with urllib.request.urlopen(req, timeout=5.0) as res:
+                data = json.loads(res.read().decode('utf-8'))
+                os.makedirs(os.path.dirname(cls.CACHE_FILE), exist_ok=True)
+                with open(cls.CACHE_FILE, 'w', encoding='utf-8') as f:
+                    json.dump(data, f)
+                return data
+        except Exception as e:
+            logger.debug(f"Failed to fetch dynamic context map: {e}")
+            return None
+
+class MemoryManager:
+    def __init__(self, model_name: str = None, fallback_max_tokens: int = 8000):
+        # We assume 1 token ~= 4 chars roughly
+        self.model_name = model_name
+        self.fallback_max_tokens = fallback_max_tokens
+        
+    @property
+    def max_tokens(self) -> int:
+        if not self.model_name:
+            return self.fallback_max_tokens
+        return DynamicContextFetcher.get_max_tokens(self.model_name, self.fallback_max_tokens)
+
+    @staticmethod
+    def count_tokens(text: str) -> int:
+        """Roughly count tokens in a string."""
+        if not text:
+            return 0
+        return len(text) // 4 + 1
+
+    @classmethod
+    def count_messages_tokens(cls, messages: List[Dict[str, Any]]) -> int:
+        total = 0
+        for msg in messages:
+            content = msg.get("content", "")
+            total += cls.count_tokens(content)
+        return total
+
+    def compact_context(self, messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        If messages exceed max_tokens, drops the oldest messages.
+        Always keeps the System prompt (first message).
+        Always keeps the most recent user prompt.
+        """
+        total_tokens = self.count_messages_tokens(messages)
+        if total_tokens <= self.max_tokens:
+            return messages
+
+        # We need to compact
+        if not messages:
+            return messages
+
+        compacted = [messages[0]] # System prompt
+        remaining_messages = messages[1:]
+        
+        # We start from the end and add backwards until we hit the limit
+        # Reserved tokens for system prompt
+        current_tokens = self.count_tokens(messages[0].get("content", ""))
+        
+        kept_messages = []
+        for msg in reversed(remaining_messages):
+            msg_tokens = self.count_tokens(msg.get("content", ""))
+            if current_tokens + msg_tokens > self.max_tokens:
+                # If we haven't even kept the most recent message, we MUST keep it and just truncate its content
+                if not kept_messages:
+                    truncated_content = msg.get("content", "")[:(self.max_tokens - current_tokens) * 4]
+                    kept_messages.insert(0, {"role": msg["role"], "content": truncated_content + "...[TRUNCATED]"})
+                break
+            
+            kept_messages.insert(0, msg)
+            current_tokens += msg_tokens
+
+        compacted.extend(kept_messages)
+        return compacted
+
+    @staticmethod
+    def log_to_nimcode_md(turn: int, prompt: str, response: str, cwd: str = ".") -> None:
+        """Appends the interaction to NIMCODE.md for persistent session history."""
+        file_path = os.path.join(cwd, "NIMCODE.md")
+        with open(file_path, "a", encoding="utf-8") as f:
+            f.write(f"## Turn {turn}\n\n")
+            f.write(f"**User**: {prompt}\n\n")
+            f.write(f"**Agent**: {response}\n\n")
+            f.write("---\n\n")

{nimcode-0.1.12 → nimcode-0.1.13}/src/nimcode/nim_client.py

@@ -8,17 +8,58 @@ 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 = None, model: str = None, is_local: bool = False):
         self.api_key = api_key
-        self.base_url = base_url.rstrip("/")
-        self.model = model
+        self.is_local = is_local
+        self.base_url = (base_url or "https://integrate.api.nvidia.com/v1").rstrip("/")
+        self.model = model or "meta/llama-3.1-70b-instruct"
         self.headers = {
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json",
             "Accept": "text/event-stream"
         }
         
+    @staticmethod
+    def get_model_context_length(model_name: str) -> int:
+        """Heuristically determines the maximum token context length from the model name."""
+        model_lower = model_name.lower()
+        if "llama-3.1" in model_lower or "llama-3.2" in model_lower:
+            return 128000
+        elif "nemotron" in model_lower:
+            return 128000 # Nemotron-4 is usually high context
+        elif "mixtral" in model_lower:
+            return 64000
+        elif "phi" in model_lower:
+            return 128000
+        elif "gemma" in model_lower:
+            return 8192
+        # Default fallback
+        return 32000
+
     async def get_available_models(self) -> List[str]:
+        if self.is_local:
+            try:
+                async with httpx.AsyncClient() as client:
+                    response = await client.get(f"{self.base_url}/models", timeout=5.0)
+                    if response.status_code == 200:
+                        data = response.json()
+                        return [m["id"] for m in data.get("data", [])]
+            except Exception as e:
+                logger.error(f"Failed to fetch local models: {e}")
+                return ["local-model"]
+                
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(f"{self.base_url}/models", headers={"Authorization": f"Bearer {self.api_key}"}, timeout=10.0)
+                if response.status_code == 200:
+                    data = response.json()
+                    return [m["id"] for m in data.get("data", [])]
+                else:
+                    logger.error(f"Failed to fetch models from API: {response.status_code}")
+        except Exception as e:
+            logger.error(f"Failed to fetch models: {e}")
+            
+        # Fallback list if API fails
         return [
             "meta/llama-3.1-70b-instruct",
             "meta/llama-3.1-8b-instruct",

{nimcode-0.1.12 → nimcode-0.1.13}/src/nimcode/permissions.py

@@ -18,7 +18,7 @@ class PermissionEngine:
         self.mode = mode
         self.safe_tools = {"Read", "Glob", "Grep"}
 
-    def check_permission(self, tool_call: dict) -> bool:
+    async def check_permission(self, tool_call: dict) -> bool:
         """Returns True if permitted, False otherwise."""
         if self.mode == PermissionMode.BYPASS:
             return True
@@ -28,9 +28,9 @@ class PermissionEngine:
         if self.mode == PermissionMode.AUTO and tool_name in self.safe_tools:
             return True
             
-        return self._prompt_user(tool_call)
+        return await self._prompt_user(tool_call)
             
-    def _prompt_user(self, tool_call: Dict[str, Any]) -> bool:
+    async def _prompt_user(self, tool_call: Dict[str, Any]) -> bool:
         from rich.panel import Panel
         from rich.prompt import Prompt
         import json
@@ -46,18 +46,44 @@ class PermissionEngine:
             content = ""
             if tool_name == "Bash":
                 content = f"Command:\n{args.get('command')}"
-            elif tool_name == "Write":
-                content_lines = len(args.get('content', '').split('\n'))
-                content = f"File: [bold cyan]{args.get('file_path')}[/bold cyan]\nAction: Overwrite with [bold green]{content_lines} new lines[/bold green]"
-            elif tool_name in ["Edit", "ASTReplace"]:
+            elif tool_name in ["Edit", "ASTReplace", "Replace", "Write"]:
                 import difflib
                 import os
                 file_path = args.get('file_path', '')
+                cwd = os.getcwd() # Assumption: running in cwd
+                full_path = os.path.join(cwd, file_path)
                 
                 # Default to basic diff summary
                 diff_str = ""
                 
-                if tool_name == "Edit":
+                old_lines = []
+                if os.path.exists(full_path):
+                    try:
+                        with open(full_path, "r", encoding="utf-8") as f:
+                            old_lines = f.readlines()
+                    except:
+                        pass
+                        
+                if tool_name == "Write":
+                    new_content = args.get('content', '')
+                    new_lines = new_content.splitlines(keepends=True)
+                    diff = list(difflib.unified_diff(old_lines, new_lines, fromfile=file_path, tofile=file_path))
+                    diff_str = "".join(diff)
+                elif tool_name == "Replace":
+                    replacements = args.get("replacements", [])
+                    try:
+                        with open(full_path, "r", encoding="utf-8") as f:
+                            new_content = f.read()
+                        for rep in replacements:
+                            old_s = rep.get("old_string", "")
+                            new_s = rep.get("new_string", "")
+                            new_content = new_content.replace(old_s, new_s, 1)
+                        new_lines = new_content.splitlines(keepends=True)
+                        diff = list(difflib.unified_diff(old_lines, new_lines, fromfile=file_path, tofile=file_path))
+                        diff_str = "".join(diff)
+                    except Exception:
+                        diff_str = "Could not compute diff for Replace."
+                elif tool_name == "Edit":
                     old_str = args.get('old_string', '')
                     new_str = args.get('new_string', '')
                     diff = list(difflib.unified_diff(old_str.splitlines(keepends=True), new_str.splitlines(keepends=True), fromfile=file_path, tofile=file_path))