npcsh 1.1.12__py3-none-any.whl → 1.1.14__py3-none-any.whl

npcsh/completion.py

@@ -0,0 +1,206 @@
+"""
+Readline and tab completion for npcsh
+"""
+import os
+import shutil
+from typing import List, Any, Optional
+
+try:
+    import readline
+except ImportError:
+    readline = None
+
+from .config import READLINE_HISTORY_FILE
+
+
+def setup_readline() -> str:
+    """Set up readline with history and completion"""
+    if readline is None:
+        return ""
+
+    history_file = READLINE_HISTORY_FILE
+
+    try:
+        readline.read_history_file(history_file)
+    except FileNotFoundError:
+        pass
+
+    readline.set_history_length(10000)
+    readline.parse_and_bind("tab: complete")
+
+    return history_file
+
+
+def save_readline_history():
+    """Save readline history to file"""
+    if readline is None:
+        return
+
+    try:
+        readline.write_history_file(READLINE_HISTORY_FILE)
+    except Exception:
+        pass
+
+
+def get_path_executables() -> List[str]:
+    """Get list of executables in PATH"""
+    executables = set()
+
+    path_dirs = os.environ.get("PATH", "").split(os.pathsep)
+
+    for path_dir in path_dirs:
+        if os.path.isdir(path_dir):
+            try:
+                for entry in os.listdir(path_dir):
+                    full_path = os.path.join(path_dir, entry)
+                    if os.access(full_path, os.X_OK):
+                        executables.add(entry)
+            except PermissionError:
+                pass
+
+    return sorted(executables)
+
+
+def get_file_completions(text: str) -> List[str]:
+    """Get file/directory completions for text"""
+    completions = []
+
+    if text.startswith("~"):
+        expanded = os.path.expanduser(text)
+        prefix = "~"
+        search_path = expanded
+    else:
+        prefix = ""
+        search_path = text
+
+    # Get directory to search
+    if os.path.isdir(search_path):
+        dir_path = search_path
+        name_prefix = ""
+    else:
+        dir_path = os.path.dirname(search_path) or "."
+        name_prefix = os.path.basename(search_path)
+
+    if not os.path.isdir(dir_path):
+        return completions
+
+    try:
+        for entry in os.listdir(dir_path):
+            if entry.startswith(name_prefix):
+                full_path = os.path.join(dir_path, entry)
+                if os.path.isdir(full_path):
+                    completions.append(entry + "/")
+                else:
+                    completions.append(entry)
+    except PermissionError:
+        pass
+
+    return completions
+
+
+def get_slash_commands(state: Any, router: Any) -> List[str]:
+    """Get list of available slash commands"""
+    commands = set()
+
+    # Built-in commands and modes
+    commands.update([
+        '/help', '/set', '/agent', '/chat', '/cmd',
+        '/sq', '/quit', '/exit', '/clear',
+    ])
+
+    # Team jinxs
+    if state.team and hasattr(state.team, 'jinxs_dict'):
+        for name in state.team.jinxs_dict:
+            commands.add(f'/{name}')
+
+    # Router jinxs
+    if router and hasattr(router, 'jinx_routes'):
+        for name in router.jinx_routes:
+            commands.add(f'/{name}')
+
+    return sorted(commands)
+
+
+def get_npc_mentions(state: Any) -> List[str]:
+    """Get list of available @npc mentions"""
+    npcs = set()
+
+    # Team NPCs
+    if state.team and hasattr(state.team, 'npcs'):
+        for name in state.team.npcs:
+            npcs.add(f'@{name}')
+
+    # Also add forenpc if available
+    if state.team and hasattr(state.team, 'forenpc') and state.team.forenpc:
+        npcs.add(f'@{state.team.forenpc.name}')
+
+    # Default NPCs if team not loaded yet
+    if not npcs:
+        npcs.update(['@sibiji', '@guac', '@corca', '@kadiefa', '@plonk', '@forenpc'])
+
+    return sorted(npcs)
+
+
+def is_command_position(buffer: str, begidx: int) -> bool:
+    """Check if we're completing a command (vs argument)"""
+    # If we're at the start or after a pipe, it's command position
+    before = buffer[:begidx].strip()
+    return not before or before.endswith('|')
+
+
+def make_completer(shell_state: Any, router: Any):
+    """Create a completer function for readline"""
+
+    executables = get_path_executables()
+
+    def completer(text: str, state: int):
+        if readline is None:
+            return None
+
+        try:
+            buffer = readline.get_line_buffer()
+            begidx = readline.get_begidx()
+
+            # Build completion options
+            options = []
+
+            # Refresh slash commands and NPC mentions each time (they may change)
+            slash_commands = get_slash_commands(shell_state, router)
+            npc_mentions = get_npc_mentions(shell_state)
+
+            if text.startswith('/'):
+                # Slash command completion
+                options = [c for c in slash_commands if c.startswith(text)]
+
+            elif text.startswith('@'):
+                # @npc mention completion
+                options = [n for n in npc_mentions if n.startswith(text)]
+
+            elif text.startswith('~') or '/' in text or text.startswith('.'):
+                # File path completion
+                options = get_file_completions(text)
+
+            elif is_command_position(buffer, begidx):
+                # Command completion
+                options = [e for e in executables if e.startswith(text)]
+
+            else:
+                # Default to file completion
+                options = get_file_completions(text)
+
+            if state < len(options):
+                return options[state]
+            return None
+
+        except Exception:
+            return None
+
+    return completer
+
+
+def readline_safe_prompt(prompt: str) -> str:
+    """Make prompt safe for readline (escape ANSI codes)"""
+    if readline is None:
+        return prompt
+    # Wrap non-printing characters
+    return prompt.replace('\x1b[', '\x01\x1b[').replace('m', 'm\x02')

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