neuroncli 2.1.0__py3-none-any.whl

neuroncli/auth.py

@@ -0,0 +1,263 @@
+"""NeuronCLI — OAuth PKCE flow for automatic OpenRouter API key provisioning.
+
+On first run, opens the user's browser to OpenRouter's login page.
+After the user logs in, OpenRouter redirects back to a tiny localhost server
+which captures the auth code and exchanges it for a permanent API key.
+
+Zero manual copy-paste. One click.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import http.server
+import json
+import os
+import secrets
+import threading
+import urllib.error
+import urllib.parse
+import urllib.request
+import webbrowser
+from pathlib import Path
+
+
+# ── Config paths ──────────────────────────────────────────────────
+
+CONFIG_DIR = Path.home() / ".neuroncli"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+CALLBACK_PORT = 19284  # Obscure port to avoid collisions
+CALLBACK_URL = f"http://localhost:{CALLBACK_PORT}"
+
+
+# ── PKCE helpers ──────────────────────────────────────────────────
+
+def _generate_code_verifier() -> str:
+    """Generate a cryptographically random code verifier (43-128 chars)."""
+    return secrets.token_urlsafe(64)
+
+
+def _generate_code_challenge(verifier: str) -> str:
+    """SHA-256 hash the verifier and base64url-encode it."""
+    digest = hashlib.sha256(verifier.encode("ascii")).digest()
+    return base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+
+
+# ── Local config storage ─────────────────────────────────────────
+
+def load_config() -> dict:
+    """Load saved config from ~/.neuroncli/config.json."""
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            pass
+    return {}
+
+
+def save_config(data: dict) -> None:
+    """Save config to ~/.neuroncli/config.json."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+
+def get_stored_api_key() -> str | None:
+    """Get the stored OpenRouter API key, if any."""
+    config = load_config()
+    return config.get("openrouter_api_key")
+
+
+def store_api_key(key: str) -> None:
+    """Store the OpenRouter API key locally."""
+    config = load_config()
+    config["openrouter_api_key"] = key
+    save_config(config)
+
+
+# ── OAuth PKCE flow ──────────────────────────────────────────────
+
+class _OAuthCallbackHandler(http.server.BaseHTTPRequestHandler):
+    """Tiny HTTP handler that captures the OAuth redirect code."""
+
+    auth_code: str | None = None
+
+    def do_GET(self):
+        parsed = urllib.parse.urlparse(self.path)
+        params = urllib.parse.parse_qs(parsed.query)
+
+        code = params.get("code", [None])[0]
+
+        if code:
+            _OAuthCallbackHandler.auth_code = code
+            # Show success page
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"""
+            <html>
+            <head>
+                <style>
+                    body {
+                        font-family: -apple-system, 'Segoe UI', Roboto, sans-serif;
+                        display: flex; justify-content: center; align-items: center;
+                        min-height: 100vh; margin: 0;
+                        background: linear-gradient(135deg, #0f0f23 0%, #1a1a3e 100%);
+                        color: #e0e0e0;
+                    }
+                    .card {
+                        text-align: center; padding: 60px;
+                        background: rgba(255,255,255,0.05);
+                        border: 1px solid rgba(255,255,255,0.1);
+                        border-radius: 24px;
+                        backdrop-filter: blur(20px);
+                    }
+                    h1 { color: #00ff88; font-size: 2em; }
+                    p { color: #aaa; font-size: 1.1em; }
+                </style>
+            </head>
+            <body>
+                <div class="card">
+                    <h1>&#10003; NeuronCLI Connected</h1>
+                    <p>Your OpenRouter API key has been provisioned.<br>
+                    You can close this tab and return to the terminal.</p>
+                </div>
+            </body>
+            </html>
+            """)
+        else:
+            self.send_response(400)
+            self.send_header("Content-Type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"<h1>Error: No auth code received</h1>")
+
+    def log_message(self, format, *args):
+        """Suppress default HTTP server logging."""
+        pass
+
+
+def _exchange_code_for_key(code: str, code_verifier: str) -> str:
+    """POST to OpenRouter to exchange the auth code for an API key."""
+    payload = json.dumps({
+        "code": code,
+        "code_verifier": code_verifier,
+        "code_challenge_method": "S256",
+    }).encode("utf-8")
+
+    req = urllib.request.Request(
+        "https://openrouter.ai/api/v1/auth/keys",
+        data=payload,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            data = json.loads(resp.read().decode())
+            return data["key"]
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"OpenRouter key exchange failed (HTTP {e.code}): {body}")
+    except Exception as e:
+        raise RuntimeError(f"OpenRouter key exchange failed: {e}")
+
+
+def run_oauth_flow() -> str | None:
+    """
+    Run the full OAuth PKCE flow:
+    1. Generate PKCE challenge
+    2. Open browser to OpenRouter auth
+    3. Start localhost server to catch redirect
+    4. Exchange code for API key
+    5. Store key locally
+
+    Returns the API key on success, None on failure.
+    """
+    # Reset
+    _OAuthCallbackHandler.auth_code = None
+
+    # Generate PKCE pair
+    code_verifier = _generate_code_verifier()
+    code_challenge = _generate_code_challenge(code_verifier)
+
+    # Build auth URL
+    auth_url = (
+        f"https://openrouter.ai/auth?"
+        f"callback_url={urllib.parse.quote(CALLBACK_URL)}"
+        f"&code_challenge={code_challenge}"
+        f"&code_challenge_method=S256"
+    )
+
+    # Start callback server in background
+    server = http.server.HTTPServer(("127.0.0.1", CALLBACK_PORT), _OAuthCallbackHandler)
+    server.timeout = 120  # 2 minute timeout
+
+    print("\n  \033[96m\033[1m[AUTH]\033[0m Opening browser for OpenRouter login...")
+    print(f"  \033[90mIf browser doesn't open, visit:\033[0m")
+    print(f"  \033[90m{auth_url[:80]}...\033[0m\n")
+
+    # Open browser
+    webbrowser.open(auth_url)
+
+    print("  \033[93mWaiting for authentication...\033[0m", end="", flush=True)
+
+    # Wait for the callback (blocks until request or timeout)
+    try:
+        server.handle_request()  # Handles exactly one request
+    except Exception:
+        pass
+    finally:
+        server.server_close()
+
+    code = _OAuthCallbackHandler.auth_code
+    if not code:
+        print(f"\n  \033[91m[X] Authentication timed out or failed.\033[0m")
+        return None
+
+    print(f" \033[92m✓\033[0m")
+    print("  \033[96mExchanging code for API key...\033[0m", end="", flush=True)
+
+    # Exchange code for key
+    try:
+        api_key = _exchange_code_for_key(code, code_verifier)
+    except RuntimeError as e:
+        print(f"\n  \033[91m[X] {e}\033[0m")
+        return None
+
+    # Store
+    store_api_key(api_key)
+    print(f" \033[92m✓\033[0m")
+    print(f"  \033[92m\033[1m[OK] API key saved to {CONFIG_FILE}\033[0m\n")
+
+    return api_key
+
+
+# ── Public API ────────────────────────────────────────────────────
+
+def ensure_api_key() -> str | None:
+    """
+    Ensure an API key is available. Checks in order:
+    1. OPENROUTER_API_KEY env var
+    2. ~/.neuroncli/config.json
+    3. Interactive OAuth PKCE flow (first-run)
+
+    Returns the API key or None if all methods fail.
+    """
+    # Check env var first
+    env_key = os.environ.get("OPENROUTER_API_KEY")
+    if env_key:
+        return env_key
+
+    # Check local config
+    stored_key = get_stored_api_key()
+    if stored_key:
+        return stored_key
+
+    # First run — interactive OAuth
+    print("\n  \033[96m\033[1m╔════════════════════════════════════════════════╗")
+    print("  ║  Welcome to NeuronCLI!                         ║")
+    print("  ║  Let's connect your free OpenRouter account.   ║")
+    print("  ║  This only happens once.                       ║")
+    print("  ╚════════════════════════════════════════════════╝\033[0m")
+
+    return run_oauth_flow()

neuroncli/cli.py

@@ -0,0 +1,409 @@
+"""NeuronCLI — CLI v2.0. Full Claude Code-style interface with modes and trust prompt."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from .agent import Agent
+from .config import VERSION, AgentConfig, MODE_STANDARD, MODE_PLAN, MODE_YOLO
+from .provider import create_provider
+from .ui import (
+    render_startup_screen, _neuron_text, _ORANGE, _GREEN, _RED, _GRAY,
+    RST, BOLD, DIM,
+    SYM_OK, SYM_ERR, SYM_PROMPT,
+)
+
+
+# ── Argument Parser ───────────────────────────────────────────────
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="neuron",
+        description="NeuronCLI - AI Coding Agent powered by Kimi K2.5 + Ollama",
+    )
+    parser.add_argument("task", nargs="?", default=None,
+                        help="Task to execute (omit for interactive REPL)")
+    parser.add_argument("--model", "-m", default=None, help="Model to use")
+    parser.add_argument("--provider", "-p", choices=["openrouter", "ollama"],
+                        default=None, help="LLM provider")
+    parser.add_argument("--dir", "-d", default=None, help="Working directory")
+    parser.add_argument("--max-iter", type=int, default=None)
+    parser.add_argument("--no-stream", action="store_true")
+    parser.add_argument("--yolo", action="store_true",
+                        help="YOLO mode — skip all permission prompts")
+    parser.add_argument("--plan", action="store_true",
+                        help="Plan mode — reason and plan before coding")
+    parser.add_argument("--version", action="version",
+                        version=f"NeuronCLI v{VERSION}")
+    return parser
+
+
+# ── NEURON.md Support ─────────────────────────────────────────────
+
+def _find_neuron_md(working_dir: str) -> str | None:
+    p = os.path.join(working_dir, "NEURON.md")
+    if os.path.isfile(p):
+        try:
+            with open(p, "r", encoding="utf-8", errors="replace") as f:
+                return f.read()
+        except OSError:
+            pass
+    return None
+
+
+def _create_neuron_md(working_dir: str) -> None:
+    template = """# NEURON.md — Project Context for NeuronCLI
+
+## Project Overview
+<!-- Describe what this project does -->
+
+## Tech Stack
+<!-- List the technologies used -->
+
+## Project Structure
+<!-- Outline the key directories and files -->
+
+## Rules
+<!-- Workflow rules for the AI agent -->
+<!-- Examples: -->
+<!-- - Always create a git branch before making changes -->
+<!-- - Run tests after editing code -->
+<!-- - Use TypeScript, not JavaScript -->
+
+## Notes
+<!-- Any additional context -->
+"""
+    path = os.path.join(working_dir, "NEURON.md")
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(template)
+    print(f"  {_GREEN}{BOLD}v{RST} Created NEURON.md in {working_dir}")
+    print(f"  {DIM}Edit it to give NeuronCLI context about your project.{RST}\n")
+
+
+# ── Trust Prompt ──────────────────────────────────────────────────
+
+def _check_trust(working_dir: str) -> bool:
+    """Check if user trusts this directory (first-run security prompt)."""
+    trust_file = os.path.join(os.path.expanduser("~"), ".neuroncli", "trusted_dirs.txt")
+    os.makedirs(os.path.dirname(trust_file), exist_ok=True)
+
+    # Check if already trusted
+    if os.path.isfile(trust_file):
+        with open(trust_file, "r") as f:
+            trusted = [line.strip() for line in f.readlines()]
+            if working_dir in trusted:
+                return True
+
+    # Ask user to trust
+    print(f"\n  {_ORANGE}{BOLD}Security Check{RST}")
+    print(f"  {DIM}NeuronCLI can read, write, and execute commands in:{RST}")
+    print(f"  {BOLD}{working_dir}{RST}\n")
+
+    try:
+        response = input(f"  {_ORANGE}Press 1 to trust this directory:{RST} ").strip()
+    except (EOFError, KeyboardInterrupt):
+        return False
+
+    if response == "1":
+        with open(trust_file, "a") as f:
+            f.write(working_dir + "\n")
+        print(f"  {_GREEN}{BOLD}v{RST} Directory trusted.\n")
+        return True
+    else:
+        print(f"  {_RED}X{RST} Directory not trusted. Exiting.\n")
+        return False
+
+
+# ── Mode Display ──────────────────────────────────────────────────
+
+_MODE_LABELS = {
+    MODE_STANDARD: "",
+    MODE_PLAN:     f" {_ORANGE}[plan]{RST}",
+    MODE_YOLO:     f" {_RED}[yolo]{RST}",
+}
+
+
+# ── Interactive REPL ──────────────────────────────────────────────
+
+def run_repl(config: AgentConfig):
+    """Interactive session — full Claude Code-style experience."""
+    neuron_md = _find_neuron_md(config.working_dir)
+    agent = Agent(config)
+
+    # Render startup screen
+    startup = render_startup_screen(
+        working_dir=config.working_dir,
+        provider=config.provider,
+        model=config.active_model,
+        neuron_md_exists=neuron_md is not None,
+    )
+    print(startup)
+
+    # Mode indicator
+    mode_label = _MODE_LABELS.get(config.mode, "")
+    print(f"  {DIM}Type a task, /help for commands, /exit to quit.{RST}{mode_label}\n")
+
+    while True:
+        try:
+            mode_tag = _MODE_LABELS.get(config.mode, "")
+            prompt_text = f"  {_ORANGE}{BOLD}>{RST}{mode_tag} "
+            user_input = input(prompt_text).strip()
+            if not user_input:
+                continue
+
+            # Slash commands
+            if user_input.startswith("/"):
+                result = _handle_command(user_input, agent, config)
+                if result == "exit":
+                    break
+                # Refresh neuron_md in case /init was run
+                neuron_md = _find_neuron_md(config.working_dir)
+                continue
+
+            # Execute task
+            print()
+            agent.run(user_input, neuron_md=neuron_md)
+
+        except KeyboardInterrupt:
+            print(f"\n  {DIM}(interrupted){RST}")
+            continue
+        except EOFError:
+            break
+
+    print(f"\n  {DIM}Session ended.{RST}\n")
+
+
+def _handle_command(cmd: str, agent: Agent, config: AgentConfig) -> str | None:
+    parts = cmd.split(maxsplit=1)
+    command = parts[0].lower()
+    arg = parts[1] if len(parts) > 1 else ""
+
+    if command in ("/exit", "/quit", "/q"):
+        return "exit"
+
+    elif command == "/help":
+        print(f"""
+  {BOLD}Commands:{RST}
+    {_ORANGE}/help{RST}              Show this help
+    {_ORANGE}/exit{RST}              Exit NeuronCLI
+    {_ORANGE}/init{RST}              Create NEURON.md project context
+    {_ORANGE}/clear{RST}             Clear conversation history
+    {_ORANGE}/compact{RST}           Compress context (free up memory)
+    {_ORANGE}/mode <mode>{RST}       Switch mode: standard, plan, yolo
+    {_ORANGE}/model <name>{RST}      Switch model
+    {_ORANGE}/models{RST}            List available models
+    {_ORANGE}/provider <name>{RST}   Switch provider (openrouter/ollama)
+    {_ORANGE}/upgrade{RST}           Info on faster response times
+    {_ORANGE}/login{RST}             Re-authenticate with OpenRouter
+    {_ORANGE}/logout{RST}            Remove stored API key
+    {_ORANGE}/dir <path>{RST}        Change working directory
+    {_ORANGE}/status{RST}            Check provider connection
+    {_ORANGE}/config{RST}            Show current configuration
+""")
+
+    elif command == "/init":
+        _create_neuron_md(config.working_dir)
+
+    elif command == "/clear":
+        agent.clear_history()
+        print(f"  {_GREEN}{BOLD}v{RST} History cleared.\n")
+
+    elif command == "/compact":
+        removed = agent.compact()
+        if removed > 0:
+            print(f"  {_GREEN}{BOLD}v{RST} Context compressed ({removed} messages removed).\n")
+        else:
+            print(f"  {DIM}Context is already compact.{RST}\n")
+
+    elif command == "/mode":
+        if not arg:
+            print(f"  Mode: {BOLD}{config.mode}{RST}")
+            print(f"  {DIM}Options: standard, plan, yolo{RST}\n")
+        else:
+            new_mode = arg.strip().lower()
+            if new_mode in (MODE_STANDARD, MODE_PLAN, MODE_YOLO):
+                config.mode = new_mode
+                label = _MODE_LABELS.get(new_mode, "")
+                print(f"  {_GREEN}{BOLD}v{RST} Mode: {BOLD}{new_mode}{RST}{label}\n")
+            else:
+                print(f"  {_RED}X{RST} Unknown mode. Use: standard, plan, yolo\n")
+
+    elif command == "/upgrade":
+        print(f"""
+  {BOLD}Faster Responses{RST}
+
+  The free tier routes through OpenRouter's shared queue,
+  which can be slow during peak hours.
+
+  {_ORANGE}Option 1: Moonshot Direct ($1 one-time){RST}
+    Sign up at platform.moonshot.ai
+    $1 recharge = ~230 fast tasks
+    Set: NEURON_PROVIDER=moonshot
+
+  {_ORANGE}Option 2: Local Ollama (free, offline){RST}
+    Install from ollama.com
+    Run: ollama pull qwen2.5-coder:7b
+    Use: neuron --provider ollama
+
+  {_ORANGE}Option 3: Self-host Kimi K2.5{RST}
+    Requires a GPU with 48GB+ VRAM
+    Fastest possible, zero API cost
+""")
+
+    elif command == "/model":
+        if not arg:
+            print(f"  Model: {BOLD}{config.active_model}{RST}\n")
+        else:
+            if config.provider == "ollama":
+                config.ollama_model = arg.strip()
+            else:
+                config.model = arg.strip()
+            agent.client = create_provider(config)
+            print(f"  {_GREEN}{BOLD}v{RST} Model: {BOLD}{config.active_model}{RST}\n")
+
+    elif command == "/models":
+        models = agent.client.list_models()
+        if models:
+            print(f"\n  {BOLD}Models ({config.provider}):{RST}")
+            for m in models:
+                marker = f" {_GREEN}<{RST}" if m == config.active_model else ""
+                print(f"    {m}{marker}")
+            print()
+        else:
+            print(f"  {_RED}X{RST} Cannot fetch models.\n")
+
+    elif command == "/provider":
+        if not arg:
+            print(f"  Provider: {BOLD}{config.provider}{RST}\n")
+        else:
+            new_provider = arg.strip().lower()
+            if new_provider not in ("openrouter", "ollama"):
+                print(f"  {_RED}X{RST} Unknown provider. Use 'openrouter' or 'ollama'.\n")
+            else:
+                config.provider = new_provider
+                agent.client = create_provider(config)
+                print(f"  {_GREEN}{BOLD}v{RST} {new_provider} ({config.active_model})\n")
+
+    elif command == "/login":
+        from .auth import run_oauth_flow
+        new_key = run_oauth_flow()
+        if new_key:
+            config.api_key = new_key
+            config.provider = "openrouter"
+            agent.client = create_provider(config)
+            print(f"  {_GREEN}{BOLD}v{RST} Authenticated.\n")
+
+    elif command == "/logout":
+        from .auth import CONFIG_FILE
+        if CONFIG_FILE.exists():
+            CONFIG_FILE.unlink()
+            print(f"  {_GREEN}{BOLD}v{RST} API key removed.\n")
+        else:
+            print(f"  {DIM}No stored key.{RST}\n")
+
+    elif command == "/dir":
+        if not arg:
+            print(f"  Dir: {BOLD}{config.working_dir}{RST}\n")
+        else:
+            path = os.path.abspath(arg.strip())
+            if os.path.isdir(path):
+                config.working_dir = path
+                print(f"  {_GREEN}{BOLD}v{RST} {path}\n")
+            else:
+                print(f"  {_RED}X{RST} Not a directory: {path}\n")
+
+    elif command == "/status":
+        client = create_provider(config)
+        if client.health_check():
+            print(f"  {_GREEN}{BOLD}v{RST} {config.provider} is up ({config.active_model})\n")
+        else:
+            print(f"  {_RED}X{RST} {config.provider} is not responding.\n")
+
+    elif command == "/config":
+        key_display = "***" + config.api_key[-4:] if config.api_key else "(none)"
+        print(f"""
+  {BOLD}Configuration:{RST}
+    Provider:       {config.provider}
+    Model:          {config.active_model}
+    Mode:           {config.mode}
+    Temperature:    {config.temperature}
+    Max Tokens:     {config.max_tokens}
+    Max Iterations: {config.max_iterations}
+    Working Dir:    {config.working_dir}
+    Streaming:      {config.streaming}
+    API Key:        {key_display}
+""")
+
+    else:
+        print(f"  {DIM}Unknown command. Type /help{RST}\n")
+
+    return None
+
+
+# ── Main Entry Point ──────────────────────────────────────────────
+
+def main(argv: list[str] | None = None) -> int:
+    if sys.platform == "win32":
+        os.system("")
+        try:
+            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+            sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    config = AgentConfig.from_env()
+    if args.provider:
+        config.provider = args.provider
+    if args.model:
+        if config.provider == "ollama":
+            config.ollama_model = args.model
+        else:
+            config.model = args.model
+    if args.dir:
+        config.working_dir = args.dir
+    if args.max_iter:
+        config.max_iterations = args.max_iter
+    if args.no_stream:
+        config.streaming = False
+    if args.yolo:
+        config.mode = MODE_YOLO
+        config.confirm_dangerous = False
+    if args.plan:
+        config.mode = MODE_PLAN
+
+    # Check provider
+    client = create_provider(config)
+    if not client.health_check():
+        if config.provider == "openrouter":
+            print(f"\n  {_RED}X OpenRouter not reachable.{RST}")
+            print(f"  {DIM}Check internet or use --provider ollama{RST}\n")
+        else:
+            print(f"\n  {_RED}X Ollama not running.{RST}")
+            print(f"  {DIM}Start with: ollama serve{RST}\n")
+        return 1
+
+    # Trust check for REPL mode
+    if not args.task and not _check_trust(config.working_dir):
+        return 1
+
+    if args.task:
+        # One-shot mode
+        model_short = config.active_model.split("/")[-1]
+        mode_tag = f" [{config.mode}]" if config.mode != "standard" else ""
+        print(f"\n  {_neuron_text()} {DIM}v{VERSION} | {config.provider} | {model_short}{mode_tag}{RST}\n")
+        neuron_md = _find_neuron_md(config.working_dir)
+        agent = Agent(config)
+        result = agent.run(args.task, neuron_md=neuron_md)
+        return 0 if not result.aborted else 1
+    else:
+        run_repl(config)
+        return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())