neuroncli 2.3.0__tar.gz → 3.0.0__tar.gz

{neuroncli-2.3.0 → neuroncli-3.0.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: neuroncli
-Version: 2.3.0
-Summary: AI Coding Agent — Free Claude Code alternative powered by Kimi K2.5 + Ollama
+Version: 3.0.0
+Summary: AI Coding Agent — Free Claude Code alternative. Native Rust binary with plan mode, shell escapes, and Azure AI + OpenRouter support.
 Author-email: Rahul S <rahultech72216@gmail.com>
 License: MIT
 Project-URL: Homepage, https://zero-x.live
 Project-URL: Repository, https://github.com/RAHUL-DevelopeRR/neuroncli
 Project-URL: Issues, https://github.com/RAHUL-DevelopeRR/neuroncli/issues
-Keywords: ai,coding,agent,cli,llm,kimi,ollama,code-assistant
+Keywords: ai,coding,agent,cli,llm,claude-code,rust,code-assistant,neuron
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{neuroncli-2.3.0 → neuroncli-3.0.0}/neuroncli/cli.py

@@ -353,6 +353,19 @@ def main(argv: list[str] | None = None) -> int:
         except Exception:
             pass
 
+    # ── Try native Rust binary first ─────────────────────────
+
+    native = _find_native_binary()
+    if native:
+        import subprocess
+        args_list = argv if argv is not None else sys.argv[1:]
+        try:
+            result = subprocess.run([native] + args_list)
+            return result.returncode
+        except (OSError, FileNotFoundError):
+            pass  # Fall through to Python implementation
+
+    # ── Python fallback ──────────────────────────────────────
     parser = build_parser()
     args = parser.parse_args(argv)
 
@@ -405,5 +418,35 @@ def main(argv: list[str] | None = None) -> int:
         return 0
 
 
+def _find_native_binary() -> str | None:
+    """Locate the native Rust binary — bundled in package or in PATH."""
+    import shutil
+
+    # Check bundled binary in package
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    ext = ".exe" if sys.platform == "win32" else ""
+    bundled = os.path.join(pkg_dir, "bin", f"neuron{ext}")
+    if os.path.isfile(bundled) and os.access(bundled, os.X_OK):
+        return bundled
+
+    # Check PATH (but not ourselves — avoid infinite recursion)
+    path_binary = shutil.which(f"neuron{ext}")
+    if path_binary:
+        # Verify it's the Rust binary by checking --version output
+        import subprocess
+        try:
+            result = subprocess.run(
+                [path_binary, "--version"],
+                capture_output=True, text=True, timeout=3
+            )
+            if "NeuronCLI" in result.stdout:
+                return path_binary
+        except (OSError, subprocess.TimeoutExpired):
+            pass
+
+    return None
+
+
 if __name__ == "__main__":
     raise SystemExit(main())
+

{neuroncli-2.3.0 → neuroncli-3.0.0}/neuroncli/openrouter_client.py

@@ -1,220 +1,231 @@
-"""NeuronCLI — OpenRouter HTTP streaming client. Zero external dependencies.
-
-Supports reasoning models (Kimi K2.5) where the response has both
-a `reasoning` field (chain-of-thought) and a `content` field (final answer).
-"""
-
-from __future__ import annotations
-
-import json
-import urllib.error
-import urllib.request
-from dataclasses import dataclass
-from typing import Generator
-
-from .config import AgentConfig
-
-
-class OpenRouterConnectionError(Exception):
-    """Raised when the OpenRouter API is unreachable or returns an error."""
-    pass
-
-
-@dataclass(frozen=True)
-class ChatMessage:
-    """A single message in the conversation."""
-    role: str       # "system", "user", "assistant"
-    content: str
-
-    def to_dict(self) -> dict[str, str]:
-        return {"role": self.role, "content": self.content}
-
-
-class OpenRouterClient:
-    """
-    HTTP client for OpenRouter's OpenAI-compatible /api/v1/chat/completions.
-    Uses only stdlib — no pip dependencies needed.
-
-    Handles reasoning models (like Kimi K2.5) that emit:
-      - `delta.reasoning` tokens (thinking, shown dimmed)
-      - `delta.content` tokens (final answer)
-    """
-
-    API_BASE = "https://openrouter.ai/api/v1"
-
-    def __init__(self, config: AgentConfig | None = None):
-        self.config = config or AgentConfig.from_env()
-
-    def health_check(self) -> bool:
-        """Check if OpenRouter API is reachable and the API key is valid."""
-        try:
-            req = urllib.request.Request(
-                f"{self.API_BASE}/models",
-                headers=self._headers(),
-            )
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                return resp.status == 200
-        except (urllib.error.URLError, OSError):
-            return False
-
-    def list_models(self) -> list[str]:
-        """List coding-relevant models from OpenRouter."""
-        try:
-            req = urllib.request.Request(
-                f"{self.API_BASE}/models",
-                headers=self._headers(),
-            )
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                data = json.loads(resp.read().decode())
-                models = data.get("data", [])
-                keywords = ("kimi", "deepseek", "qwen", "codestral", "claude", "gemini")
-                names = [m["id"] for m in models
-                         if any(k in m["id"].lower() for k in keywords)]
-                return sorted(names)[:25]
-        except (urllib.error.URLError, OSError):
-            return []
-
-    def chat(self, messages: list[ChatMessage], model: str | None = None) -> str:
-        """Send a chat request and return the full response text."""
-        payload = self._build_payload(messages, model, stream=False)
-        data = self._post(payload)
-        choice = data.get("choices", [{}])[0]
-        msg = choice.get("message", {})
-        # Kimi K2.5 reasoning models: content may be in `content` or `reasoning`
-        content = msg.get("content") or ""
-        if not content:
-            content = msg.get("reasoning", "")
-        return content
-
-    def chat_stream(
-        self,
-        messages: list[ChatMessage],
-        model: str | None = None,
-    ) -> Generator[str, None, None]:
-        """
-        Stream a chat response token by token.
-        
-        For reasoning models (Kimi K2.5), yields:
-          - reasoning tokens with a dim prefix (hidden thinking)
-          - content tokens normally (the actual response)
-        """
-        payload = self._build_payload(messages, model, stream=True)
-        body = json.dumps(payload).encode("utf-8")
-        req = urllib.request.Request(
-            f"{self.API_BASE}/chat/completions",
-            data=body,
-            headers=self._headers(json_body=True),
-            method="POST",
-        )
-
-        try:
-            resp = urllib.request.urlopen(req, timeout=300)
-        except urllib.error.HTTPError as exc:
-            error_body = exc.read().decode("utf-8", errors="replace")
-            try:
-                err_data = json.loads(error_body)
-                msg = err_data.get("error", {}).get("message", error_body)
-            except json.JSONDecodeError:
-                msg = error_body
-            raise OpenRouterConnectionError(
-                f"\n  [X] OpenRouter API error ({exc.code})\n"
-                f"  {msg}"
-            ) from exc
-        except urllib.error.URLError as exc:
-            raise OpenRouterConnectionError(
-                f"\n  [X] Cannot reach OpenRouter API.\n"
-                f"  Check your internet connection.\n"
-                f"  Error: {exc}"
-            ) from exc
-
-        in_reasoning = False
-        try:
-            for raw_line in resp:
-                line = raw_line.decode("utf-8", errors="replace").strip()
-                if not line or line == "data: [DONE]":
-                    continue
-                if not line.startswith("data: "):
-                    continue
-                try:
-                    chunk = json.loads(line[6:])
-                except json.JSONDecodeError:
-                    continue
-                choices = chunk.get("choices", [])
-                if not choices:
-                    continue
-                delta = choices[0].get("delta", {})
-
-                # Handle reasoning tokens (Kimi K2.5 chain-of-thought)
-                reasoning_token = delta.get("reasoning", "")
-                content_token = delta.get("content", "")
-
-                if reasoning_token:
-                    if not in_reasoning:
-                        yield "\033[2m\033[90m"  # DIM + GRAY
-                        in_reasoning = True
-                    yield reasoning_token
-
-                if content_token:
-                    if in_reasoning:
-                        yield "\033[0m\n"  # Reset after reasoning
-                        in_reasoning = False
-                    yield content_token
-        finally:
-            if in_reasoning:
-                yield "\033[0m\n"
-            resp.close()
-
-    # ── Internal helpers ──────────────────────────────────────────
-
-    def _headers(self, json_body: bool = False) -> dict[str, str]:
-        h: dict[str, str] = {
-            "Authorization": f"Bearer {self.config.api_key}",
-            "HTTP-Referer": "https://github.com/RAHUL-DevelopeRR/neuroncli",
-            "X-Title": "NeuronCLI",
-        }
-        if json_body:
-            h["Content-Type"] = "application/json"
-        return h
-
-    def _build_payload(
-        self,
-        messages: list[ChatMessage],
-        model: str | None,
-        stream: bool,
-    ) -> dict:
-        return {
-            "model": model or self.config.model,
-            "messages": [m.to_dict() for m in messages],
-            "stream": stream,
-            "max_tokens": self.config.max_tokens,
-            "temperature": self.config.temperature,
-            "top_p": self.config.top_p,
-        }
-
-    def _post(self, payload: dict) -> dict:
-        body = json.dumps(payload).encode("utf-8")
-        req = urllib.request.Request(
-            f"{self.API_BASE}/chat/completions",
-            data=body,
-            headers=self._headers(json_body=True),
-            method="POST",
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=300) as resp:
-                return json.loads(resp.read().decode("utf-8"))
-        except urllib.error.HTTPError as exc:
-            error_body = exc.read().decode("utf-8", errors="replace")
-            try:
-                err_data = json.loads(error_body)
-                msg = err_data.get("error", {}).get("message", error_body)
-            except json.JSONDecodeError:
-                msg = error_body
-            raise OpenRouterConnectionError(
-                f"\n  [X] OpenRouter API error ({exc.code})\n"
-                f"  {msg}"
-            ) from exc
-        except urllib.error.URLError as exc:
-            raise OpenRouterConnectionError(
-                f"\n  [X] Cannot reach OpenRouter API.\n"
-                f"  Error: {exc}"
-            ) from exc
+"""NeuronCLI — OpenRouter HTTP streaming client. Zero external dependencies.
+
+Supports reasoning models (Kimi K2.5) where the response has both
+a `reasoning` field (chain-of-thought) and a `content` field (final answer).
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Generator
+
+from .config import AgentConfig
+
+
+class OpenRouterConnectionError(Exception):
+    """Raised when the OpenRouter API is unreachable or returns an error."""
+    pass
+
+
+@dataclass(frozen=True)
+class ChatMessage:
+    """A single message in the conversation."""
+    role: str       # "system", "user", "assistant"
+    content: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {"role": self.role, "content": self.content}
+
+
+class OpenRouterClient:
+    """
+    HTTP client for OpenRouter's OpenAI-compatible /api/v1/chat/completions.
+    Uses only stdlib — no pip dependencies needed.
+
+    Handles reasoning models (like Kimi K2.5) that emit:
+      - `delta.reasoning` tokens (thinking, shown dimmed)
+      - `delta.content` tokens (final answer)
+    """
+
+    API_BASE = "https://openrouter.ai/api/v1"
+
+    def __init__(self, config: AgentConfig | None = None):
+        self.config = config or AgentConfig.from_env()
+
+    def health_check(self) -> bool:
+        """Check if OpenRouter API is reachable and the API key is valid."""
+        try:
+            req = urllib.request.Request(
+                f"{self.API_BASE}/models",
+                headers=self._headers(),
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return resp.status == 200
+        except (urllib.error.URLError, OSError):
+            return False
+
+    def list_models(self) -> list[str]:
+        """List coding-relevant models from OpenRouter."""
+        try:
+            req = urllib.request.Request(
+                f"{self.API_BASE}/models",
+                headers=self._headers(),
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                data = json.loads(resp.read().decode())
+                models = data.get("data", [])
+                keywords = ("kimi", "deepseek", "qwen", "codestral", "claude", "gemini")
+                names = [m["id"] for m in models
+                         if any(k in m["id"].lower() for k in keywords)]
+                return sorted(names)[:25]
+        except (urllib.error.URLError, OSError):
+            return []
+
+    def chat(self, messages: list[ChatMessage], model: str | None = None) -> str:
+        """Send a chat request and return the full response text."""
+        payload = self._build_payload(messages, model, stream=False)
+        data = self._post(payload)
+        choice = data.get("choices", [{}])[0]
+        msg = choice.get("message", {})
+        # Kimi K2.5 reasoning models: content may be in `content` or `reasoning`
+        content = msg.get("content") or ""
+        if not content:
+            content = msg.get("reasoning", "")
+        return content
+
+    def chat_stream(
+        self,
+        messages: list[ChatMessage],
+        model: str | None = None,
+    ) -> Generator[str, None, None]:
+        """
+        Stream a chat response token by token.
+        
+        For reasoning models (Kimi K2.5), yields:
+          - reasoning tokens with a dim prefix (hidden thinking)
+          - content tokens normally (the actual response)
+        """
+        payload = self._build_payload(messages, model, stream=True)
+        body = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            f"{self.API_BASE}/chat/completions",
+            data=body,
+            headers=self._headers(json_body=True),
+            method="POST",
+        )
+
+        try:
+            resp = urllib.request.urlopen(req, timeout=300)
+        except urllib.error.HTTPError as exc:
+            error_body = exc.read().decode("utf-8", errors="replace")
+            try:
+                err_data = json.loads(error_body)
+                msg = err_data.get("error", {}).get("message", error_body)
+            except json.JSONDecodeError:
+                msg = error_body
+            if exc.code == 402:
+                raise OpenRouterConnectionError(
+                    f"\n  [X] OpenRouter: Insufficient credits (402)\n"
+                    f"  {msg}\n\n"
+                    f"  Fix options:\n"
+                    f"  1. Add $5 credits: https://openrouter.ai/settings/credits\n"
+                    f"  2. Switch to a free model: neuron --model moonshotai/kimi-k2.5:free\n"
+                    f"  3. Use Ollama (offline): NEURON_PROVIDER=ollama neuron\n"
+                    f"  4. Re-auth with a funded account: neuron --reauth\n"
+                ) from exc
+            raise OpenRouterConnectionError(
+                f"\n  [X] OpenRouter API error ({exc.code})\n"
+                f"  {msg}"
+            ) from exc
+        except urllib.error.URLError as exc:
+            raise OpenRouterConnectionError(
+                f"\n  [X] Cannot reach OpenRouter API.\n"
+                f"  Check your internet connection.\n"
+                f"  Error: {exc}"
+            ) from exc
+
+        in_reasoning = False
+        try:
+            for raw_line in resp:
+                line = raw_line.decode("utf-8", errors="replace").strip()
+                if not line or line == "data: [DONE]":
+                    continue
+                if not line.startswith("data: "):
+                    continue
+                try:
+                    chunk = json.loads(line[6:])
+                except json.JSONDecodeError:
+                    continue
+                choices = chunk.get("choices", [])
+                if not choices:
+                    continue
+                delta = choices[0].get("delta", {})
+
+                # Handle reasoning tokens (Kimi K2.5 chain-of-thought)
+                reasoning_token = delta.get("reasoning", "")
+                content_token = delta.get("content", "")
+
+                if reasoning_token:
+                    if not in_reasoning:
+                        yield "\033[2m\033[90m"  # DIM + GRAY
+                        in_reasoning = True
+                    yield reasoning_token
+
+                if content_token:
+                    if in_reasoning:
+                        yield "\033[0m\n"  # Reset after reasoning
+                        in_reasoning = False
+                    yield content_token
+        finally:
+            if in_reasoning:
+                yield "\033[0m\n"
+            resp.close()
+
+    # ── Internal helpers ──────────────────────────────────────────
+
+    def _headers(self, json_body: bool = False) -> dict[str, str]:
+        h: dict[str, str] = {
+            "Authorization": f"Bearer {self.config.api_key}",
+            "HTTP-Referer": "https://github.com/RAHUL-DevelopeRR/neuroncli",
+            "X-Title": "NeuronCLI",
+        }
+        if json_body:
+            h["Content-Type"] = "application/json"
+        return h
+
+    def _build_payload(
+        self,
+        messages: list[ChatMessage],
+        model: str | None,
+        stream: bool,
+    ) -> dict:
+        return {
+            "model": model or self.config.model,
+            "messages": [m.to_dict() for m in messages],
+            "stream": stream,
+            "max_tokens": self.config.max_tokens,
+            "temperature": self.config.temperature,
+            "top_p": self.config.top_p,
+            "route": "fallback",  # Auto-select cheapest available provider
+        }
+
+    def _post(self, payload: dict) -> dict:
+        body = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            f"{self.API_BASE}/chat/completions",
+            data=body,
+            headers=self._headers(json_body=True),
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=300) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            error_body = exc.read().decode("utf-8", errors="replace")
+            try:
+                err_data = json.loads(error_body)
+                msg = err_data.get("error", {}).get("message", error_body)
+            except json.JSONDecodeError:
+                msg = error_body
+            raise OpenRouterConnectionError(
+                f"\n  [X] OpenRouter API error ({exc.code})\n"
+                f"  {msg}"
+            ) from exc
+        except urllib.error.URLError as exc:
+            raise OpenRouterConnectionError(
+                f"\n  [X] Cannot reach OpenRouter API.\n"
+                f"  Error: {exc}"
+            ) from exc

neuroncli-3.0.0/neuroncli/repo_map.py

@@ -0,0 +1,212 @@
+"""NeuronCLI — AST-based semantic repo map.
+
+Generates a concise structural overview of the project for the system prompt.
+Replaces the 200-item directory dump with ~500 tokens of meaningful context.
+Inspired by Aider's repo-map concept.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+from pathlib import Path
+
+
+# Directories to always skip
+_SKIP_DIRS = {
+    ".git", "__pycache__", "node_modules", ".venv", "venv",
+    ".mypy_cache", ".pytest_cache", "dist", "build", ".tox",
+    ".eggs", ".next", ".nuxt", "coverage", ".coverage",
+}
+
+
+def build_repo_map(working_dir: str, max_tokens: int = 500) -> str:
+    """Generate a concise structural overview of the project.
+
+    Output format:
+        src/
+          agent.py: class Agent [run, compact, clear_history]
+          tools.py: class ToolRegistry [register, execute]; read_file, write_file
+        tests/
+          test_agent.py: TestAgent [test_run_simple, test_tools]
+    """
+    root = Path(working_dir)
+    if not root.is_dir():
+        return f"[Not a directory: {working_dir}]"
+
+    lines: list[str] = []
+    _walk_dir(root, root, lines, depth=0, max_depth=3)
+
+    full_map = "\n".join(lines)
+    return _smart_truncate(full_map, max_tokens)
+
+
+def _walk_dir(base: Path, current: Path, lines: list[str], depth: int, max_depth: int):
+    """Recursively build the repo map."""
+    if depth >= max_depth:
+        return
+
+    try:
+        entries = sorted(current.iterdir(), key=lambda e: (not e.is_dir(), e.name.lower()))
+    except (PermissionError, OSError):
+        return
+
+    for entry in entries:
+        if entry.name.startswith(".") or entry.name in _SKIP_DIRS:
+            continue
+
+        rel = entry.relative_to(base)
+        indent = "  " * depth
+
+        if entry.is_dir():
+            # Count meaningful files in directory
+            try:
+                child_count = sum(1 for c in entry.iterdir()
+                                  if not c.name.startswith(".") and c.name not in _SKIP_DIRS)
+            except (PermissionError, OSError):
+                child_count = 0
+
+            if child_count > 0:
+                lines.append(f"{indent}{entry.name}/")
+                _walk_dir(base, entry, lines, depth + 1, max_depth)
+
+        elif entry.is_file():
+            symbols = _extract_symbols(entry)
+            if symbols:
+                lines.append(f"{indent}{entry.name}: {symbols}")
+            else:
+                lines.append(f"{indent}{entry.name}")
+
+
+def _extract_symbols(filepath: Path) -> str:
+    """Extract key symbols from a file based on its type."""
+    ext = filepath.suffix.lower()
+
+    if ext == ".py":
+        return _extract_python_symbols(filepath)
+    elif ext in (".js", ".ts", ".jsx", ".tsx"):
+        return _extract_js_symbols(filepath)
+    elif ext == ".go":
+        return _extract_go_symbols(filepath)
+
+    # For other files, return size hint
+    try:
+        size = filepath.stat().st_size
+        if size > 10240:
+            return f"({size // 1024}KB)"
+    except OSError:
+        pass
+    return ""
+
+
+def _extract_python_symbols(filepath: Path) -> str:
+    """Use Python's ast module to extract classes and top-level functions."""
+    try:
+        source = filepath.read_text(encoding="utf-8", errors="replace")
+        tree = ast.parse(source, filename=str(filepath))
+    except (SyntaxError, OSError, ValueError):
+        return ""
+
+    parts = []
+
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, ast.ClassDef):
+            methods = [n.name for n in ast.iter_child_nodes(node)
+                       if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+                       and not n.name.startswith("_")]
+            if methods:
+                methods_str = ", ".join(methods[:5])
+                if len(methods) > 5:
+                    methods_str += f" +{len(methods) - 5}"
+                parts.append(f"class {node.name} [{methods_str}]")
+            else:
+                parts.append(f"class {node.name}")
+
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if not node.name.startswith("_"):
+                parts.append(node.name + "()")
+
+    if not parts:
+        # Fallback: count lines
+        try:
+            line_count = len(source.splitlines())
+            return f"({line_count} lines)"
+        except Exception:
+            pass
+
+    return "; ".join(parts[:6])
+
+
+def _extract_js_symbols(filepath: Path) -> str:
+    """Basic regex extraction for JS/TS files."""
+    import re
+    try:
+        source = filepath.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+    parts = []
+
+    # Classes
+    for match in re.finditer(r'(?:export\s+)?class\s+(\w+)', source):
+        parts.append(f"class {match.group(1)}")
+    # Named exports / functions
+    for match in re.finditer(r'(?:export\s+)?(?:async\s+)?function\s+(\w+)', source):
+        parts.append(match.group(1) + "()")
+    # Arrow function exports
+    for match in re.finditer(r'export\s+(?:const|let)\s+(\w+)\s*=', source):
+        name = match.group(1)
+        if name not in [p.rstrip("()") for p in parts]:
+            parts.append(name)
+
+    return "; ".join(parts[:6])
+
+
+def _extract_go_symbols(filepath: Path) -> str:
+    """Basic regex extraction for Go files."""
+    import re
+    try:
+        source = filepath.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+
+    parts = []
+    for match in re.finditer(r'type\s+(\w+)\s+struct', source):
+        parts.append(f"type {match.group(1)}")
+    for match in re.finditer(r'func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(', source):
+        name = match.group(1)
+        if name[0].isupper():  # Only exported
+            parts.append(name + "()")
+
+    return "; ".join(parts[:6])
+
+
+def _smart_truncate(map_text: str, max_tokens: int) -> str:
+    """Progressively reduce detail to fit within token budget.
+
+    Estimation: 1 token ≈ 4 characters.
+    """
+    max_chars = max_tokens * 4
+    if len(map_text) <= max_chars:
+        return map_text
+
+    # Phase 1: Remove size hints like (123 lines), (45KB)
+    import re
+    truncated = re.sub(r'\s*\(\d+\s*(?:lines|KB|B)\)', '', map_text)
+    if len(truncated) <= max_chars:
+        return truncated
+
+    # Phase 2: Remove method lists from classes
+    truncated = re.sub(r'\s*\[.+?\]', '', truncated)
+    if len(truncated) <= max_chars:
+        return truncated
+
+    # Phase 3: Just keep directory structure + filenames
+    lines = truncated.split("\n")
+    kept = [l for l in lines if l.strip().endswith("/") or "." in l.split("/")[-1]]
+    truncated = "\n".join(kept)
+    if len(truncated) <= max_chars:
+        return truncated
+
+    # Phase 4: Hard truncate
+    return truncated[:max_chars] + "\n... (truncated)"

neuroncli-3.0.0/neuroncli/validators.py

@@ -0,0 +1,169 @@
+"""NeuronCLI — Post-write file validation engine.
+
+Automatically validates files after write/edit operations.
+Feeds errors back into the agent loop for self-correction.
+Inspired by Crush's LSP diagnostics + Aider's lint-fix pattern.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class ValidationResult:
+    """Result of validating a generated file."""
+    valid: bool
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def feedback(self) -> str:
+        """Format as feedback string for the agent loop."""
+        if self.valid:
+            return ""
+        parts = []
+        for e in self.errors:
+            parts.append(f"  ERROR: {e}")
+        for w in self.warnings:
+            parts.append(f"  WARNING: {w}")
+        return "\n".join(parts)
+
+
+def validate_file(path: str, content: str | None = None) -> ValidationResult:
+    """Validate a file based on its extension.
+
+    Args:
+        path: File path (used for extension detection)
+        content: File content (read from disk if not provided)
+    """
+    p = Path(path)
+    ext = p.suffix.lower()
+
+    if content is None:
+        try:
+            content = p.read_text(encoding="utf-8", errors="replace")
+        except OSError as e:
+            return ValidationResult(valid=False, errors=[f"Cannot read file: {e}"])
+
+    validators = {
+        ".py": _validate_python,
+        ".json": _validate_json,
+        ".html": _validate_html,
+        ".htm": _validate_html,
+        ".css": _validate_css,
+        ".js": _validate_javascript,
+        ".ts": _validate_javascript,
+    }
+
+    validator = validators.get(ext)
+    if validator is None:
+        return ValidationResult(valid=True)  # No validator = assume OK
+
+    return validator(str(p), content)
+
+
+# ── Python Validator ──────────────────────────────────────────────
+
+def _validate_python(path: str, content: str) -> ValidationResult:
+    """Validate Python via py_compile (catches syntax errors)."""
+    errors = []
+    warnings = []
+
+    try:
+        compile(content, path, "exec")
+    except SyntaxError as e:
+        errors.append(f"SyntaxError at line {e.lineno}: {e.msg}")
+
+    # Check for common mistakes
+    if "import *" in content:
+        warnings.append("Wildcard import detected (import *)")
+
+    return ValidationResult(valid=len(errors) == 0, errors=errors, warnings=warnings)
+
+
+# ── JSON Validator ────────────────────────────────────────────────
+
+def _validate_json(path: str, content: str) -> ValidationResult:
+    """Validate JSON structure."""
+    try:
+        json.loads(content)
+        return ValidationResult(valid=True)
+    except json.JSONDecodeError as e:
+        return ValidationResult(valid=False, errors=[f"Invalid JSON at line {e.lineno}: {e.msg}"])
+
+
+# ── HTML Validator ────────────────────────────────────────────────
+
+def _validate_html(path: str, content: str) -> ValidationResult:
+    """Validate HTML structure — checks for complete document."""
+    errors = []
+    warnings = []
+
+    # Check for escaped tags (common LLM mistake)
+    if "&lt;" in content and "<html" not in content.lower():
+        errors.append("HTML tags are escaped (&lt; instead of <). The LLM outputted escaped HTML.")
+
+    # Check for required structural elements
+    lower = content.lower()
+    if "<!doctype" not in lower:
+        warnings.append("Missing <!DOCTYPE html> declaration")
+    if "<html" not in lower:
+        errors.append("Missing <html> tag")
+    if "<head" not in lower:
+        warnings.append("Missing <head> tag")
+    if "<body" not in lower:
+        errors.append("Missing <body> tag")
+
+    # Check for unclosed tags (basic check)
+    open_tags = len(re.findall(r'<(?!/)(?!meta)(?!br)(?!hr)(?!img)(?!input)(?!link)([a-z]+)', lower))
+    close_tags = len(re.findall(r'</([a-z]+)', lower))
+    if open_tags > 0 and close_tags == 0:
+        errors.append("No closing tags found — file may be truncated")
+
+    return ValidationResult(valid=len(errors) == 0, errors=errors, warnings=warnings)
+
+
+# ── CSS Validator ─────────────────────────────────────────────────
+
+def _validate_css(path: str, content: str) -> ValidationResult:
+    """Basic CSS validation — brace matching."""
+    errors = []
+
+    open_braces = content.count("{")
+    close_braces = content.count("}")
+    if open_braces != close_braces:
+        errors.append(f"Unmatched braces: {open_braces} open, {close_braces} close")
+
+    return ValidationResult(valid=len(errors) == 0, errors=errors)
+
+
+# ── JavaScript Validator ──────────────────────────────────────────
+
+def _validate_javascript(path: str, content: str) -> ValidationResult:
+    """Validate JS/TS — try node --check if available, else brace match."""
+    errors = []
+
+    # Try node --check (fast syntax check)
+    try:
+        result = subprocess.run(
+            ["node", "--check", path],
+            capture_output=True, text=True, timeout=5,
+        )
+        if result.returncode != 0:
+            # Extract the actual error line
+            stderr = result.stderr.strip()
+            if stderr:
+                errors.append(stderr.split("\n")[0])
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        # Node not available — fall back to brace matching
+        open_braces = content.count("{")
+        close_braces = content.count("}")
+        if abs(open_braces - close_braces) > 2:
+            errors.append(f"Suspicious brace mismatch: {open_braces} open, {close_braces} close")
+
+    return ValidationResult(valid=len(errors) == 0, errors=errors)

{neuroncli-2.3.0 → neuroncli-3.0.0}/neuroncli.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: neuroncli
-Version: 2.3.0
-Summary: AI Coding Agent — Free Claude Code alternative powered by Kimi K2.5 + Ollama
+Version: 3.0.0
+Summary: AI Coding Agent — Free Claude Code alternative. Native Rust binary with plan mode, shell escapes, and Azure AI + OpenRouter support.
 Author-email: Rahul S <rahultech72216@gmail.com>
 License: MIT
 Project-URL: Homepage, https://zero-x.live
 Project-URL: Repository, https://github.com/RAHUL-DevelopeRR/neuroncli
 Project-URL: Issues, https://github.com/RAHUL-DevelopeRR/neuroncli/issues
-Keywords: ai,coding,agent,cli,llm,kimi,ollama,code-assistant
+Keywords: ai,coding,agent,cli,llm,claude-code,rust,code-assistant,neuron
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{neuroncli-2.3.0 → neuroncli-3.0.0}/neuroncli.egg-info/SOURCES.txt

@@ -11,13 +11,16 @@ neuroncli/ollama_client.py
 neuroncli/openrouter_client.py
 neuroncli/prompts.py
 neuroncli/provider.py
+neuroncli/repo_map.py
 neuroncli/session.py
 neuroncli/tools.py
 neuroncli/ui.py
+neuroncli/validators.py
 neuroncli.egg-info/PKG-INFO
 neuroncli.egg-info/SOURCES.txt
 neuroncli.egg-info/dependency_links.txt
 neuroncli.egg-info/entry_points.txt
 neuroncli.egg-info/requires.txt
 neuroncli.egg-info/top_level.txt
+neuroncli/bin/neuron.exe
 tests/test_agent.py

{neuroncli-2.3.0 → neuroncli-3.0.0}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "neuroncli"
-version = "2.3.0"
-description = "AI Coding Agent — Free Claude Code alternative powered by Kimi K2.5 + Ollama"
+version = "3.0.0"
+description = "AI Coding Agent — Free Claude Code alternative. Native Rust binary with plan mode, shell escapes, and Azure AI + OpenRouter support."
 readme = "README.md"
 license = {text = "MIT"}
 requires-python = ">=3.10"
 authors = [
     {name = "Rahul S", email = "rahultech72216@gmail.com"},
 ]
-keywords = ["ai", "coding", "agent", "cli", "llm", "kimi", "ollama", "code-assistant"]
+keywords = ["ai", "coding", "agent", "cli", "llm", "claude-code", "rust", "code-assistant", "neuron"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Environment :: Console",
@@ -41,5 +41,8 @@ neuron = "neuroncli.cli:main"
 [tool.setuptools.packages.find]
 include = ["neuroncli*"]
 
+[tool.setuptools.package-data]
+neuroncli = ["bin/*"]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]