nc1709 1.15.4__py3-none-any.whl

nc1709/remote_client.py

@@ -0,0 +1,266 @@
+"""
+NC1709 Remote Client
+Connects to a remote NC1709 server for LLM access
+"""
+import os
+import json
+from typing import Optional, Dict, Any
+from urllib.request import Request, urlopen
+from urllib.error import URLError, HTTPError
+
+
+class RemoteClient:
+    """Client for connecting to remote NC1709 server"""
+
+    def __init__(
+        self,
+        server_url: Optional[str] = None,
+        api_key: Optional[str] = None
+    ):
+        """Initialize remote client
+
+        Args:
+            server_url: URL of the NC1709 server (or set NC1709_API_URL env var)
+            api_key: API key for authentication (or set NC1709_API_KEY env var)
+        """
+        self.server_url = (
+            server_url or
+            os.environ.get("NC1709_API_URL") or
+            os.environ.get("NC1709_SERVER_URL")
+        )
+        self.api_key = (
+            api_key or
+            os.environ.get("NC1709_API_KEY")
+        )
+
+        if not self.server_url:
+            raise ValueError(
+                "No server URL provided. Set NC1709_API_URL environment variable "
+                "or pass server_url parameter."
+            )
+
+        # Normalize URL
+        self.server_url = self.server_url.rstrip("/")
+
+    def _make_request(
+        self,
+        endpoint: str,
+        method: str = "GET",
+        data: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """Make HTTP request to server
+
+        Args:
+            endpoint: API endpoint (e.g., "/api/remote/status")
+            method: HTTP method
+            data: JSON data for POST requests
+
+        Returns:
+            Response JSON
+        """
+        url = f"{self.server_url}{endpoint}"
+
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "nc1709-client/1.4.0"
+        }
+
+        if self.api_key:
+            headers["X-API-Key"] = self.api_key
+
+        body = json.dumps(data).encode("utf-8") if data else None
+
+        req = Request(url, data=body, headers=headers, method=method)
+
+        try:
+            with urlopen(req, timeout=120) as response:
+                return json.loads(response.read().decode("utf-8"))
+        except HTTPError as e:
+            error_body = e.read().decode("utf-8")
+            try:
+                error_json = json.loads(error_body)
+                detail = error_json.get("detail", error_body)
+            except json.JSONDecodeError:
+                detail = error_body
+
+            if e.code == 401:
+                raise ConnectionError(
+                    f"Authentication failed: {detail}\n"
+                    "Set NC1709_API_KEY environment variable with your API key."
+                )
+            raise ConnectionError(f"Server error ({e.code}): {detail}")
+        except URLError as e:
+            raise ConnectionError(
+                f"Cannot connect to NC1709 server at {self.server_url}\n"
+                f"Error: {e.reason}\n"
+                "Make sure the server is running and accessible."
+            )
+
+    def check_status(self) -> Dict[str, Any]:
+        """Check server status
+
+        Returns:
+            Server status information
+        """
+        return self._make_request("/api/remote/status")
+
+    def complete(
+        self,
+        prompt: str,
+        task_type: str = "general",
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None
+    ) -> str:
+        """Get LLM completion from remote server
+
+        Args:
+            prompt: User prompt
+            task_type: Task type (reasoning, coding, tools, general, fast)
+            system_prompt: Optional system prompt
+            temperature: Sampling temperature
+            max_tokens: Maximum tokens
+
+        Returns:
+            LLM response text
+        """
+        data = {
+            "prompt": prompt,
+            "task_type": task_type,
+            "temperature": temperature
+        }
+
+        if system_prompt:
+            data["system_prompt"] = system_prompt
+        if max_tokens:
+            data["max_tokens"] = max_tokens
+
+        result = self._make_request("/api/remote/complete", method="POST", data=data)
+        return result.get("response", "")
+
+    def chat(self, message: str) -> str:
+        """Send chat message to remote server (uses full reasoning engine)
+
+        Args:
+            message: User message
+
+        Returns:
+            Assistant response
+        """
+        data = {"message": message}
+        result = self._make_request("/api/remote/chat", method="POST", data=data)
+        return result.get("response", "")
+
+    def agent_chat(
+        self,
+        messages: list,
+        cwd: str,
+        tools: list = None
+    ) -> Dict[str, Any]:
+        """Send agent chat request - returns LLM response for local tool execution
+
+        This is the new architecture where:
+        - Server only runs LLM (thinking)
+        - Client executes tools locally
+
+        Args:
+            messages: Conversation history [{"role": "user/assistant", "content": "..."}]
+            cwd: Client's current working directory
+            tools: List of available tools on client
+
+        Returns:
+            Dict with 'response' (LLM output that may contain tool calls)
+        """
+        data = {
+            "messages": messages,
+            "cwd": cwd,
+            "tools": tools or []
+        }
+        return self._make_request("/api/remote/agent", method="POST", data=data)
+
+    def is_connected(self) -> bool:
+        """Check if connected to server
+
+        Returns:
+            True if server is reachable
+        """
+        try:
+            status = self.check_status()
+            return status.get("status") == "ok"
+        except Exception:
+            return False
+
+    def index_code(
+        self,
+        user_id: str,
+        files: list,
+        project_name: str = None
+    ) -> Dict[str, Any]:
+        """Index code files on the server's vector database
+
+        Args:
+            user_id: Unique user/session identifier
+            files: List of {"path": "...", "content": "...", "language": "..."}
+            project_name: Optional project name for grouping
+
+        Returns:
+            Indexing result with stats
+        """
+        data = {
+            "user_id": user_id,
+            "files": files,
+            "project_name": project_name
+        }
+        return self._make_request("/api/remote/index", method="POST", data=data)
+
+    def search_code(
+        self,
+        user_id: str,
+        query: str,
+        n_results: int = 5,
+        project_name: str = None
+    ) -> Dict[str, Any]:
+        """Search indexed code on the server
+
+        Args:
+            user_id: User identifier
+            query: Search query
+            n_results: Number of results to return
+            project_name: Optional project filter
+
+        Returns:
+            Search results
+        """
+        data = {
+            "user_id": user_id,
+            "query": query,
+            "n_results": n_results,
+            "project_name": project_name
+        }
+        return self._make_request("/api/remote/search", method="POST", data=data)
+
+
+def get_remote_client() -> Optional[RemoteClient]:
+    """Get remote client if configured
+
+    Returns:
+        RemoteClient instance if NC1709_API_URL is set, None otherwise
+    """
+    if os.environ.get("NC1709_API_URL") or os.environ.get("NC1709_SERVER_URL"):
+        try:
+            return RemoteClient()
+        except ValueError:
+            return None
+    return None
+
+
+def is_remote_mode() -> bool:
+    """Check if running in remote mode
+
+    Returns:
+        True if NC1709_API_URL is set
+    """
+    return bool(
+        os.environ.get("NC1709_API_URL") or
+        os.environ.get("NC1709_SERVER_URL")
+    )

nc1709/shell_completions.py

@@ -0,0 +1,349 @@
+"""
+Shell Completions Generator
+Generates completion scripts for bash, zsh, and fish shells
+"""
+import os
+from typing import Optional
+
+
+# Bash completion script
+BASH_COMPLETION = '''
+# NC1709 Bash Completion
+# Add to ~/.bashrc or ~/.bash_profile:
+# source <(nc1709 --completion bash)
+# or: eval "$(nc1709 --completion bash)"
+
+_nc1709_completions() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+
+    # Main options
+    opts="--help --version --web --shell --config --resume --remote --api-key --serve --port --plugins --plugin --completion --mcp-serve"
+
+    # Shell commands (when in interactive mode)
+    shell_commands="help exit quit clear history config sessions index search plugins git docker mcp"
+
+    # Plugin commands
+    plugin_opts="git:status git:diff git:log git:branch git:commit git:push git:pull docker:ps docker:images docker:logs docker:compose_up docker:compose_down fastapi:scaffold nextjs:scaffold django:scaffold"
+
+    case "${prev}" in
+        --plugin)
+            COMPREPLY=( $(compgen -W "${plugin_opts}" -- ${cur}) )
+            return 0
+            ;;
+        --completion)
+            COMPREPLY=( $(compgen -W "bash zsh fish" -- ${cur}) )
+            return 0
+            ;;
+        --port)
+            COMPREPLY=()
+            return 0
+            ;;
+        --remote|--api-key)
+            COMPREPLY=()
+            return 0
+            ;;
+        --resume)
+            # Could add session completion here
+            COMPREPLY=()
+            return 0
+            ;;
+    esac
+
+    # Complete options or files
+    if [[ ${cur} == -* ]]; then
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+    else
+        # Complete files for potential file paths
+        COMPREPLY=( $(compgen -f -- ${cur}) )
+    fi
+
+    return 0
+}
+
+complete -F _nc1709_completions nc1709
+'''
+
+
+# Zsh completion script
+ZSH_COMPLETION = '''
+#compdef nc1709
+
+# NC1709 Zsh Completion
+# Add to ~/.zshrc:
+# source <(nc1709 --completion zsh)
+# or: eval "$(nc1709 --completion zsh)"
+# or save to ~/.zsh/completions/_nc1709
+
+_nc1709() {
+    local -a commands
+    local -a options
+    local -a plugins
+
+    options=(
+        '--help[Show help message]'
+        '--version[Show version]'
+        '--web[Start web dashboard]'
+        '--shell[Start interactive shell]'
+        '--config[Show configuration]'
+        '--resume[Resume session]:session_id:'
+        '--remote[Remote server URL]:url:'
+        '--api-key[API key for remote server]:key:'
+        '--serve[Enable remote access]'
+        '--port[Server port]:port:'
+        '--plugins[List available plugins]'
+        '--plugin[Run a plugin]:plugin:->plugins'
+        '--completion[Generate shell completion]:shell:(bash zsh fish)'
+        '--mcp-serve[Start MCP server]'
+    )
+
+    plugins=(
+        'git\\:status:Show git status'
+        'git\\:diff:Show git diff'
+        'git\\:log:Show git log'
+        'git\\:branch:List branches'
+        'git\\:commit:Create commit'
+        'git\\:push:Push to remote'
+        'git\\:pull:Pull from remote'
+        'docker\\:ps:List containers'
+        'docker\\:images:List images'
+        'docker\\:logs:View logs'
+        'docker\\:compose_up:Start compose'
+        'docker\\:compose_down:Stop compose'
+        'fastapi\\:scaffold:Create FastAPI project'
+        'nextjs\\:scaffold:Create Next.js project'
+        'django\\:scaffold:Create Django project'
+    )
+
+    case $state in
+        plugins)
+            _describe 'plugin' plugins
+            ;;
+        *)
+            _arguments -s $options
+            ;;
+    esac
+}
+
+_nc1709 "$@"
+'''
+
+
+# Fish completion script
+FISH_COMPLETION = '''
+# NC1709 Fish Completion
+# Add to ~/.config/fish/completions/nc1709.fish
+# or: nc1709 --completion fish > ~/.config/fish/completions/nc1709.fish
+
+# Main options
+complete -c nc1709 -l help -d "Show help message"
+complete -c nc1709 -l version -d "Show version"
+complete -c nc1709 -l web -d "Start web dashboard"
+complete -c nc1709 -l shell -d "Start interactive shell"
+complete -c nc1709 -l config -d "Show configuration"
+complete -c nc1709 -l resume -d "Resume session" -x
+complete -c nc1709 -l remote -d "Remote server URL" -x
+complete -c nc1709 -l api-key -d "API key for remote server" -x
+complete -c nc1709 -l serve -d "Enable remote access"
+complete -c nc1709 -l port -d "Server port" -x
+complete -c nc1709 -l plugins -d "List available plugins"
+complete -c nc1709 -l plugin -d "Run a plugin" -xa "
+    git:status\t'Show git status'
+    git:diff\t'Show git diff'
+    git:log\t'Show git log'
+    git:branch\t'List branches'
+    git:commit\t'Create commit'
+    git:push\t'Push to remote'
+    git:pull\t'Pull from remote'
+    docker:ps\t'List containers'
+    docker:images\t'List images'
+    docker:logs\t'View logs'
+    docker:compose_up\t'Start compose'
+    docker:compose_down\t'Stop compose'
+    fastapi:scaffold\t'Create FastAPI project'
+    nextjs:scaffold\t'Create Next.js project'
+    django:scaffold\t'Create Django project'
+"
+complete -c nc1709 -l completion -d "Generate shell completion" -xa "bash zsh fish"
+complete -c nc1709 -l mcp-serve -d "Start MCP server"
+
+# File completion for positional arguments
+complete -c nc1709 -f -a "(__fish_complete_path)"
+'''
+
+
+def get_completion_script(shell: str) -> str:
+    """Get completion script for specified shell
+
+    Args:
+        shell: Shell type (bash, zsh, fish)
+
+    Returns:
+        Completion script content
+    """
+    scripts = {
+        "bash": BASH_COMPLETION,
+        "zsh": ZSH_COMPLETION,
+        "fish": FISH_COMPLETION
+    }
+
+    script = scripts.get(shell.lower())
+    if not script:
+        raise ValueError(f"Unknown shell: {shell}. Supported: bash, zsh, fish")
+
+    return script.strip()
+
+
+def install_completions(shell: Optional[str] = None) -> str:
+    """Install completions for the detected or specified shell
+
+    Args:
+        shell: Shell type (auto-detect if None)
+
+    Returns:
+        Installation status message
+    """
+    if shell is None:
+        shell = detect_shell()
+
+    script = get_completion_script(shell)
+    home = os.path.expanduser("~")
+
+    if shell == "bash":
+        # Try to install to .bash_completion.d or .bashrc
+        completion_dir = os.path.join(home, ".bash_completion.d")
+        if os.path.isdir(completion_dir):
+            path = os.path.join(completion_dir, "nc1709")
+            with open(path, "w") as f:
+                f.write(script)
+            return f"Installed to {path}. Restart your shell to use completions."
+        else:
+            # Add to .bashrc
+            bashrc = os.path.join(home, ".bashrc")
+            source_line = '\n# NC1709 completions\neval "$(nc1709 --completion bash)"\n'
+            with open(bashrc, "a") as f:
+                f.write(source_line)
+            return f"Added to {bashrc}. Run 'source ~/.bashrc' or restart your shell."
+
+    elif shell == "zsh":
+        # Install to .zsh/completions or add to .zshrc
+        completion_dir = os.path.join(home, ".zsh", "completions")
+        os.makedirs(completion_dir, exist_ok=True)
+        path = os.path.join(completion_dir, "_nc1709")
+        with open(path, "w") as f:
+            f.write(script)
+
+        # Ensure completions dir is in fpath
+        zshrc = os.path.join(home, ".zshrc")
+        fpath_line = f'\nfpath=({completion_dir} $fpath)\nautoload -Uz compinit && compinit\n'
+
+        # Check if already added
+        try:
+            with open(zshrc, "r") as f:
+                content = f.read()
+            if completion_dir not in content:
+                with open(zshrc, "a") as f:
+                    f.write(fpath_line)
+        except FileNotFoundError:
+            with open(zshrc, "w") as f:
+                f.write(fpath_line)
+
+        return f"Installed to {path}. Run 'source ~/.zshrc' or restart your shell."
+
+    elif shell == "fish":
+        # Install to fish completions directory
+        completion_dir = os.path.join(home, ".config", "fish", "completions")
+        os.makedirs(completion_dir, exist_ok=True)
+        path = os.path.join(completion_dir, "nc1709.fish")
+        with open(path, "w") as f:
+            f.write(script)
+        return f"Installed to {path}. Completions will be available in new fish sessions."
+
+    else:
+        raise ValueError(f"Cannot install completions for shell: {shell}")
+
+
+def detect_shell() -> str:
+    """Detect the current shell
+
+    Returns:
+        Shell name (bash, zsh, or fish)
+    """
+    shell_path = os.environ.get("SHELL", "")
+    shell_name = os.path.basename(shell_path)
+
+    if "zsh" in shell_name:
+        return "zsh"
+    elif "fish" in shell_name:
+        return "fish"
+    else:
+        return "bash"
+
+
+def print_installation_instructions(shell: str) -> None:
+    """Print installation instructions for a shell
+
+    Args:
+        shell: Shell type
+    """
+    instructions = {
+        "bash": """
+# Bash Completion Installation
+
+Option 1: Add to .bashrc (recommended)
+  echo 'eval "$(nc1709 --completion bash)"' >> ~/.bashrc
+  source ~/.bashrc
+
+Option 2: Create completion file
+  nc1709 --completion bash > ~/.bash_completion.d/nc1709
+  # Requires bash-completion to be installed
+""",
+        "zsh": """
+# Zsh Completion Installation
+
+Option 1: Add to .zshrc (simplest)
+  echo 'eval "$(nc1709 --completion zsh)"' >> ~/.zshrc
+  source ~/.zshrc
+
+Option 2: Save to completions directory
+  mkdir -p ~/.zsh/completions
+  nc1709 --completion zsh > ~/.zsh/completions/_nc1709
+  # Add to .zshrc: fpath=(~/.zsh/completions $fpath)
+  # Then run: autoload -Uz compinit && compinit
+""",
+        "fish": """
+# Fish Completion Installation
+
+  nc1709 --completion fish > ~/.config/fish/completions/nc1709.fish
+
+  # Completions will be available immediately in new shells
+"""
+    }
+
+    print(instructions.get(shell, f"Unknown shell: {shell}"))
+
+
+# Entry point for CLI
+def handle_completion_command(args: list) -> None:
+    """Handle completion command from CLI
+
+    Args:
+        args: Command arguments (e.g., ['bash'] or ['--install', 'zsh'])
+    """
+    if not args:
+        # Print detected shell and instructions
+        shell = detect_shell()
+        print(f"Detected shell: {shell}")
+        print_installation_instructions(shell)
+        return
+
+    if args[0] == "--install":
+        shell = args[1] if len(args) > 1 else None
+        result = install_completions(shell)
+        print(result)
+    else:
+        # Print completion script
+        shell = args[0]
+        print(get_completion_script(shell))