npcsh 0.1.2__py3-none-any.whl → 1.1.13__py3-none-any.whl

npcsh/config.py

@@ -0,0 +1,163 @@
+"""
+npcsh configuration management
+"""
+import os
+import importlib.metadata
+from typing import Optional, Dict, Any
+
+# Version
+try:
+    VERSION = importlib.metadata.version("npcsh")
+except importlib.metadata.PackageNotFoundError:
+    VERSION = "unknown"
+
+# Default paths
+DEFAULT_NPC_TEAM_PATH = "~/.npcsh/npc_team"
+PROJECT_NPC_TEAM_PATH = "./npc_team"
+HISTORY_DB_DEFAULT_PATH = "~/.npcsh_history.db"
+READLINE_HISTORY_FILE = os.path.expanduser("~/.npcsh_history")
+
+# Environment defaults
+NPCSH_CHAT_MODEL = os.environ.get("NPCSH_CHAT_MODEL", "gemma3:4b")
+NPCSH_CHAT_PROVIDER = os.environ.get("NPCSH_CHAT_PROVIDER", "ollama")
+NPCSH_DB_PATH = os.path.expanduser(
+    os.environ.get("NPCSH_DB_PATH", "~/npcsh_history.db")
+)
+NPCSH_VECTOR_DB_PATH = os.path.expanduser(
+    os.environ.get("NPCSH_VECTOR_DB_PATH", "~/npcsh_chroma.db")
+)
+NPCSH_DEFAULT_MODE = os.environ.get("NPCSH_DEFAULT_MODE", "agent")
+NPCSH_VISION_MODEL = os.environ.get("NPCSH_VISION_MODEL", "gemma3:4b")
+NPCSH_VISION_PROVIDER = os.environ.get("NPCSH_VISION_PROVIDER", "ollama")
+NPCSH_IMAGE_GEN_MODEL = os.environ.get(
+    "NPCSH_IMAGE_GEN_MODEL", "runwayml/stable-diffusion-v1-5"
+)
+NPCSH_IMAGE_GEN_PROVIDER = os.environ.get("NPCSH_IMAGE_GEN_PROVIDER", "diffusers")
+NPCSH_VIDEO_GEN_MODEL = os.environ.get(
+    "NPCSH_VIDEO_GEN_MODEL", "damo-vilab/text-to-video-ms-1.7b"
+)
+NPCSH_VIDEO_GEN_PROVIDER = os.environ.get("NPCSH_VIDEO_GEN_PROVIDER", "diffusers")
+NPCSH_EMBEDDING_MODEL = os.environ.get("NPCSH_EMBEDDING_MODEL", "nomic-embed-text")
+NPCSH_EMBEDDING_PROVIDER = os.environ.get("NPCSH_EMBEDDING_PROVIDER", "ollama")
+NPCSH_REASONING_MODEL = os.environ.get("NPCSH_REASONING_MODEL", "deepseek-r1")
+NPCSH_REASONING_PROVIDER = os.environ.get("NPCSH_REASONING_PROVIDER", "ollama")
+NPCSH_STREAM_OUTPUT = os.environ.get("NPCSH_STREAM_OUTPUT", "0") == "1"
+NPCSH_API_URL = os.environ.get("NPCSH_API_URL", None)
+NPCSH_SEARCH_PROVIDER = os.environ.get("NPCSH_SEARCH_PROVIDER", "duckduckgo")
+NPCSH_BUILD_KG = os.environ.get("NPCSH_BUILD_KG") == "1"
+
+
+def get_shell_config_file() -> str:
+    """Get the path to the user's shell config file"""
+    shell = os.environ.get("SHELL", "/bin/bash")
+
+    if "zsh" in shell:
+        return os.path.expanduser("~/.zshrc")
+    elif "fish" in shell:
+        return os.path.expanduser("~/.config/fish/config.fish")
+    else:
+        return os.path.expanduser("~/.bashrc")
+
+
+def get_npcshrc_path() -> str:
+    """Get path to npcshrc file"""
+    return os.path.expanduser("~/.npcshrc")
+
+
+def get_npcshrc_path_windows():
+    """Get npcshrc path on Windows"""
+    return os.path.expanduser("~/.npcshrc")
+
+
+def ensure_npcshrc_exists() -> str:
+    """Ensure npcshrc file exists and return its path"""
+    npcshrc_path = get_npcshrc_path()
+
+    if not os.path.exists(npcshrc_path):
+        default_content = f"""# npcsh configuration file
+export NPCSH_CHAT_MODEL="{NPCSH_CHAT_MODEL}"
+export NPCSH_CHAT_PROVIDER="{NPCSH_CHAT_PROVIDER}"
+export NPCSH_VISION_MODEL="{NPCSH_VISION_MODEL}"
+export NPCSH_VISION_PROVIDER="{NPCSH_VISION_PROVIDER}"
+export NPCSH_EMBEDDING_MODEL="{NPCSH_EMBEDDING_MODEL}"
+export NPCSH_EMBEDDING_PROVIDER="{NPCSH_EMBEDDING_PROVIDER}"
+export NPCSH_SEARCH_PROVIDER="{NPCSH_SEARCH_PROVIDER}"
+export NPCSH_DEFAULT_MODE="{NPCSH_DEFAULT_MODE}"
+export NPCSH_STREAM_OUTPUT="0"
+"""
+        with open(npcshrc_path, 'w') as f:
+            f.write(default_content)
+
+    return npcshrc_path
+
+
+def add_npcshrc_to_shell_config() -> None:
+    """Add sourcing of npcshrc to shell config if not present"""
+    shell_config = get_shell_config_file()
+    npcshrc_path = get_npcshrc_path()
+
+    source_line = f'source "{npcshrc_path}"'
+
+    if os.path.exists(shell_config):
+        with open(shell_config, 'r') as f:
+            content = f.read()
+        if npcshrc_path not in content and '.npcshrc' not in content:
+            with open(shell_config, 'a') as f:
+                f.write(f"\n# Source npcsh configuration\n{source_line}\n")
+
+
+def setup_npcsh_config() -> None:
+    """Set up npcsh configuration"""
+    ensure_npcshrc_exists()
+    add_npcshrc_to_shell_config()
+
+
+def is_npcsh_initialized() -> bool:
+    """Check if npcsh has been initialized"""
+    marker = os.path.expanduser("~/.npcsh/.initialized")
+    return os.path.exists(marker)
+
+
+def set_npcsh_initialized() -> None:
+    """Mark npcsh as initialized"""
+    npcsh_dir = os.path.expanduser("~/.npcsh")
+    os.makedirs(npcsh_dir, exist_ok=True)
+    marker = os.path.join(npcsh_dir, ".initialized")
+    with open(marker, 'w') as f:
+        f.write("1")
+
+
+def set_npcsh_config_value(key: str, value: str) -> None:
+    """Set a value in npcshrc"""
+    npcshrc_path = ensure_npcshrc_exists()
+
+    with open(npcshrc_path, 'r') as f:
+        lines = f.readlines()
+
+    found = False
+    for i, line in enumerate(lines):
+        if line.strip().startswith(f'export {key}='):
+            lines[i] = f'export {key}="{value}"\n'
+            found = True
+            break
+
+    if not found:
+        lines.append(f'export {key}="{value}"\n')
+
+    with open(npcshrc_path, 'w') as f:
+        f.writelines(lines)
+
+    # Also set in current environment
+    os.environ[key] = value
+
+
+def get_setting_windows(key, default=None):
+    """Get setting on Windows"""
+    npcshrc_path = get_npcshrc_path_windows()
+    if os.path.exists(npcshrc_path):
+        with open(npcshrc_path, 'r') as f:
+            for line in f:
+                if line.strip().startswith(f'export {key}='):
+                    value = line.split('=', 1)[1].strip().strip('"').strip("'")
+                    return value
+    return default

npcsh/corca.py

@@ -0,0 +1,50 @@
+"""
+corca - MCP-powered agentic shell CLI entry point
+
+This is a thin wrapper that executes the corca.jinx through the jinx mechanism.
+"""
+import argparse
+import os
+import sys
+
+from npcsh._state import setup_shell
+
+
+def main():
+    parser = argparse.ArgumentParser(description="corca - MCP-powered agentic shell")
+    parser.add_argument("command", nargs="*", help="Optional one-shot command to execute")
+    parser.add_argument("--model", "-m", type=str, help="LLM model to use")
+    parser.add_argument("--provider", "-p", type=str, help="LLM provider to use")
+    parser.add_argument("--mcp-server", type=str, help="Path to MCP server script")
+    args = parser.parse_args()
+
+    # Setup shell to get team and default NPC
+    command_history, team, default_npc = setup_shell()
+
+    if not team or "corca" not in team.jinxs_dict:
+        print("Error: corca jinx not found. Ensure npc_team/jinxs/modes/corca.jinx exists.")
+        sys.exit(1)
+
+    # Build context for jinx execution
+    initial_command = " ".join(args.command) if args.command else None
+
+    context = {
+        "npc": default_npc,
+        "team": team,
+        "messages": [],
+        "model": args.model,
+        "provider": args.provider,
+        "mcp_server_path": args.mcp_server,
+        "initial_command": initial_command,
+    }
+
+    # Execute the jinx
+    corca_jinx = team.jinxs_dict["corca"]
+    result = corca_jinx.execute(context=context, npc=default_npc)
+
+    if isinstance(result, dict) and result.get("output"):
+        print(result["output"])
+
+
+if __name__ == "__main__":
+    main()

npcsh/execution.py

@@ -0,0 +1,185 @@
+"""
+Command execution utilities for npcsh
+"""
+import os
+import shutil
+import subprocess
+import sys
+from typing import List, Tuple, Any, Optional
+
+from termcolor import colored
+
+
+# Commands that require interactive terminal handling
+TERMINAL_EDITORS = ['vim', 'nvim', 'nano', 'vi', 'emacs', 'less', 'more', 'man']
+
+# Interactive commands that need special handling (command -> args)
+INTERACTIVE_COMMANDS = {
+    'ipython': ['ipython'],
+    'python': ['python', '-i'],
+    'python3': ['python3', '-i'],
+    'node': ['node'],
+    'irb': ['irb'],
+    'ghci': ['ghci'],
+    'mysql': ['mysql'],
+    'psql': ['psql'],
+    'sqlite3': ['sqlite3'],
+    'redis-cli': ['redis-cli'],
+    'mongo': ['mongo'],
+    'ssh': ['ssh'],
+    'telnet': ['telnet'],
+    'ftp': ['ftp'],
+    'sftp': ['sftp'],
+    'top': ['top'],
+    'htop': ['htop'],
+    'watch': ['watch'],
+    'r': ['R', '--interactive'],
+}
+
+
+def validate_bash_command(command_parts: List[str]) -> bool:
+    """
+    Check if the command is a valid bash command.
+
+    Returns True if the command exists in PATH or is a shell builtin.
+    """
+    if not command_parts:
+        return False
+
+    cmd = command_parts[0]
+
+    # Check shell builtins
+    builtins = {'cd', 'pwd', 'echo', 'export', 'source', 'alias', 'unalias',
+                'history', 'set', 'unset', 'read', 'eval', 'exec', 'exit',
+                'return', 'shift', 'trap', 'wait', 'jobs', 'fg', 'bg',
+                'kill', 'ulimit', 'umask', 'type', 'hash', 'true', 'false'}
+
+    if cmd in builtins:
+        return True
+
+    # Check if command exists in PATH
+    return shutil.which(cmd) is not None
+
+
+def handle_bash_command(
+    cmd_parts: List[str],
+    full_cmd: str,
+    stdin_input: Optional[str],
+    state: Any
+) -> Tuple[bool, str]:
+    """
+    Execute a bash command and return the result.
+
+    Args:
+        cmd_parts: Parsed command parts
+        full_cmd: Full command string
+        stdin_input: Input to pipe to command
+        state: Shell state
+
+    Returns:
+        Tuple of (success, output)
+    """
+    try:
+        result = subprocess.run(
+            full_cmd,
+            shell=True,
+            capture_output=True,
+            text=True,
+            cwd=state.current_path,
+            input=stdin_input,
+            timeout=300
+        )
+
+        if result.returncode == 0:
+            output = result.stdout
+            if result.stderr:
+                output += f"\n{result.stderr}"
+            return True, output.strip()
+        else:
+            error = result.stderr or result.stdout or f"Command exited with code {result.returncode}"
+            return False, error.strip()
+
+    except subprocess.TimeoutExpired:
+        return False, "Command timed out after 5 minutes"
+    except Exception as e:
+        return False, str(e)
+
+
+def open_terminal_editor(command: str) -> str:
+    """Open a terminal editor command interactively"""
+    try:
+        subprocess.run(command, shell=True)
+        return "Editor session completed"
+    except Exception as e:
+        return f"Editor error: {e}"
+
+
+def handle_cd_command(cmd_parts: List[str], state: Any) -> Tuple[Any, str]:
+    """Handle the cd command"""
+    if len(cmd_parts) < 2:
+        new_path = os.path.expanduser("~")
+    else:
+        new_path = os.path.expanduser(cmd_parts[1])
+
+    if not os.path.isabs(new_path):
+        new_path = os.path.join(state.current_path, new_path)
+
+    new_path = os.path.normpath(new_path)
+
+    if os.path.isdir(new_path):
+        state.current_path = new_path
+        os.chdir(new_path)
+        return state, f"Changed to: {new_path}"
+    else:
+        return state, colored(f"Directory not found: {new_path}", "red")
+
+
+def handle_interactive_command(cmd_parts: List[str], state: Any) -> Tuple[Any, str]:
+    """Handle interactive commands by running them in a subprocess"""
+    command = ' '.join(cmd_parts)
+    try:
+        subprocess.run(command, shell=True, cwd=state.current_path)
+        return state, f"Interactive session ({cmd_parts[0]}) completed"
+    except KeyboardInterrupt:
+        return state, colored("Session interrupted", "yellow")
+    except Exception as e:
+        return state, colored(f"Error: {e}", "red")
+
+
+def start_interactive_session(command: str) -> int:
+    """Start an interactive shell session"""
+    try:
+        return subprocess.call(command, shell=True)
+    except Exception as e:
+        print(colored(f"Error starting session: {e}", "red"))
+        return 1
+
+
+def list_directory(args: List[str]) -> None:
+    """List directory contents with formatting"""
+    path = args[0] if args else "."
+    path = os.path.expanduser(path)
+
+    if not os.path.exists(path):
+        print(colored(f"Path not found: {path}", "red"))
+        return
+
+    if os.path.isfile(path):
+        print(path)
+        return
+
+    try:
+        entries = os.listdir(path)
+        entries.sort()
+
+        for entry in entries:
+            full_path = os.path.join(path, entry)
+            if os.path.isdir(full_path):
+                print(colored(entry + "/", "blue", attrs=["bold"]))
+            elif os.access(full_path, os.X_OK):
+                print(colored(entry, "green", attrs=["bold"]))
+            else:
+                print(entry)
+
+    except PermissionError:
+        print(colored(f"Permission denied: {path}", "red"))

npcsh/guac.py

@@ -0,0 +1,46 @@
+"""
+guac - Python data analysis mode CLI entry point
+
+This is a thin wrapper that executes the guac.jinx through the jinx mechanism.
+"""
+import argparse
+import os
+import sys
+
+from npcsh._state import setup_shell
+
+
+def main():
+    parser = argparse.ArgumentParser(description="guac - Python data analysis mode")
+    parser.add_argument("--model", "-m", type=str, help="LLM model to use")
+    parser.add_argument("--provider", "-p", type=str, help="LLM provider to use")
+    parser.add_argument("--plots-dir", type=str, help="Directory to save plots")
+    args = parser.parse_args()
+
+    # Setup shell to get team and default NPC
+    command_history, team, default_npc = setup_shell()
+
+    if not team or "guac" not in team.jinxs_dict:
+        print("Error: guac jinx not found. Ensure npc_team/jinxs/modes/guac.jinx exists.")
+        sys.exit(1)
+
+    # Build context for jinx execution
+    context = {
+        "npc": default_npc,
+        "team": team,
+        "messages": [],
+        "model": args.model,
+        "provider": args.provider,
+        "plots_dir": args.plots_dir,
+    }
+
+    # Execute the jinx
+    guac_jinx = team.jinxs_dict["guac"]
+    result = guac_jinx.execute(context=context, npc=default_npc)
+
+    if isinstance(result, dict) and result.get("output"):
+        print(result["output"])
+
+
+if __name__ == "__main__":
+    main()