nimcode 0.1.6__tar.gz → 0.1.12__tar.gz

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

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

nimcode-0.1.12/README.md

@@ -0,0 +1,134 @@
+<div align="center">
+  
+# 🚀 NimCode
+
+**The Autonomous AI Coding Assistant for the NVIDIA NIM Ecosystem**
+
+[![PyPI version](https://badge.fury.io/py/nimcode.svg)](https://badge.fury.io/py/nimcode)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+*A powerful, standalone REPL and CLI agent that writes, edits, and plans code like a senior developer—powered by LLaMa 3.1 70B (and other cutting-edge models) and the lightning-fast NVIDIA NIM API.*
+
+</div>
+
+---
+
+## 🌟 Overview
+
+NimCode is your autonomous coding pair-programmer. Built with a rich interactive terminal interface, it doesn't just autocomplete code—it plans architectures, executes terminal commands, writes complete files, formats code automatically, and manages your workspace. 
+
+### 🛠️ What We've Built So Far
+- **Robust Interactive REPL**: Multiline support (Alt+Enter), syntax highlighting, and beautiful `rich`-powered UI menus.
+- **Smart Permission Engine**: Granular control over what the AI can do, with interactive diff previews for file modifications and the brand new `/trust` mode for unhindered execution.
+- **Automated Workflows**: Automatic linting and formatting using `black`, `flake8`, and `prettier` behind the scenes with crash-resistant execution.
+- **CI/CD Integration**: A complete automated pipeline pushing to PyPI and creating GitHub Releases automatically on version tags.
+- **Extensive Tool Ecosystem**: The agent is equipped with Bash execution, AST Replacement, Semantic Search, Web Browsing, Interactive Terminal management, and much more.
+- **Model Context Protocol (MCP)**: Native integration for MCP tools allowing infinite extensibility.
+
+### 🚀 What We're Working On (Roadmap)
+- **Sub-agent Swarms**: Perfecting `/delegate` and `/swarm` to distribute complex tasks among specialized AI roles.
+- **Advanced Diagnostics**: Refining `/bughunter`, `/security-review`, and `/doctor` for automated codebase auditing.
+- **Test-Driven Development**: Upgrading `/tdd` and `/testgen` to automatically write tests and ensure 100% coverage before committing.
+- **Infrastructure & DevOps**: Implementing `/terraform-god` and `/sql-tune` for automated cloud provisioning and database query optimization.
+
+---
+
+## 📦 Installation
+
+NimCode is available globally via PyPI. You can install it anywhere in seconds:
+
+```bash
+pip install nimcode
+```
+
+## 🚀 Quick Start
+
+1. **Get an API Key**: Grab a free NVIDIA API key from [build.nvidia.com](https://build.nvidia.com/).
+2. **Login**: Connect your local environment by running:
+   ```bash
+   nimcode login
+   ```
+3. **Start Coding**: 
+   - Launch the interactive REPL:
+     ```bash
+     nimcode
+     ```
+   - Or run a one-off task directly from the command line:
+     ```bash
+     nimcode /plan "Build a classic Snake game using HTML5 Canvas"
+     ```
+
+---
+
+## 💻 Complete Command Reference
+
+Inside the `nimcode` REPL, you can type natural language or use any of the following slash commands to trigger specific workflows:
+
+### Mode Toggles & Execution
+- **`/code`**: Enter standard coding mode (default mode, prompts for dangerous actions).
+- **`/plan`**: Enter planning mode (read-only safe mode). The AI will research and write a markdown plan before modifying code.
+- **`/trust`**: Enter trust mode. The AI will run commands and edit files completely autonomously without asking for `(a)ccept / (r)eject`.
+- **`/untrust`**: Disable trust mode and restore permission prompts.
+
+### Interface & Settings
+- **`/models`**: Open an interactive UI to select your preferred NVIDIA NIM model (e.g., meta/llama-3.1-70b-instruct).
+- **`/theme`**: Open an interactive UI to change your syntax highlighting theme (e.g., monokai, dracula, nord, github).
+- **`/config`**: View and edit global NimCode configuration settings.
+
+### Workspace & Context Management
+- **`/clear`**: Clear the current conversation history to reset context.
+- **`/compact`**: Compact the context window to save tokens while keeping essential memories.
+- **`/context`**: View and manage the loaded context window.
+- **`/rewind`**: Rewind the conversation history by a few steps.
+- **`/undo`**: Revert the last file modification made by the AI.
+
+### Project & Search
+- **`/index`**: Index the current project files to enable lightning-fast Semantic Search.
+- **`/map`**: Generate a high-level semantic architecture map of the codebase.
+- **`/research`**: Enter deep-research mode for reading documentation or large files.
+
+### Automation & Git
+- **`/commit`**: Analyze all staged git changes and automatically generate a conventional commit message.
+- **`/fix`**: Run a specific shell command and let the AI automatically iterate to fix any resulting errors.
+- **`/autofix-pr`**: Pulls the current active GitHub Pull Request, reads comments, and automatically fixes the mentioned issues.
+
+### Advanced Development Modes
+- **`/testgen <file>`**: Generate unit tests for a specific file, aiming for 100% coverage.
+- **`/tdd`**: Enter Test-Driven Development mode. The AI will write tests first, verify they fail, and then implement the code to pass them.
+- **`/bughunter`**: Initiate an automated search for logical bugs and edge cases across the codebase.
+- **`/security-review`**: Audit the codebase for common vulnerabilities (e.g., OWASP top 10).
+- **`/sql-tune`**: Database telepathy mode. Analyzes and auto-tunes SQL queries for maximum performance.
+- **`/terraform-god`**: Cloud architect mode. Auto-provisions scalable best-practice Terraform infrastructure.
+- **`/decompile <binary>`**: Reverse engineering mode using tools like `objdump` and `radare2`.
+
+### AI & Agents
+- **`/delegate <role> <task>`**: Spawn an independent sub-agent with a specific role to handle a background task.
+- **`/swarm`**: Orchestrate multiple sub-agents to tackle a complex architectural epic simultaneously.
+- **`/grill-me`**: Interrogation mode. The AI will ask *you* hard questions to refine your system design and edge cases.
+- **`/learn`**: Teach NimCode a new persistent skill or framework rule that it will remember for future sessions.
+- **`/vision`**: Capture the screen and analyze UI elements using Vision AI models.
+- **`/voice`**: Record your voice for 5 seconds and transcribe it as a prompt.
+- **`/mcp install`**: Install and configure new Model Context Protocol tools.
+
+---
+
+## ⚙️ How it Works
+
+NimCode creates a `.nimcode` directory inside your projects. This directory acts as the "brain" for that specific workspace:
+- `.nimcode/plans/`: All your generated step-by-step markdown plans live here.
+- `.nimcode/skills/`: Any custom guidelines, framework rules, or memories you teach the agent.
+- `.nimcode/history/`: File backups for `/undo` capabilities.
+
+## 🛡️ Requirements
+
+- Python 3.8+
+- An NVIDIA NIM API Key (`NIM_API_KEY`)
+
+## 🤝 Contributing
+
+Contributions, issues, and feature requests are welcome! Feel free to check out our [issues page](#).
+
+---
+<div align="center">
+<i>Built with ❤️ for the open-source developer community.</i>
+</div>

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="nimcode",
-    version="0.1.6",
+    version="0.1.12",
     packages=find_packages(where="src"),
     package_dir={"": "src"},
     install_requires=[

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

@@ -333,23 +333,29 @@ class Agent:
                             file_path = tool_call.get("args", {}).get("file_path", "")
                             if file_path.endswith(".py"):
                                 import subprocess
-                                subprocess.run(["black", "-q", file_path], capture_output=True)
-                                lint = subprocess.run(["flake8", "--select=E9,F821,F822,F823", file_path], capture_output=True, text=True)
-                                if lint.returncode != 0:
-                                    import sys
-                                    if sys.stdin.isatty():
-                                        from rich.prompt import Confirm
-                                        c.print(f"\n[bold yellow]Linter found errors in {file_path}:[/bold yellow]\n{lint.stdout}")
-                                        if Confirm.ask("Would you like to auto-fix these errors?"):
-                                            result += f"\n\nAuto-Linter found errors:\n{lint.stdout}\nPlease fix them."
-                                            c.print(f"[bold red]Auto-fixing...[/bold red]")
+                                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)
+                                    if lint.returncode != 0:
+                                        import sys
+                                        if sys.stdin.isatty():
+                                            from rich.prompt import Confirm
+                                            c.print(f"\n[bold yellow]Linter found errors in {file_path}:[/bold yellow]\n{lint.stdout}")
+                                            if Confirm.ask("Would you like to auto-fix these errors?"):
+                                                result += f"\n\nAuto-Linter found errors:\n{lint.stdout}\nPlease fix them."
+                                                c.print(f"[bold red]Auto-fixing...[/bold red]")
+                                            else:
+                                                c.print("[dim]Ignoring linter errors.[/dim]")
                                         else:
-                                            c.print("[dim]Ignoring linter errors.[/dim]")
-                                    else:
-                                        result += f"\n\nAuto-Linter found errors:\n{lint.stdout}\nPlease fix them."
+                                            result += f"\n\nAuto-Linter found errors:\n{lint.stdout}\nPlease fix them."
+                                except Exception as e:
+                                    pass
                             elif file_path.endswith((".js", ".ts", ".jsx", ".tsx")):
                                 import subprocess
-                                subprocess.run(["npx", "prettier", "--write", file_path], capture_output=True)
+                                try:
+                                    subprocess.run(["npx", "--yes", "prettier", "--write", file_path], capture_output=True, timeout=10)
+                                except Exception:
+                                    pass
                 except KeyboardInterrupt:
                     c.print("\n[yellow]Tool execution interrupted by user.[/yellow]")
                     result = "Tool execution was interrupted by the user via Ctrl+C. Ask the user what to do next."

{nimcode-0.1.6 → nimcode-0.1.12}/src/nimcode/repl.py

@@ -1,5 +1,6 @@
 import os
 import sys
+import asyncio
 import shutil
 import json
 import logging
@@ -180,11 +181,21 @@ class NimcodeREPL:
         console.print()
 
         style = Style.from_dict({
-            'prompt': '#ffffff bold',
-            'bottom-toolbar': '#888888 bg:#222222',
-            'toolbar_title': '#ffffff bg:#4400aa bold',
-            'toolbar_text': '#cccccc bg:#222222',
-            'toolbar_shortcut': '#aaaaaa bg:#444444'
+            'prompt': '#00ffff bold',
+            'bottom-toolbar': '#999999 bg:#1e1e1e',
+            'toolbar_title': '#ffffff bg:#5c2d91 bold',
+            'toolbar_text': '#cccccc bg:#1e1e1e',
+            'toolbar_shortcut': '#888888 bg:#2d2d2d',
+            
+            # Claude Code inspired Autocompletion Menu
+            'completion-menu': 'bg:#2b2b2b #eeeeee',
+            'completion-menu.completion': 'bg:#2b2b2b #eeeeee',
+            'completion-menu.completion.current': 'bg:#5c2d91 #ffffff bold',
+            'scrollbar.background': 'bg:#1e1e1e',
+            'scrollbar.button': 'bg:#5c2d91',
+            
+            # Auto-suggestion (greyed out ghost text)
+            'auto-suggestion': '#666666 italic',
         })
         
         from prompt_toolkit.key_binding import KeyBindings
@@ -228,51 +239,60 @@ class NimcodeREPL:
                 ('class:toolbar_text', f' Model: {self.model} | Mode: {mode} | Tokens: {tokens} | Cost: ${cost:.4f} | Effort: {effort}{goal_ui}'),
                 ('class:toolbar_shortcut', ' [Alt+Enter] multiline '),
             ]
-        from prompt_toolkit.completion import NestedCompleter, WordCompleter, PathCompleter
+        from prompt_toolkit.completion import Completer, Completion, PathCompleter
         
-        command_completer = NestedCompleter.from_nested_dict({
-            '/help': None,
-            '/plan': None,
-            '/code': None,
-            '/models': None,
-            '/theme': WordCompleter(['monokai', 'dracula', 'nord', 'github']),
-            '/clear': None,
-            '/compact': None,
-            '/commit': None,
-            '/fix': None,
-            '/testgen': PathCompleter(),
-            '/vision': None,
-            '/voice': None,
-            '/index': None,
-            '/exit': None,
-            '/quit': None,
-            '/learn': None,
-            '/cost': None,
-            '/effort': WordCompleter(['Low', 'Medium', 'High']),
-            '/thinking': None,
-            '/add': PathCompleter(),
-            '/research': None,
-            '/swarm': None,
-            '/tdd': None,
-            '/mcp': WordCompleter(['install']),
-            '/rewind': None,
-            '/fork': None,
-            '/grill-me': None,
-            '/teleport': PathCompleter(),
-            '/buddy': None,
-            '/ultraplan': None,
-            '/bughunter': None,
-            '/security-review': None,
-            '/doctor': None,
-            '/permissions': WordCompleter(['auto', 'bypass', 'default']),
-            '/graph': None,
-            '/guardian': None,
-            '/thinkback': None,
-            '/autofix-pr': None,
-            '/terraform-god': None,
-            '/sql-tune': None,
-            '/decompile': PathCompleter(),
-        })
+        class SlashCompleter(Completer):
+            def __init__(self):
+                self.commands = [
+                    '/help', '/plan', '/code', '/models', '/theme', '/clear', '/compact', 
+                    '/commit', '/fix', '/testgen', '/vision', '/voice', '/index', '/exit', 
+                    '/quit', '/learn', '/cost', '/effort', '/thinking', '/add', '/research', 
+                    '/swarm', '/tdd', '/mcp', '/rewind', '/fork', '/grill-me', '/teleport', 
+                    '/buddy', '/ultraplan', '/bughunter', '/security-review', '/doctor', 
+                    '/permissions', '/graph', '/guardian', '/thinkback', '/autofix-pr', 
+                    '/terraform-god', '/sql-tune', '/decompile'
+                ]
+                self.subcommands = {
+                    '/theme': ['monokai', 'dracula', 'nord', 'github'],
+                    '/effort': ['Low', 'Medium', 'High'],
+                    '/mcp': ['install'],
+                    '/permissions': ['auto', 'bypass', 'default']
+                }
+                self.path_completer = PathCompleter()
+
+            def get_completions(self, document, complete_event):
+                text = document.text_before_cursor
+                parts = text.split()
+                
+                if not parts:
+                    return
+
+                if len(parts) == 1 or (len(parts) == 2 and text.endswith(' ')):
+                    if not text.endswith(' '):
+                        word = parts[0]
+                        for c in self.commands:
+                            if c.startswith(word):
+                                yield Completion(c, start_position=-len(word))
+                    else:
+                        cmd = parts[0]
+                        if cmd in self.subcommands:
+                            for sub in self.subcommands[cmd]:
+                                yield Completion(sub, start_position=0)
+                        elif cmd in ['/testgen', '/add', '/teleport', '/decompile']:
+                            yield from self.path_completer.get_completions(document, complete_event)
+                            
+                elif len(parts) >= 2:
+                    cmd = parts[0]
+                    word = parts[-1] if not text.endswith(' ') else ''
+                    
+                    if cmd in self.subcommands:
+                        for sub in self.subcommands[cmd]:
+                            if sub.startswith(word):
+                                yield Completion(sub, start_position=-len(word))
+                    elif cmd in ['/testgen', '/add', '/teleport', '/decompile']:
+                        yield from self.path_completer.get_completions(document, complete_event)
+
+        command_completer = SlashCompleter()
         
         from prompt_toolkit.lexers import PygmentsLexer
         from pygments.lexers.shell import BashLexer
@@ -290,7 +310,7 @@ class NimcodeREPL:
         
         while True:
             try:
-                user_input = await session.prompt_async("> ")
+                user_input = await session.prompt_async("❯ ")
                 if user_input.lower() in ["/exit", "/quit"]:
                     self.agent.save_history()
                     break
@@ -303,6 +323,8 @@ class NimcodeREPL:
                     table.add_row("/help", "Show this help menu")
                     table.add_row("/plan", "Enter planning mode (safe mode)")
                     table.add_row("/code", "Enter coding mode (all tools enabled)")
+                    table.add_row("/trust", "Enter trust mode (runs all tools without permission)")
+                    table.add_row("/untrust", "Disable trust mode (ask for permission)")
                     table.add_row("/models", "Select NVIDIA NIM model")
                     table.add_row("/theme <name>", "Change syntax theme (e.g., monokai)")
                     table.add_row("/clear", "Clear current context history")
@@ -530,6 +552,14 @@ class NimcodeREPL:
                     console.print("[bold magenta]Entering Code mode.[/bold magenta] Standard permissions restored.")
                     self.messages.append({"role": "system", "content": "You are now in coding mode. You may use all available tools."})
                     continue
+                elif user_input.strip() == "/trust":
+                    self.agent.permission_engine.mode = PermissionMode.BYPASS
+                    console.print("[bold red]🚨 TRUST MODE ACTIVATED: NimCode will now run all tools without asking for permission! 🚨[/bold red]")
+                    continue
+                elif user_input.strip() == "/untrust":
+                    self.agent.permission_engine.mode = PermissionMode.DEFAULT
+                    console.print("[bold green]🛡️ Trust mode disabled. NimCode will ask for permission again.[/bold green]")
+                    continue
                 elif user_input.strip().startswith("/theme"):
                     parts = user_input.strip().split()
                     if len(parts) > 1:
@@ -537,15 +567,22 @@ class NimcodeREPL:
                         save_global_setting("theme", parts[1])
                         console.print(f"[green]Theme updated to '{parts[1]}'[/green]")
                     else:
-                        from prompt_toolkit.shortcuts import radiolist_dialog
+                        from rich.table import Table
+                        from rich.prompt import Prompt
+                        
                         themes = ['monokai', 'dracula', 'nord', 'github']
-                        choices = [(t, t) for t in themes]
-                        selected_theme = await radiolist_dialog(
-                            title="Syntax Themes",
-                            text="Select a theme:",
-                            values=choices
-                        ).run_async()
-                        if selected_theme:
+                        table = Table(title="🎨 Available Syntax Themes", show_header=True, header_style="bold magenta")
+                        table.add_column("ID", style="cyan", width=4)
+                        table.add_column("Theme Name", style="white")
+                        
+                        for idx, t in enumerate(themes, 1):
+                            table.add_row(str(idx), t)
+                            
+                        console.print(table)
+                        
+                        choice = Prompt.ask("Select a theme by ID", choices=[str(i) for i in range(1, len(themes) + 1)], default="1")
+                        if choice:
+                            selected_theme = themes[int(choice) - 1]
                             self.settings["theme"] = selected_theme
                             save_global_setting("theme", selected_theme)
                             console.print(f"[green]Theme updated to '{selected_theme}'[/green]")
@@ -554,22 +591,36 @@ class NimcodeREPL:
                     continue
                 elif user_input.strip() == "/models":
                     console.print("[bold yellow]Fetching available models from NVIDIA NIM...[/bold yellow]")
-                    models = await self.client.get_available_models()
-                    from prompt_toolkit.shortcuts import radiolist_dialog
-                    choices = [(m, m) for m in models]
-                    selected_model = await radiolist_dialog(
-                        title="NVIDIA NIM Models",
-                        text="Select a model for code generation:",
-                        values=choices
-                    ).run_async()
-                    
-                    if selected_model:
-                        self.client.model = selected_model
-                        self.model = selected_model
-                        save_global_setting("model", selected_model)
-                        console.print(f"[bold green]Model changed to: {selected_model}[/bold green]")
-                    else:
-                        console.print("[yellow]Model selection cancelled.[/yellow]")
+                    try:
+                        models = await self.client.get_available_models()
+                        if not models:
+                            console.print("[red]No models returned from API.[/red]")
+                            continue
+                            
+                        from rich.table import Table
+                        from rich.prompt import Prompt
+                        
+                        table = Table(title="🤖 Available NVIDIA NIM Models", show_header=True, header_style="bold magenta")
+                        table.add_column("ID", style="cyan", width=4)
+                        table.add_column("Model Name", style="white")
+                        
+                        for idx, m in enumerate(models, 1):
+                            table.add_row(str(idx), m)
+                            
+                        console.print(table)
+                        
+                        choice = Prompt.ask("Select a model by ID (or press Enter to cancel)", choices=[str(i) for i in range(1, len(models) + 1)] + [""], default="")
+                        
+                        if choice:
+                            selected_model = models[int(choice) - 1]
+                            self.client.model = selected_model
+                            self.model = selected_model
+                            save_global_setting("model", selected_model)
+                            console.print(f"[bold green]Model changed to: {selected_model}[/bold green]")
+                        else:
+                            console.print("[yellow]Model selection cancelled.[/yellow]")
+                    except Exception as e:
+                        console.print(f"[bold red]Failed to fetch models: {e}[/bold red]")
                     continue
                 elif user_input.strip() == "/commit":
                     import subprocess
@@ -856,7 +907,6 @@ class NimcodeREPL:
                         console.print(f"\n\n[bold magenta]🔬 Subagent Research Complete for '{q}'![/bold magenta]\n{result}\n")
                         self.messages.append({"role": "system", "content": f"A background subagent completed research on '{q}'. Result:\n{result}"})
                     
-                    import asyncio
                     asyncio.create_task(bg_research(query))
                     console.print("[dim italic]Subagent spawned in background. You can continue chatting![/dim italic]")
                     continue
@@ -914,7 +964,6 @@ class NimcodeREPL:
                         
                         console.print(f"\n[bold magenta]🐝 Swarm Finished![/bold magenta]\n[bold]Review:[/bold]\n{review}")
                         
-                    import asyncio
                     asyncio.create_task(run_swarm(task))
                     continue
                 elif user_input.strip().startswith("/tdd "):
@@ -932,12 +981,11 @@ class NimcodeREPL:
                         result = await tdd_agent.run_headless(feat, max_turns=10)
                         console.print(f"\n[bold green]🧪 TDD Completed![/bold green]\n{result}")
                         
-                    import asyncio
                     asyncio.create_task(run_tdd(feature))
                     continue
                 elif user_input.strip().startswith("/"):
                     import difflib
-                    valid_commands = ["/help", "/plan", "/code", "/models", "/theme", "/clear", "/compact", "/commit", "/fix", "/exit", "/quit", "/config", "/alias", "/add", "/rewind", "/fork", "/testgen", "/vision", "/voice", "/index", "/research", "/mcp install", "/swarm", "/tdd", "/learn", "/cost", "/effort", "/thinking", "/grill-me", "/teleport", "/buddy", "/ultraplan", "/bughunter", "/security-review", "/doctor", "/permissions", "/graph", "/guardian", "/thinkback", "/autofix-pr", "/terraform-god", "/sql-tune", "/decompile"]
+                    valid_commands = ["/help", "/plan", "/code", "/trust", "/untrust", "/models", "/theme", "/clear", "/compact", "/commit", "/fix", "/exit", "/quit", "/config", "/alias", "/add", "/rewind", "/fork", "/testgen", "/vision", "/voice", "/index", "/research", "/mcp install", "/swarm", "/tdd", "/learn", "/cost", "/effort", "/thinking", "/grill-me", "/teleport", "/buddy", "/ultraplan", "/bughunter", "/security-review", "/doctor", "/permissions", "/graph", "/guardian", "/thinkback", "/autofix-pr", "/terraform-god", "/sql-tune", "/decompile"]
                     cmd_name = user_input.strip().split()[0]
                     matches = difflib.get_close_matches(cmd_name, valid_commands, n=1, cutoff=0.5)
                     if matches:
@@ -958,6 +1006,9 @@ class NimcodeREPL:
             except KeyboardInterrupt:
                 console.print("\n[bold yellow]⚠ Operation cancelled by user. (Press Ctrl+D to exit)[/bold yellow]")
                 continue
+            except asyncio.CancelledError:
+                console.print("\n[bold yellow]⚠ Operation cancelled by user. (Press Ctrl+D to exit)[/bold yellow]")
+                continue
             except EOFError:
                 break
 

{nimcode-0.1.6 → nimcode-0.1.12}/src/nimcode.egg-info/PKG-INFO

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

{nimcode-0.1.6 → nimcode-0.1.12}/tests/test_repl.py

@@ -189,11 +189,7 @@ async def test_start_repl_commands(agent):
                 # Mock run to avoid actually executing queries
                 agent.run = AsyncMock()
                 
-                class MockDialog:
-                    async def run_async(self):
-                        return "model1"
-
-                with patch("prompt_toolkit.shortcuts.radiolist_dialog", return_value=MockDialog()):
+                with patch("rich.prompt.Prompt.ask", return_value="1"):
                     try:
                         from nimcode.repl import NimcodeREPL
                         repl = NimcodeREPL(agent)

nimcode-0.1.6/README.md

@@ -1,68 +0,0 @@
-<div align="center">
-  
-# 🚀 NimCode
-
-**The Autonomous AI Coding Assistant for the NVIDIA NIM Ecosystem**
-
-[![PyPI version](https://badge.fury.io/py/nimcode.svg)](https://badge.fury.io/py/nimcode)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-*A powerful, standalone REPL and CLI agent that writes, edits, and plans code like a senior developer—powered by LLaMa 3.1 70B and the lightning-fast NVIDIA NIM API.*
-
-</div>
-
----
-
-## 🌟 Features
-
-- 🧠 **Smart Planning (`/plan`)**: Generates comprehensive, step-by-step architectural plans directly into `.nimcode/plans/`.
-- 🛠️ **Autonomous Execution (`/code`)**: Reads, writes, and tests code across your entire workspace.
-- 📸 **Vision Support (`/vision`)**: Analyze screenshots to debug UI issues or write code from design mockups.
-- 🎙️ **Voice Commands (`/voice`)**: Speak your requirements and let the agent do the typing.
-- 💾 **Continuous Learning**: Saves custom rules and instructions to `.nimcode/skills/` so it gets smarter over time.
-- 🤖 **Auto-Commits (`/commit`)**: Automatically writes descriptive, conventional git commits for your changes.
-
-## 📦 Installation
-
-NimCode is available globally via PyPI. You can install it anywhere in seconds:
-
-```bash
-pip install nimcode
-```
-
-## 🚀 Quick Start
-
-1. **Get an API Key**: Grab a free NVIDIA API key from [build.nvidia.com](https://build.nvidia.com/).
-2. **Login**: Connect your local environment by running:
-   ```bash
-   nimcode login
-   ```
-3. **Start Coding**: 
-   - Launch the interactive REPL:
-     ```bash
-     nimcode
-     ```
-   - Or run a one-off task directly from the command line:
-     ```bash
-     nimcode /plan "Build a classic Snake game using HTML5 Canvas"
-     ```
-
-## ⚙️ How it Works
-
-NimCode creates a `.nimcode` directory inside your projects. This directory acts as the "brain" for that specific workspace:
-- `.nimcode/plans/`: All your generated step-by-step markdown plans live here.
-- `.nimcode/skills/`: Any custom guidelines, framework rules, or memories you teach the agent.
-
-## 🛡️ Requirements
-
-- Python 3.8+
-- An NVIDIA NIM API Key (NIM_API_KEY)
-
-## 🤝 Contributing
-
-Contributions, issues, and feature requests are welcome! Feel free to check out our [issues page](#).
-
----
-<div align="center">
-<i>Built with ❤️ for the open-source developer community.</i>
-</div>