nimcode 0.4.0__tar.gz → 0.4.2__tar.gz

nimcode-0.4.2/PKG-INFO

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: nimcode
+Version: 0.4.2
+Summary: A standalone, robust coding agent for NVIDIA NIM models.
+Home-page: https://github.com/Batunash/nimcode
+Author: Autonomous Agent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+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: watchdog>=3.0.0
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<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 based on real documents (SDD, PRD, RFC), executes terminal commands, writes complete files, and manages your workspace.
+
+### ✅ What Works Right Now
+- **OS-Aware Agent**: Automatically detects Windows/Linux/macOS and uses the correct shell commands. No more `mkdir -p` on Windows.
+- **SDD/PRD-Aware Planning**: `/plan` mode reads your actual documents and produces implementation plans grounded in real file names, modules, and requirements—not generic PM templates.
+- **Paginated File Reading**: Large files (like SDDs) are read in chunks with `offset`/`limit` so nothing gets truncated.
+- **VS Code Deep Integration**: Native IPC communication allowing NimCode to read active editors, send patches, and act as your intelligent coding panel within VS Code.
+- **RAG & Semantic Search**: Zero-dependency TF-IDF/BM25 based indexer that instantly scans massive workspaces and retrieves context-aware code snippets.
+- **Autonomous Auto-Fixer**: The `/fix` command creates a self-healing feedback loop—runs your broken commands, analyzes tracebacks, and automatically iterates on code patches until the build passes.
+- **Multi-Model & Local Support**: Flexible `api_base_url` configuration to seamlessly switch between NVIDIA NIM, Ollama, or vLLM endpoints. Dynamic model list fetched from the API at runtime.
+- **Smart Permission Engine**: Granular control over file writes and command executions, featuring an auto-bypass mechanism and interactive `(a)ccept / (r)eject` diff previews. Non-interactive/CI mode is secure by default (Bash denied unless explicitly allowed).
+- **Robust Interactive REPL**: Multiline support (Alt+Enter), syntax highlighting, and beautiful `rich`-powered UI menus.
+- **Automated Workflows**: Automatic linting and formatting using `black`, `flake8`, and `prettier` behind the scenes.
+- **Model Context Protocol (MCP)**: Native integration for MCP tools allowing infinite extensibility.
+- **Context Management**: Auto-compact with per-model context window awareness. `/thinkback` shows real session statistics.
+- **Live Sync**: Workspace watcher automatically updates the repo map in the agent's context when files change.
+
+### 🚀 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 & Update
+
+```bash
+# First time install
+pip install nimcode
+
+# Update to latest version
+pip install --upgrade nimcode
+```
+
+> **⚠️ If NimCode shows an old version number at startup**, you likely have an older install. Run `pip install --upgrade nimcode` to get the latest fixes.
+
+## 🚀 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:
+
+### Mode Toggles & Execution
+- **`/code`**: Enter standard coding mode (default mode, prompts for dangerous actions).
+- **`/plan`**: Enter planning mode. NimCode will **read your actual documents/files first**, then write a concrete implementation plan to `.nimcode/plans/`.
+- **`/trust`**: Enter trust mode. The AI will run commands and edit files completely autonomously without asking for `(a)ccept / (r)eject`. Turn limit removed.
+- **`/untrust`**: Disable trust mode and restore permission prompts.
+
+### Interface & Settings
+- **`/models`**: Open an interactive UI to select your preferred NVIDIA NIM model.
+- **`/theme`**: Open an interactive UI to change your syntax highlighting theme.
+- **`/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.
+- **`/thinkback`**: View real session statistics (turns, token estimates, message history).
+
+### 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).
+- **`/ultraplan <task>`**: Generate a master ultra-detailed, dependency-graphed execution plan.
+
+### 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.
+- **`/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 **agent's personal workspace**, not your project's source code:
+- `.nimcode/plans/`: All generated step-by-step markdown plans live here.
+- `.nimcode/skills/`: Custom guidelines, framework rules, or memories you teach the agent.
+- `.nimcode/history/`: File backups for `/undo` capabilities.
+
+> **Important**: NimCode writes your actual source code to your project root, not inside `.nimcode/`. The `.nimcode/` folder is only for the agent's internal notes.
+
+### 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
+{
+    "model": "meta/llama-3.1-70b-instruct",
+    "api_base_url": "https://integrate.api.nvidia.com/v1",
+    "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 |
+|---------|---------|-------------|
+| `model` | `meta/llama-3.1-70b-instruct` | Default LLM model |
+| `api_base_url` | NVIDIA NIM endpoint | Switch to Ollama/vLLM by changing this |
+| `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 |
+
+---
+
+## 📋 Changelog
+
+### v0.4.0 (Latest)
+- 🐛 **System prompt is now OS-aware**: Correctly uses Windows (`mkdir`, `copy`) or Unix (`mkdir -p`, `cp`) commands based on the detected OS
+- 🐛 **Plan quality massively improved**: `/plan` mode now reads your actual documents (SDD, PRD, etc.) and generates concrete plans with real file paths and code — not generic PM templates
+- 🐛 **Fixed `_distill_memory` 400 error**: Context compaction no longer crashes with a Bad Request error
+- 🐛 **Fixed version tracking**: `CURRENT_VERSION` was hardcoded as `3.0.0`; now reads from a single source of truth
+- 🐛 **`/thinkback` shows real data**: Previously showed hardcoded fake table; now shows actual session statistics
+- 🐛 **LiveSync fixed**: `repo_map` module was missing, causing the workspace watcher to silently fail
+- 🔒 **Security**: Non-interactive mode no longer auto-approves Bash commands
+- ⚙️ **Fully configurable**: `max_turns`, `max_tokens`, `max_retries`, retry delays all configurable via settings
+- ⚙️ **Dynamic model list**: Fetched from NIM API at runtime with fallback to known models
+- ⚙️ **Paginated file reading**: `Read` tool supports `offset`/`limit` for large files
+- ✅ **178 tests passing**
+
+### v0.3.4
+- All timeouts configurable via settings (0 = infinite)
+
+---
+
+## 🛡️ 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.4.0 → nimcode-0.4.2}/README.md

@@ -15,17 +15,22 @@
 
 ## 🌟 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. 
+NimCode is your autonomous coding pair-programmer. Built with a rich interactive terminal interface, it doesn't just autocomplete code—it plans architectures based on real documents (SDD, PRD, RFC), executes terminal commands, writes complete files, and manages your workspace.
 
-### 🛠️ What We've Built So Far
+### ✅ What Works Right Now
+- **OS-Aware Agent**: Automatically detects Windows/Linux/macOS and uses the correct shell commands. No more `mkdir -p` on Windows.
+- **SDD/PRD-Aware Planning**: `/plan` mode reads your actual documents and produces implementation plans grounded in real file names, modules, and requirements—not generic PM templates.
+- **Paginated File Reading**: Large files (like SDDs) are read in chunks with `offset`/`limit` so nothing gets truncated.
 - **VS Code Deep Integration**: Native IPC communication allowing NimCode to read active editors, send patches, and act as your intelligent coding panel within VS Code.
 - **RAG & Semantic Search**: Zero-dependency TF-IDF/BM25 based indexer that instantly scans massive workspaces and retrieves context-aware code snippets.
-- **Autonomous Auto-Fixer**: The `/fix` command creates a self-healing feedback loop—it runs your broken commands, analyzes the tracebacks, and automatically iterates on code patches until the build passes.
-- **Multi-Model & Local Support**: Flexible `api_base_url` configuration to seamlessly switch between NVIDIA NIM, Ollama, or vLLM endpoints.
-- **Smart Permission Engine**: Granular control over file writes and command executions, featuring an auto-bypass mechanism and interactive `(a)ccept / (r)eject` diff previews.
+- **Autonomous Auto-Fixer**: The `/fix` command creates a self-healing feedback loop—runs your broken commands, analyzes tracebacks, and automatically iterates on code patches until the build passes.
+- **Multi-Model & Local Support**: Flexible `api_base_url` configuration to seamlessly switch between NVIDIA NIM, Ollama, or vLLM endpoints. Dynamic model list fetched from the API at runtime.
+- **Smart Permission Engine**: Granular control over file writes and command executions, featuring an auto-bypass mechanism and interactive `(a)ccept / (r)eject` diff previews. Non-interactive/CI mode is secure by default (Bash denied unless explicitly allowed).
 - **Robust Interactive REPL**: Multiline support (Alt+Enter), syntax highlighting, and beautiful `rich`-powered UI menus.
 - **Automated Workflows**: Automatic linting and formatting using `black`, `flake8`, and `prettier` behind the scenes.
 - **Model Context Protocol (MCP)**: Native integration for MCP tools allowing infinite extensibility.
+- **Context Management**: Auto-compact with per-model context window awareness. `/thinkback` shows real session statistics.
+- **Live Sync**: Workspace watcher automatically updates the repo map in the agent's context when files change.
 
 ### 🚀 What We're Working On (Roadmap)
 - **Sub-agent Swarms**: Perfecting `/delegate` and `/swarm` to distribute complex tasks among specialized AI roles.
@@ -35,14 +40,18 @@ NimCode is your autonomous coding pair-programmer. Built with a rich interactive
 
 ---
 
-## 📦 Installation
-
-NimCode is available globally via PyPI. You can install it anywhere in seconds:
+## 📦 Installation & Update
 
 ```bash
+# First time install
 pip install nimcode
+
+# Update to latest version
+pip install --upgrade nimcode
 ```
 
+> **⚠️ If NimCode shows an old version number at startup**, you likely have an older install. Run `pip install --upgrade nimcode` to get the latest fixes.
+
 ## 🚀 Quick Start
 
 1. **Get an API Key**: Grab a free NVIDIA API key from [build.nvidia.com](https://build.nvidia.com/).
@@ -64,17 +73,17 @@ pip install nimcode
 
 ## 💻 Complete Command Reference
 
-Inside the `nimcode` REPL, you can type natural language or use any of the following slash commands to trigger specific workflows:
+Inside the `nimcode` REPL, you can type natural language or use any of the following slash commands:
 
 ### 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`.
+- **`/plan`**: Enter planning mode. NimCode will **read your actual documents/files first**, then write a concrete implementation plan to `.nimcode/plans/`.
+- **`/trust`**: Enter trust mode. The AI will run commands and edit files completely autonomously without asking for `(a)ccept / (r)eject`. Turn limit removed.
 - **`/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).
+- **`/models`**: Open an interactive UI to select your preferred NVIDIA NIM model.
+- **`/theme`**: Open an interactive UI to change your syntax highlighting theme.
 - **`/config`**: View and edit global NimCode configuration settings.
 
 ### Workspace & Context Management
@@ -83,6 +92,7 @@ Inside the `nimcode` REPL, you can type natural language or use any of the follo
 - **`/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.
+- **`/thinkback`**: View real session statistics (turns, token estimates, message history).
 
 ### Project & Search
 - **`/index`**: Index the current project files to enable lightning-fast Semantic Search.
@@ -99,9 +109,7 @@ Inside the `nimcode` REPL, you can type natural language or use any of the follo
 - **`/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`.
+- **`/ultraplan <task>`**: Generate a master ultra-detailed, dependency-graphed execution plan.
 
 ### AI & Agents
 - **`/delegate <role> <task>`**: Spawn an independent sub-agent with a specific role to handle a background task.
@@ -109,24 +117,27 @@ Inside the `nimcode` REPL, you can type natural language or use any of the follo
 - **`/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 creates a `.nimcode` directory inside your projects. This directory acts as the **agent's personal workspace**, not your project's source code:
+- `.nimcode/plans/`: All generated step-by-step markdown plans live here.
+- `.nimcode/skills/`: Custom guidelines, framework rules, or memories you teach the agent.
 - `.nimcode/history/`: File backups for `/undo` capabilities.
 
+> **Important**: NimCode writes your actual source code to your project root, not inside `.nimcode/`. The `.nimcode/` folder is only for the agent's internal notes.
+
 ### 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
 {
+    "model": "meta/llama-3.1-70b-instruct",
+    "api_base_url": "https://integrate.api.nvidia.com/v1",
     "timeout_command": 1200,
     "timeout_llm": 120,
     "timeout_format": 10,
@@ -143,6 +154,8 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 | Setting | Default | Description |
 |---------|---------|-------------|
+| `model` | `meta/llama-3.1-70b-instruct` | Default LLM model |
+| `api_base_url` | NVIDIA NIM endpoint | Switch to Ollama/vLLM by changing this |
 | `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 |
@@ -155,6 +168,28 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 | `retry_max_delay` | 60.0 | Max delay cap for backoff (seconds) |
 | `allow_bash_non_interactive` | false | Allow Bash commands in non-interactive/CI mode |
 
+---
+
+## 📋 Changelog
+
+### v0.4.0 (Latest)
+- 🐛 **System prompt is now OS-aware**: Correctly uses Windows (`mkdir`, `copy`) or Unix (`mkdir -p`, `cp`) commands based on the detected OS
+- 🐛 **Plan quality massively improved**: `/plan` mode now reads your actual documents (SDD, PRD, etc.) and generates concrete plans with real file paths and code — not generic PM templates
+- 🐛 **Fixed `_distill_memory` 400 error**: Context compaction no longer crashes with a Bad Request error
+- 🐛 **Fixed version tracking**: `CURRENT_VERSION` was hardcoded as `3.0.0`; now reads from a single source of truth
+- 🐛 **`/thinkback` shows real data**: Previously showed hardcoded fake table; now shows actual session statistics
+- 🐛 **LiveSync fixed**: `repo_map` module was missing, causing the workspace watcher to silently fail
+- 🔒 **Security**: Non-interactive mode no longer auto-approves Bash commands
+- ⚙️ **Fully configurable**: `max_turns`, `max_tokens`, `max_retries`, retry delays all configurable via settings
+- ⚙️ **Dynamic model list**: Fetched from NIM API at runtime with fallback to known models
+- ⚙️ **Paginated file reading**: `Read` tool supports `offset`/`limit` for large files
+- ✅ **178 tests passing**
+
+### v0.3.4
+- All timeouts configurable via settings (0 = infinite)
+
+---
+
 ## 🛡️ Requirements
 
 - Python 3.8+

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

@@ -1,5 +1,6 @@
 from setuptools import setup, find_packages
 import os
+from pathlib import Path
 
 # Single source of truth for version
 version = {}
@@ -25,4 +26,8 @@ setup(
     },
     author="Autonomous Agent",
     description="A standalone, robust coding agent for NVIDIA NIM models.",
+    long_description=Path("README.md").read_text(encoding="utf-8"),
+    long_description_content_type="text/markdown",
+    url="https://github.com/Batunash/nimcode",
+    python_requires=">=3.8",
 )

nimcode-0.4.2/src/nimcode/__version__.py

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

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

@@ -30,11 +30,12 @@ Format:
 
 Available Tools:
 - Bash: {{"tool": "Bash", "args": {{"command": "string"}}}}
-- Read: {{"tool": "Read", "args": {{"file_path": "string"}}}}
+- Read: {{"tool": "Read", "args": {{"file_path": "string", "offset": "int (optional, 1-based line number to start from)", "limit": "int (optional, max number of lines to return)"}}}}
 - Write: {{"tool": "Write", "args": {{"file_path": "string", "content": "string"}}}}
 - Edit: {{"tool": "Edit", "args": {{"file_path": "string", "old_string": "string", "new_string": "string"}}}}
 - Glob: {{"tool": "Glob", "args": {{"pattern": "string"}}}}
 - Grep: {{"tool": "Grep", "args": {{"query": "string", "directory": "string"}}}}
+- AskQuestion: {{"tool": "AskQuestion", "args": {{"question": "string", "options": ["string (optional list of choices)"]}}}} — Ask the USER a clarifying question when requirements are ambiguous. Wait for their reply before continuing. Preferred in /grill-me, /plan, and whenever you lack information.
 
 Before calling a tool, you may optionally use a <think> block to reason about your plan.
 <think>
@@ -173,21 +174,40 @@ class Agent:
         
         self.permission_engine = PermissionEngine(mode=permission_mode)
 
+    def _session_history_path(self) -> str:
+        """Path for serialized session history.
+
+        Uses a fresh '.nimcode/sessions/' subdir — NOT '.nimcode/history/' — because
+        repl.py's PromptSession already uses '.nimcode/history' as a *file* for
+        prompt_toolkit FileHistory. A path cannot be both a file and a directory:
+        trying to makedirs('.nimcode/history') while FileHistory treats it as a file
+        raises NotADirectoryError, which save_history's try/except would silently
+        swallow (re-breaking --resume). 'sessions' is collision-free. This also keeps
+        session JSON separate from NIMCODE.md, the human-readable log appended by
+        MemoryManager.log_to_nimcode_md — fixing the original Bug B (two producers
+        overwriting each other -> JSONDecodeError on load)."""
+        return os.path.join(os.getcwd(), ".nimcode", "sessions", "session.json")
+
     def save_history(self):
-        """Saves current conversation to NIMCODE.md"""
+        """Saves current conversation (machine-readable JSON) to .nimcode/sessions/session.json."""
         try:
             import json
-            with open("NIMCODE.md", "w", encoding="utf-8") as f:
+            path = self._session_history_path()
+            # Ensure the parent dir exists (handles one-shot `nimcode "prompt"` and
+            # `--resume` paths that don't go through the REPL's .nimcode bootstrap).
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            with open(path, "w", encoding="utf-8") as f:
                 json.dump(self.messages, f)
         except Exception as e:
             logger.error(f"Failed to save history: {e}")
 
     def load_history(self):
-        """Loads conversation from NIMCODE.md"""
+        """Loads conversation from .nimcode/sessions/session.json (if present)."""
         try:
             import json
-            if os.path.exists("NIMCODE.md"):
-                with open("NIMCODE.md", "r", encoding="utf-8") as f:
+            path = self._session_history_path()
+            if os.path.exists(path):
+                with open(path, "r", encoding="utf-8") as f:
                     self.messages = json.load(f)
         except Exception as e:
             logger.error(f"Failed to load history: {e}")

{nimcode-0.4.0 → nimcode-0.4.2}/src/nimcode/cli.py

@@ -1,5 +1,6 @@
 import argparse
 import asyncio
+import logging
 import os
 import sys
 from rich.console import Console
@@ -7,6 +8,7 @@ from .agent import Agent
 from .config import load_settings, save_global_setting
 from .permissions import PermissionMode
 
+logger = logging.getLogger(__name__)
 console = Console()
 
 def run_login():
@@ -24,11 +26,14 @@ def run_login():
 
 def run_doctor():
     console.print("[bold cyan]NimCode Doctor[/bold cyan] - Diagnostics")
-    key = os.environ.get("NIM_API_KEY")
-    if key:
-        console.print("[green][OK][/green] NIM_API_KEY environment variable is set.")
+    env_key = os.environ.get("NIM_API_KEY")
+    settings = load_settings()
+    settings_key = settings.get("api_key")
+    if env_key or settings_key:
+        source = "environment variable" if env_key else "settings.json (`nimcode login`)"
+        console.print(f"[green][OK][/green] NIM API key found via {source}.")
     else:
-        console.print("[red][X][/red] NIM_API_KEY environment variable is missing.")
+        console.print("[red][X][/red] No NIM API key found. Set NIM_API_KEY or run `nimcode login`.")
     
     # Check .nimcode existence
     if os.path.exists(".nimcode"):
@@ -43,26 +48,36 @@ def install_hook():
     if not os.path.exists(".git"):
         console.print("[red][X][/red] Not a git repository.")
         return
-        
+
     hook_path = os.path.join(".git", "hooks", "prepare-commit-msg")
     with open(hook_path, "w", encoding="utf-8") as f:
         f.write("#!/bin/sh\n")
         f.write("# NimCode auto-commit hook\n")
+        f.write("# Only generate a message if the user hasn't supplied one.\n")
         f.write("if [ -z \"$(cat $1)\" ]; then\n")
-        f.write("  nimcode /commit > $1\n")
+        f.write("  nimcode \"Generate a conventional commit message for the currently staged changes. Use the Bash tool to run 'git diff --staged', then write ONLY the commit message (no preamble, no explanation) to stdout.\" > \"$1\"\n")
         f.write("fi\n")
-    
-    import stat
-    os.chmod(hook_path, os.stat(hook_path).st_mode | stat.S_IEXEC)
+
+    # Make it executable. On Windows the stat bit is a no-op, but Git for Windows
+    # runs hooks regardless; guard against platforms where chmod is unsupported.
+    try:
+        import stat
+        os.chmod(hook_path, os.stat(hook_path).st_mode | stat.S_IEXEC)
+    except Exception as e:
+        logger.debug("Could not set executable bit on hook (non-fatal): %s", e)
     console.print(f"[green][OK][/green] Git hook installed to {hook_path}")
 
 def _silence_anyio_errors():
     import sys
     original_hook = sys.unraisablehook
     def custom_unraisablehook(unraisable):
+        # These are known teardown-noise patterns from anyio/MCP that surface on Ctrl+C.
+        # Log at debug (traceable) instead of silently swallowing, so genuine errors still surface.
         if unraisable.exc_type == RuntimeError and "exit cancel scope in a different task" in str(unraisable.exc_value):
+            logger.debug("anyio cancel-scope teardown noise (suppressed): %s", unraisable.exc_value)
             return
         if unraisable.exc_type == BaseExceptionGroup and "unhandled errors in a TaskGroup" in str(unraisable.exc_value):
+            logger.debug("anyio TaskGroup teardown noise (suppressed): %s", unraisable.exc_value)
             return
         original_hook(unraisable)
     sys.unraisablehook = custom_unraisablehook
@@ -87,9 +102,9 @@ def main():
     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("--max-turns", "-t", type=int, default=30, help="Maximum number of turns the agent is allowed to run.")
+    parser.add_argument("--max-turns", "-t", type=int, default=None, help="Maximum number of turns the agent is allowed to run. If omitted, uses settings.json max_turns (default 200; 0 = unlimited).")
     parser.add_argument("--permission-mode", "-p", type=PermissionMode, choices=list(PermissionMode), default=PermissionMode.DEFAULT, help="Permission mode for mutating tools.")
-    parser.add_argument("--resume", "-r", action="store_true", help="Resume from the last session stored in NIMCODE.md.")
+    parser.add_argument("--resume", "-r", action="store_true", help="Resume from the last session stored in .nimcode/sessions/session.json.")
     
     args = parser.parse_args()
     
@@ -127,10 +142,14 @@ def main():
             msg = context.get("message", "")
             exception = context.get("exception", None)
             if "unhandled errors in a TaskGroup" in str(msg) or "unhandled errors in a TaskGroup" in str(exception):
+                logger.debug("TaskGroup teardown noise (suppressed): %s", exception or msg)
                 return
             if exception and isinstance(exception, RuntimeError) and "exit cancel scope in a different task" in str(exception):
+                logger.debug("anyio cancel-scope teardown noise (suppressed): %s", exception)
                 return
-            if "asynchronous generator" in str(msg):
+            # Only swallow the specific shutdown-warning shapes, not all async generator messages.
+            if "asynchronous generator" in str(msg) and ("never awaited" in str(msg) or "GeneratorExit" in str(msg)):
+                logger.debug("async generator teardown noise (suppressed): %s", msg)
                 return
             loop.default_exception_handler(context)
         loop.set_exception_handler(custom_exception_handler)
@@ -139,25 +158,32 @@ def main():
             await repl.start_repl()
         except asyncio.CancelledError:
             pass
+        except KeyboardInterrupt:
+            console.print("\n[bold yellow]Goodbye![/bold yellow]")
 
     piped_input = None
     if not sys.stdin.isatty():
         piped_input = sys.stdin.read().strip()
 
-    if piped_input:
-        console.print(f"[bold green]Starting NimCode[/bold green] with model [cyan]{args.model}[/cyan]")
-        prompt = f"{piped_input}\n\n{args.prompt or ''}".strip()
-        console.print(f"Task (with piped input): {prompt}")
-        asyncio.run(agent.run(prompt))
-    elif args.prompt:
-        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))
-    else:
-        from .repl import NimcodeREPL
-        repl = NimcodeREPL(agent)
-        asyncio.run(safe_start_repl(repl))
-    
+    try:
+        if piped_input:
+            console.print(f"[bold green]Starting NimCode[/bold green] with model [cyan]{args.model}[/cyan]")
+            prompt = f"{piped_input}\n\n{args.prompt or ''}".strip()
+            console.print(f"Task (with piped input): {prompt}")
+            asyncio.run(agent.run(prompt))
+        elif args.prompt:
+            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))
+        else:
+            from .repl import NimcodeREPL
+            repl = NimcodeREPL(agent)
+            asyncio.run(safe_start_repl(repl))
+    except KeyboardInterrupt:
+        # Ctrl+C during an active async stream/await — graceful exit, no traceback.
+        console.print("\n[bold yellow]Interrupted. Exiting NimCode.[/bold yellow]")
+        return
+
     # We don't print "Done!" for REPL to keep it clean on exit
     if args.prompt or piped_input:
         console.print("[bold green]Done![/bold green]")