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

npcsh/alicanto.py

@@ -0,0 +1,65 @@
+"""
+alicanto - Deep research mode CLI entry point
+
+This is a thin wrapper that executes the alicanto.jinx through the jinx mechanism.
+"""
+import argparse
+import os
+import sys
+
+from npcsh._state import setup_shell
+
+
+def main():
+    parser = argparse.ArgumentParser(description="alicanto - Deep research with multiple perspectives")
+    parser.add_argument("query", nargs="*", help="Research query")
+    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("--num-npcs", type=int, default=5, help="Number of research perspectives")
+    parser.add_argument("--depth", type=int, default=3, help="Research depth")
+    parser.add_argument("--max-steps", type=int, default=20, help="Maximum research steps")
+    parser.add_argument("--exploration", type=float, default=0.3, help="Exploration factor (0-1)")
+    parser.add_argument("--creativity", type=float, default=0.5, help="Creativity factor (0-1)")
+    parser.add_argument("--format", type=str, default="report", choices=["report", "summary", "full"],
+                        help="Output format")
+    parser.add_argument("--with-research", action="store_true", help="Include web research")
+    args = parser.parse_args()
+
+    if not args.query:
+        parser.print_help()
+        sys.exit(1)
+
+    # Setup shell to get team and default NPC
+    command_history, team, default_npc = setup_shell()
+
+    if not team or "alicanto" not in team.jinxs_dict:
+        print("Error: alicanto jinx not found. Ensure npc_team/jinxs/modes/alicanto.jinx exists.")
+        sys.exit(1)
+
+    # Build context for jinx execution
+    context = {
+        "npc": default_npc,
+        "team": team,
+        "messages": [],
+        "query": " ".join(args.query),
+        "model": args.model,
+        "provider": args.provider,
+        "num_npcs": args.num_npcs,
+        "depth": args.depth,
+        "max_steps": args.max_steps,
+        "exploration": args.exploration,
+        "creativity": args.creativity,
+        "format": args.format,
+        "skip_research": not args.with_research,
+    }
+
+    # Execute the jinx
+    alicanto_jinx = team.jinxs_dict["alicanto"]
+    result = alicanto_jinx.execute(context=context, npc=default_npc)
+
+    if isinstance(result, dict) and result.get("output"):
+        print(result["output"])
+
+
+if __name__ == "__main__":
+    main()

npcsh/build.py

@@ -0,0 +1,291 @@
+import os
+import shutil
+import textwrap
+from pathlib import Path
+
+
+def build_flask_server(config, **kwargs):
+    output_dir = Path(config['output_dir'])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    server_script = output_dir / 'npc_server.py'
+    
+    server_code = textwrap.dedent(f'''
+    import os
+    from npcpy.serve import start_flask_server
+    from npcpy.npc_compiler import Team
+    from sqlalchemy import create_engine
+    
+    if __name__ == "__main__":
+        team_path = os.path.join(
+            os.path.dirname(__file__), 
+            "npc_team"
+        )
+        db_path = os.path.expanduser("~/npcsh_history.db")
+        
+        db_conn = create_engine(f'sqlite:///{{db_path}}')
+        team = Team(team_path=team_path, db_conn=db_conn)
+        
+        start_flask_server(
+            port={config['port']},
+            cors_origins={config.get('cors_origins')},
+            teams={{"main": team}},
+            npcs=team.npcs,
+            db_path=db_path,
+            user_npc_directory=os.path.expanduser(
+                "~/.npcsh/npc_team"
+            )
+        )
+    ''')
+    
+    server_script.write_text(server_code)
+    
+    shutil.copytree(
+        config['team_path'], 
+        output_dir / 'npc_team',
+        dirs_exist_ok=True
+    )
+    
+    requirements = output_dir / 'requirements.txt'
+    requirements.write_text(
+        'npcsh\n'
+        'flask\n'
+        'flask-cors\n'
+        'sqlalchemy\n'
+    )
+    
+    readme = output_dir / 'README.md'
+    readme.write_text(textwrap.dedent(f'''
+    # NPC Team Server
+    
+    Run: python npc_server.py
+    
+    Server will be available at http://localhost:{config['port']}
+    
+    For pyinstaller standalone:
+    pyinstaller --onefile npc_server.py
+    '''))
+    
+    return {
+        "output": f"Flask server built in {output_dir}", 
+        "messages": kwargs.get('messages', [])
+    }
+
+
+def build_docker_compose(config, **kwargs):
+    output_dir = Path(config['output_dir'])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    shutil.copytree(
+        config['team_path'], 
+        output_dir / 'npc_team',
+        dirs_exist_ok=True
+    )
+    
+    dockerfile = output_dir / 'Dockerfile'
+    dockerfile.write_text(textwrap.dedent('''
+    FROM python:3.11-slim
+    
+    WORKDIR /app
+    
+    COPY requirements.txt .
+    RUN pip install --no-cache-dir -r requirements.txt
+    
+    COPY npc_team ./npc_team
+    COPY npc_server.py .
+    
+    EXPOSE 5337
+    
+    CMD ["python", "npc_server.py"]
+    '''))
+    
+    compose = output_dir / 'docker-compose.yml'
+    compose.write_text(textwrap.dedent(f'''
+    version: '3.8'
+    
+    services:
+      npc-server:
+        build: .
+        ports:
+          - "{config['port']}:{config['port']}"
+        volumes:
+          - npc-data:/root/.npcsh
+        environment:
+          - NPCSH_DB_PATH=/root/.npcsh/npcsh_history.db
+    
+    volumes:
+      npc-data:
+    '''))
+    
+    build_flask_server(config, **kwargs)
+    
+    return {
+        "output": f"Docker compose built in {output_dir}. Run: docker-compose up", 
+        "messages": kwargs.get('messages', [])
+    }
+
+
+def build_cli_executable(config, **kwargs):
+    output_dir = Path(config['output_dir'])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    cli_script = output_dir / 'npc_cli.py'
+    
+    cli_code = textwrap.dedent('''
+    import sys
+    from npcsh._state import setup_shell, execute_command, initial_state
+    from npcsh.routes import router
+    
+    def main():
+        if len(sys.argv) < 2:
+            print("Usage: npc_cli <command>")
+            sys.exit(1)
+        
+        command = " ".join(sys.argv[1:])
+        
+        command_history, team, npc = setup_shell()
+        initial_state.npc = npc
+        initial_state.team = team
+        
+        state, result = execute_command(
+            command, 
+            initial_state, 
+            router=router
+        )
+        
+        output = result.get('output') if isinstance(result, dict) else result
+        print(output)
+    
+    if __name__ == "__main__":
+        main()
+    ''')
+    
+    cli_script.write_text(cli_code)
+    
+    shutil.copytree(
+        config['team_path'], 
+        output_dir / 'npc_team',
+        dirs_exist_ok=True
+    )
+    
+    spec_file = output_dir / 'npc_cli.spec'
+    spec_file.write_text(textwrap.dedent('''
+    a = Analysis(
+        ['npc_cli.py'],
+        pathex=[],
+        binaries=[],
+        datas=[('npc_team', 'npc_team')],
+        hiddenimports=[],
+        hookspath=[],
+        hooksconfig={},
+        runtime_hooks=[],
+        excludes=[],
+        win_no_prefer_redirects=False,
+        win_private_assemblies=False,
+        cipher=None,
+        noarchive=False,
+    )
+    pyz = PYZ(a.pure, a.zipped_data, cipher=None)
+    
+    exe = EXE(
+        pyz,
+        a.scripts,
+        a.binaries,
+        a.zipfiles,
+        a.datas,
+        [],
+        name='npc',
+        debug=False,
+        bootloader_ignore_signals=False,
+        strip=False,
+        upx=True,
+        upx_exclude=[],
+        runtime_tmpdir=None,
+        console=True,
+    )
+    '''))
+    
+    return {
+        "output": (
+            f"CLI executable built in {output_dir}. "
+            f"Run: pyinstaller npc_cli.spec"
+        ), 
+        "messages": kwargs.get('messages', [])
+    }
+
+
+def build_static_site(config, **kwargs):
+    output_dir = Path(config['output_dir'])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    html = output_dir / 'index.html'
+    html.write_text(textwrap.dedent(f'''
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>NPC Team Interface</title>
+        <style>
+            body {{ 
+                font-family: monospace; 
+                max-width: 800px; 
+                margin: 50px auto; 
+            }}
+            #output {{ 
+                white-space: pre-wrap; 
+                background: #f5f5f5; 
+                padding: 20px; 
+                min-height: 300px; 
+            }}
+        </style>
+    </head>
+    <body>
+        <h1>NPC Team</h1>
+        <input id="input" type="text" 
+               placeholder="Enter command..." 
+               style="width: 100%; padding: 10px;">
+        <div id="output"></div>
+        
+        <script>
+        const API_URL = '{config.get("api_url", "http://localhost:5337")}';
+        
+        document.getElementById('input').addEventListener('keypress', 
+            async (e) => {{
+            if (e.key === 'Enter') {{
+                const cmd = e.target.value;
+                e.target.value = '';
+                
+                const resp = await fetch(`${{API_URL}}/api/stream`, {{
+                    method: 'POST',
+                    headers: {{'Content-Type': 'application/json'}},
+                    body: JSON.stringify({{
+                        commandstr: cmd,
+                        conversationId: 'web-session',
+                        model: 'llama3.2',
+                        provider: 'ollama'
+                    }})
+                }});
+                
+                const reader = resp.body.getReader();
+                const decoder = new TextDecoder();
+                
+                while (true) {{
+                    const {{done, value}} = await reader.read();
+                    if (done) break;
+                    
+                    const text = decoder.decode(value);
+                    document.getElementById('output').textContent += text;
+                }}
+            }}
+        }});
+        </script>
+    </body>
+    </html>
+    '''))
+    
+    return {
+        "output": (
+            f"Static site built in {output_dir}. "
+            f"Serve with: python -m http.server 8000"
+        ), 
+        "messages": kwargs.get('messages', [])
+    }

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')