neuroncli 2.1.0__py3-none-any.whl

neuroncli/config.py

@@ -0,0 +1,112 @@
+"""NeuronCLI — Configuration module. v2.0 with modes, context management, and hybrid pricing."""
+
+from __future__ import annotations
+from .auth import ensure_api_key
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+# ── Operational Modes ─────────────────────────────────────────────
+MODE_STANDARD = "standard"    # Ask permission for writes/commands
+MODE_PLAN     = "plan"        # Plan first, then execute after approval
+MODE_YOLO     = "yolo"        # Skip all permission prompts
+
+
+@dataclass
+class AgentConfig:
+    """All configurable settings for the NeuronCLI agent."""
+
+    # ── Provider Selection ────────────────────────────────────────
+    provider: str = "openrouter"      # "openrouter" or "ollama"
+
+    # ── OpenRouter Settings ───────────────────────────────────────
+    api_key: str = ""
+    model: str = "moonshotai/kimi-k2.5"     # Free reasoning model
+    max_tokens: int = 4096
+
+    # ── Ollama Settings (fallback) ────────────────────────────────
+    ollama_model: str = "qwen2.5-coder:7b"
+    base_url: str = "http://localhost:11434"
+    num_ctx: int = 8192
+
+    # ── Shared LLM Settings ──────────────────────────────────────
+    temperature: float = 0.2
+    top_p: float = 0.9
+
+    # ── Agent Behavior ────────────────────────────────────────────
+    max_iterations: int = 15          # Safety cap for ReAct loop
+    streaming: bool = True            # Stream tokens to terminal
+    confirm_dangerous: bool = True    # Ask before destructive commands
+    show_thinking: bool = True        # Show reasoning tokens (K2.5)
+    mode: str = MODE_STANDARD         # standard / plan / yolo
+
+    # ── Context Management ────────────────────────────────────────
+    context_warn_percent: float = 0.85     # Warn at 85% context usage
+    context_compress_percent: float = 0.92 # Auto-compress at 92%
+    max_context_tokens: int = 128000       # K2.5 supports 128k
+
+    # ── Working Directory ─────────────────────────────────────────
+    working_dir: str = field(default_factory=lambda: os.getcwd())
+
+    # ── Dangerous command patterns (require confirmation) ─────────
+    dangerous_patterns: tuple[str, ...] = (
+        "rm ", "del ", "rmdir", "format ",
+        "shutdown", "restart",
+        "> /dev/null", "| rm",
+        "drop table", "drop database",
+        "git push --force", "git reset --hard",
+    )
+
+    @classmethod
+    def from_env(cls) -> "AgentConfig":
+        """Build config from environment variables with defaults."""
+        provider = os.environ.get("NEURON_PROVIDER", "openrouter")
+        api_key = ensure_api_key() or ""
+
+        if provider == "openrouter" and not api_key:
+            provider = "ollama"
+
+        model = os.environ.get("NEURON_MODEL", "moonshotai/kimi-k2.5")
+        ollama_model = os.environ.get("NEURON_OLLAMA_MODEL", "qwen2.5-coder:7b")
+
+        return cls(
+            provider=provider,
+            api_key=api_key,
+            model=model,
+            ollama_model=ollama_model,
+            base_url=os.environ.get("OLLAMA_HOST", "http://localhost:11434"),
+            temperature=float(os.environ.get("NEURON_TEMPERATURE", "0.2")),
+            max_iterations=int(os.environ.get("NEURON_MAX_ITER", "15")),
+            max_tokens=int(os.environ.get("NEURON_MAX_TOKENS", "4096")),
+            num_ctx=int(os.environ.get("NEURON_CTX", "8192")),
+            working_dir=os.environ.get("NEURON_WORK_DIR", os.getcwd()),
+        )
+
+    def resolve_path(self, path: str) -> Path:
+        p = Path(path)
+        if p.is_absolute():
+            return p
+        return Path(self.working_dir) / p
+
+    def is_dangerous_command(self, cmd: str) -> bool:
+        lower = cmd.lower().strip()
+        return any(pat in lower for pat in self.dangerous_patterns)
+
+    @property
+    def active_model(self) -> str:
+        if self.provider == "ollama":
+            return self.ollama_model
+        return self.model
+
+    @property
+    def needs_confirmation(self) -> bool:
+        """Whether current mode requires user confirmation for writes."""
+        return self.mode == MODE_STANDARD and self.confirm_dangerous
+
+
+# ── App-wide constants ────────────────────────────────────────────
+
+APP_NAME = "NeuronCLI"
+VERSION = "2.1.0"

neuroncli/git_integration.py

@@ -0,0 +1,86 @@
+"""NeuronCLI — Git integration. Auto-commit AI edits like Aider."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def is_git_repo(working_dir: str) -> bool:
+    """Check if the working directory is inside a git repository."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            cwd=working_dir, capture_output=True, text=True, timeout=5,
+        )
+        return result.returncode == 0 and result.stdout.strip() == "true"
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def git_auto_commit(working_dir: str, files: list[str], message: str) -> str | None:
+    """Stage specific files and commit with a descriptive message.
+    Returns commit hash on success, None on failure.
+    """
+    if not is_git_repo(working_dir):
+        return None
+
+    try:
+        # Stage only the modified files
+        for f in files:
+            subprocess.run(
+                ["git", "add", str(f)],
+                cwd=working_dir, capture_output=True, timeout=5,
+            )
+
+        # Check if there are staged changes
+        status = subprocess.run(
+            ["git", "diff", "--cached", "--quiet"],
+            cwd=working_dir, capture_output=True, timeout=5,
+        )
+        if status.returncode == 0:
+            return None  # Nothing staged
+
+        # Commit
+        result = subprocess.run(
+            ["git", "commit", "-m", f"neuron: {message}"],
+            cwd=working_dir, capture_output=True, text=True, timeout=10,
+        )
+        if result.returncode == 0:
+            # Extract short hash
+            hash_result = subprocess.run(
+                ["git", "rev-parse", "--short", "HEAD"],
+                cwd=working_dir, capture_output=True, text=True, timeout=5,
+            )
+            return hash_result.stdout.strip() if hash_result.returncode == 0 else "ok"
+        return None
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        return None
+
+
+def git_status(working_dir: str) -> str:
+    """Get git status summary."""
+    if not is_git_repo(working_dir):
+        return "Not a git repository."
+    try:
+        result = subprocess.run(
+            ["git", "status", "--short"],
+            cwd=working_dir, capture_output=True, text=True, timeout=5,
+        )
+        return result.stdout.strip() or "Working tree clean."
+    except Exception:
+        return "Error running git status."
+
+
+def git_diff(working_dir: str) -> str:
+    """Get current unstaged diff."""
+    if not is_git_repo(working_dir):
+        return "Not a git repository."
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--stat"],
+            cwd=working_dir, capture_output=True, text=True, timeout=5,
+        )
+        return result.stdout.strip() or "No changes."
+    except Exception:
+        return "Error running git diff."

neuroncli/ollama_client.py

@@ -0,0 +1,150 @@
+"""NeuronCLI — Ollama HTTP streaming client. Zero external dependencies."""
+
+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 OllamaConnectionError(Exception):
+    """Raised when the Ollama server is unreachable."""
+    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 OllamaClient:
+    """
+    HTTP client for Ollama's /api/chat endpoint.
+    Uses only stdlib — no pip dependencies needed.
+    """
+
+    def __init__(self, config: AgentConfig | None = None):
+        self.config = config or AgentConfig.from_env()
+        self._base = self.config.base_url.rstrip("/")
+
+    def health_check(self) -> bool:
+        """Check if Ollama server is responding."""
+        try:
+            req = urllib.request.Request(f"{self._base}/api/tags")
+            with urllib.request.urlopen(req, timeout=5) as resp:
+                return resp.status == 200
+        except (urllib.error.URLError, OSError):
+            return False
+
+    def list_models(self) -> list[str]:
+        """List locally installed model names."""
+        try:
+            req = urllib.request.Request(f"{self._base}/api/tags")
+            with urllib.request.urlopen(req, timeout=5) as resp:
+                data = json.loads(resp.read().decode())
+                return [m["name"] for m in data.get("models", [])]
+        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("/api/chat", payload)
+        return data.get("message", {}).get("content", "")
+
+    def chat_stream(
+        self,
+        messages: list[ChatMessage],
+        model: str | None = None,
+    ) -> Generator[str, None, None]:
+        """
+        Stream a chat response token by token.
+        Yields individual tokens as strings.
+        """
+        payload = self._build_payload(messages, model, stream=True)
+        body = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            f"{self._base}/api/chat",
+            data=body,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+
+        try:
+            resp = urllib.request.urlopen(req, timeout=300)
+        except urllib.error.URLError as exc:
+            raise OllamaConnectionError(
+                f"\n  [X] Cannot connect to Ollama at {self._base}\n"
+                f"  Start it with: ollama serve\n"
+                f"  Error: {exc}"
+            ) from exc
+
+        buffer = b""
+        try:
+            while True:
+                byte = resp.read(1)
+                if not byte:
+                    break
+                buffer += byte
+                if byte == b"\n":
+                    line = buffer.decode("utf-8", errors="replace").strip()
+                    buffer = b""
+                    if not line:
+                        continue
+                    try:
+                        data = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    token = data.get("message", {}).get("content", "")
+                    if token:
+                        yield token
+                    if data.get("done", False):
+                        break
+        finally:
+            resp.close()
+
+    # ── Internal helpers ──────────────────────────────────────────
+
+    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,
+            "options": {
+                "temperature": self.config.temperature,
+                "top_p": self.config.top_p,
+                "num_ctx": self.config.num_ctx,
+            },
+        }
+
+    def _post(self, path: str, payload: dict) -> dict:
+        body = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            f"{self._base}{path}",
+            data=body,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=300) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except urllib.error.URLError as exc:
+            raise OllamaConnectionError(
+                f"\n  [X] Cannot connect to Ollama at {self._base}\n"
+                f"  Start it with: ollama serve\n"
+                f"  Error: {exc}"
+            ) from exc

neuroncli/openrouter_client.py

@@ -0,0 +1,220 @@
+"""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/prompts.py

@@ -0,0 +1,109 @@
+"""NeuronCLI — System prompt builder. v2.0 with plan mode, to-do prompting, and context injection."""
+
+from __future__ import annotations
+
+from .tools import ToolRegistry
+
+
+def build_system_prompt(
+    tool_registry: ToolRegistry,
+    working_dir: str,
+    mode: str = "standard",
+    neuron_md: str | None = None,
+) -> str:
+    """Build the complete system prompt for the agent."""
+    tool_docs = tool_registry.generate_prompt_section()
+    tool_names = ", ".join(tool_registry.tool_names())
+
+    # Base prompt
+    prompt = f"""You are NeuronCLI, an expert AI coding agent running in the user's terminal.
+You have direct filesystem and terminal access through tools.
+
+## Working Directory
+{working_dir}
+
+## Available Tools
+{tool_docs}
+
+## How to Call Tools
+
+Use this EXACT format:
+
+<tool_call>
+{{"tool": "TOOL_NAME", "args": {{"param1": "value1"}}}}
+</tool_call>
+
+You CAN call MULTIPLE tools in one response (they execute in parallel):
+
+<tool_call>
+{{"tool": "read_file", "args": {{"path": "README.md"}}}}
+</tool_call>
+<tool_call>
+{{"tool": "read_file", "args": {{"path": "package.json"}}}}
+</tool_call>
+<tool_call>
+{{"tool": "list_directory", "args": {{"path": "src"}}}}
+</tool_call>
+
+## How to Give Your Final Answer
+
+<final_answer>
+Your response here. Use markdown formatting.
+</final_answer>
+
+## Rules
+1. Be concise. Do NOT narrate what you are about to do.
+2. Call multiple tools at once when possible (parallel execution).
+3. For simple greetings or questions, skip tools and answer with <final_answer> directly.
+4. NEVER invent file contents — always use tools to verify.
+5. Use edit_file for changes (NOT write_file for existing files).
+6. Read a file BEFORE editing it.
+7. Available tools: {tool_names}"""
+
+    # Mode-specific instructions
+    if mode == "plan":
+        prompt += """
+
+## PLAN MODE (Active)
+You are in PLAN MODE. Do NOT write code yet.
+1. Analyze the user's request carefully.
+2. Ask numbered clarifying questions about requirements, tech stack, and constraints.
+3. Once clarified, generate a structured implementation plan with:
+   - Architecture overview
+   - File structure
+   - Key components and their responsibilities
+   - Implementation steps (numbered)
+4. Present the plan and wait for user approval before writing any code.
+5. Do NOT use write_file or edit_file in Plan Mode."""
+
+    elif mode == "yolo":
+        prompt += """
+
+## YOLO MODE (Active)
+Execute ALL operations autonomously. Do NOT ask for permission.
+Write files, edit code, run commands — go continuously until the task is fully complete.
+Be aggressive and thorough. Do not stop to ask the user questions."""
+
+    # Multi-step task tracking
+    prompt += """
+
+## Multi-Step Tasks
+For complex tasks, create a mental to-do list:
+```
+TODO:
+- [ ] Step 1: Understand requirements
+- [ ] Step 2: Read relevant files
+- [ ] Step 3: Make changes
+- [ ] Step 4: Verify changes work
+```
+Track progress through each step. Do NOT skip verification."""
+
+    # Context from NEURON.md
+    if neuron_md:
+        prompt += f"""
+
+## Project Context (from NEURON.md)
+{neuron_md}
+Follow all rules and conventions specified above."""
+
+    return prompt