nimcode 0.5.2__tar.gz → 0.5.4__tar.gz

{nimcode-0.5.2 → nimcode-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.5.2
+Version: 0.5.4
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent
@@ -193,7 +193,13 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ## 📋 Changelog
 
-### v0.5.2 (Latest)
+### v0.5.4 (Latest)
+- 🐛 **Bug Fix**: Fixed a bug where the `Read` tool would crash with a `TypeError` if an LLM provided the `offset` and `limit` arguments as strings (e.g. `'1'`) instead of integers.
+
+### v0.5.3
+- 🧭 **Phase/Task Plan Architecture**: `/plan` mode now forces the AI to output plans with meticulous Phase -> Task -> Checklist hierarchy (inspired by Claude Code), fixing superficial plan generation.
+
+### v0.5.2
 - 🧠 **Autonomous Marathon Runner**: Capable of running non-stop for 5-6 hours without drifting from the main plan.
 - 🧪 **Native TestRunner**: NimCode can now run your test suites (`pytest`, `npm test`, `go test`) and self-heal its code until the tests pass.
 - 🗺️ **Semantic AST Explorer**: `GetCodeOutline` tool added for instant navigation within large files (functions/classes with line numbers) instead of reading thousands of lines.

{nimcode-0.5.2 → nimcode-0.5.4}/README.md

@@ -172,7 +172,13 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ## 📋 Changelog
 
-### v0.5.2 (Latest)
+### v0.5.4 (Latest)
+- 🐛 **Bug Fix**: Fixed a bug where the `Read` tool would crash with a `TypeError` if an LLM provided the `offset` and `limit` arguments as strings (e.g. `'1'`) instead of integers.
+
+### v0.5.3
+- 🧭 **Phase/Task Plan Architecture**: `/plan` mode now forces the AI to output plans with meticulous Phase -> Task -> Checklist hierarchy (inspired by Claude Code), fixing superficial plan generation.
+
+### v0.5.2
 - 🧠 **Autonomous Marathon Runner**: Capable of running non-stop for 5-6 hours without drifting from the main plan.
 - 🧪 **Native TestRunner**: NimCode can now run your test suites (`pytest`, `npm test`, `go test`) and self-heal its code until the tests pass.
 - 🗺️ **Semantic AST Explorer**: `GetCodeOutline` tool added for instant navigation within large files (functions/classes with line numbers) instead of reading thousands of lines.

nimcode-0.5.4/src/nimcode/__version__.py

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

{nimcode-0.5.2 → nimcode-0.5.4}/src/nimcode/agent.py

@@ -61,16 +61,17 @@ PLANNING MODE INSTRUCTIONS:
 When in /plan mode or asked to create a plan:
 1. FIRST: Read the project structure using Glob and Read tools. Understand what already exists.
 2. SECOND: Analyze the codebase — read key files, understand the architecture, dependencies, and patterns.
-3. THIRD: Write a DETAILED, ACTIONABLE plan that references actual files and code in the project.
-4. Your plan must include:
-   - Specific files to create/modify (with full paths)
-   - Actual code snippets or pseudocode for each change
-   - Dependencies to install
-   - Testing strategy
-   - Step-by-step execution order
+3. THIRD: Write an EXTREMELY DETAILED, EXHAUSTIVE, ACTIONABLE plan that references actual files and code in the project.
+4. Your plan MUST be structured into PHASES and TASKS:
+   - Break the project down into logical PHASES (e.g., Phase 1: Database Setup, Phase 2: Core API, Phase 3: Frontend).
+   - Under EACH Phase, create a massive list of highly specific TASKS.
+   - Under EACH Task, create a checklist of micro-steps (`- [ ]`) containing:
+     * Specific files to create/modify (with full paths)
+     * Actual code snippets, function signatures, or exact DB schemas
+     * Testing strategy (exact test file names and commands)
 5. NEVER write generic project management templates (stakeholders, timelines, resources).
 6. NEVER use placeholders like [Insert Date] or [Insert Dependencies].
-7. A good plan is one that another developer could follow to implement the feature without asking questions.
+7. NEVER be brief. Err on the side of writing too much detail. A good plan is a complete technical specification and a giant task checklist that another developer could blindly follow to implement the feature step-by-step.
 
 CODE EXECUTION INSTRUCTIONS:
 When asked to "execute", "implement", or "build" something:

{nimcode-0.5.2 → nimcode-0.5.4}/src/nimcode/repl.py

@@ -444,17 +444,17 @@ class NimcodeREPL:
                         "   - Write the plan directly to '.nimcode/plans/<name_timestamp>.md'.\n"
                         "   - Use this strict technical structure: # Title, ## Context, ## Root Cause Analysis, ## Execution Plan (file-by-file with line numbers/snippets), ## Verification.\n"
                         "3. IF it is a 'From-Scratch / Major Architecture' task:\n"
-                        "   - Work AUTONOMOUSLY in a loop using your file-writing tools to generate a SINGLE, EXTREMELY DETAILED master plan file (e.g. '.nimcode/plans/<name>.md').\n"
-                        "   - Step A (Drafting): Write the initial outline to the file (High-level Phase names). Do NOT write code, pseudocode, or DB schemas.\n"
-                        "   - Step B (Iterative Expansion): Read the file, expand ONLY Phase 1 with extremely detailed 'Tasks', 'Acceptance Criteria', and 'Implementation Guidelines'. Overwrite the file with the updated content.\n"
-                        "   - Step C: Repeat Step B for Phase 2, Phase 3, etc., updating the same single file until all phases are fully detailed in Project Manager style.\n"
-                        "   - Step D: After all phases are detailed, overwrite '.nimcode/active_plan.txt' with the master plan's path.\n"
+                        "   - Generate a SINGLE, EXTREMELY DETAILED master plan file (e.g. '.nimcode/plans/<name>.md').\n"
+                        "   - Structure the plan meticulously into PHASES (e.g., Phase 1: Database Setup, Phase 2: Core API).\n"
+                        "   - Under EVERY Phase, create a massive list of highly specific TASKS.\n"
+                        "   - Each Task MUST contain a checklist of micro-steps with exact file paths and logic (e.g., `- [ ] Create src/api/user.py with X, Y, Z functions`).\n"
+                        "   - Write the entire exhaustive plan into the file using your file-writing tools.\n"
                         "4. General Rules:\n"
                         "   - STRICT FIDELITY: You MUST absolutely respect the languages, frameworks, endpoints, tables, and features mentioned in the user's project files or SDD. Do NOT default to Python/Pytest if another language is specified. Do NOT omit database tables. Do NOT generalize specific endpoints into 'REST API'.\n"
                         "   - BUSINESS LOGIC: Do not ignore 'non-technical' sections like Monetization, ASO, or Affiliate integrations. They MUST be included as explicit tasks.\n"
                         "   - Quote real names, modules, and requirements. Do not invent generic projects.\n"
                         "   - NEVER output a generic software-lifecycle template (Phase1: MVP / Design / Development) unless instructed. Focus on code, DB schemas, and technical choices.\n"
-                        "   - After writing any plan file, overwrite '.nimcode/active_plan.txt' with the file's path."
+                        "   - After writing any plan file, ALWAYS overwrite '.nimcode/active_plan.txt' with the file's path."
                     )})
                     continue
                 elif user_input.strip().startswith("/teleport"):

{nimcode-0.5.2 → nimcode-0.5.4}/src/nimcode/tools.py

@@ -399,6 +399,12 @@ class ToolRegistry:
 
     @staticmethod
     def _execute_read(file_path: str, cwd: str, offset: int = 1, limit: int = 0) -> str:
+        try:
+            offset = max(1, int(offset))
+            limit = max(0, int(limit))
+        except ValueError:
+            return "Error executing Read: 'offset' and 'limit' must be integers."
+
         full_path = os.path.join(cwd, file_path)
         if not os.path.exists(full_path):
             raise ToolError(f"File not found: {file_path}")
@@ -417,7 +423,6 @@ class ToolRegistry:
             all_lines = f.readlines()
 
         total = len(all_lines)
-        offset = max(1, int(offset))
 
         # No limit → whole file (and cache it).
         if limit == 0:

{nimcode-0.5.2 → nimcode-0.5.4}/src/nimcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.5.2
+Version: 0.5.4
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent
@@ -193,7 +193,13 @@ NimCode's behavior can be fully customized through `~/.nimcode/settings.json` (g
 
 ## 📋 Changelog
 
-### v0.5.2 (Latest)
+### v0.5.4 (Latest)
+- 🐛 **Bug Fix**: Fixed a bug where the `Read` tool would crash with a `TypeError` if an LLM provided the `offset` and `limit` arguments as strings (e.g. `'1'`) instead of integers.
+
+### v0.5.3
+- 🧭 **Phase/Task Plan Architecture**: `/plan` mode now forces the AI to output plans with meticulous Phase -> Task -> Checklist hierarchy (inspired by Claude Code), fixing superficial plan generation.
+
+### v0.5.2
 - 🧠 **Autonomous Marathon Runner**: Capable of running non-stop for 5-6 hours without drifting from the main plan.
 - 🧪 **Native TestRunner**: NimCode can now run your test suites (`pytest`, `npm test`, `go test`) and self-heal its code until the tests pass.
 - 🗺️ **Semantic AST Explorer**: `GetCodeOutline` tool added for instant navigation within large files (functions/classes with line numbers) instead of reading thousands of lines.

nimcode-0.5.2/src/nimcode/__version__.py

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