framework.py

#!/usr/bin/python3
import platform
import os
import importlib
import re
from colorama import Fore, Style, init
import time
import sys
from eula import check_eula
from prompts import get_prompt, prompt_selector, STYLES, load_prompt_style
from prompt_colors import get_kali_prompt, color_selector, COLOR_SCHEMES
from config import config_selector, load_config, get_config, _init_colors, _C_ACCENT, _C_WHITE, _C_GREEN, _C_RED, _C_DIM, _C_GRAY, _C_BORDER, _C_SECTION, _C_CYAN
import getpass

# Initialize colorama for cross-platform ANSI support
init()

# Syntax highlighting + fast history + completion via prompt_toolkit
try:
    from prompt_toolkit import PromptSession
    from prompt_toolkit.lexers import Lexer
    from prompt_toolkit.history import FileHistory
    from prompt_toolkit.formatted_text import ANSI
    from prompt_toolkit.styles import Style as PTStyle
    from prompt_toolkit.completion import Completer, Completion
    from prompt_toolkit.shortcuts import CompleteStyle
    from prompt_toolkit.filters import Condition
    from prompt_toolkit.key_binding import KeyBindings
    from prompt_toolkit.keys import Keys
    HAS_PROMPT_TOOLKIT = True
except ImportError:
    HAS_PROMPT_TOOLKIT = False

# readline fallback for history (no syntax highlighting)
try:
    import readline
    HAS_READLINE = True
except ImportError:
    HAS_READLINE = False

# variables de formateo y colores
subrayado = '\033[4m'
morado = '\033[38;5;135m'

# sistema operativo y arquitectura
sistema = platform.system()
arquitectura = platform.architecture()[0]

# variables de estética
usuario = getpass.getuser()

# Navigation path (list of segments, e.g. ["pentesting", "red", "dos"])
nav_path = []

# variable de bucle principal
is_running = True

# Command history
HISTORY_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "config", "cmd_history.txt")
MAX_HISTORY = 200

# =================== CATEGORY TREE ===================

CATEGORY_TREE = {
    "pentesting": {
        "_desc": "Herramientas de seguridad ofensiva",
        "_help": "Suite de herramientas de seguridad ofensiva para pruebas de penetración. Incluye módulos para ataques de red, WiFi, web y Active Directory.",
        "red": {
            "_desc": "Ataques de red",
            "_help": "Herramientas para ataques a nivel de red local: denegación de servicio, man-in-the-middle, escaneo de puertos y captura de tráfico.",
            "dos": {
                "_desc": "Denegacion de servicio",
                "_help": "Herramientas de denegación de servicio que permiten bloquear o interrumpir la conectividad de objetivos en la red.",
                "internetblocker": {
                    "_desc": "Bloquea el acceso a internet de uno o más objetivos",
                    "_tool": "pentesting.red.dos.internetblocker",
                },
            },
            "mitm": {"_desc": "Man in the middle"},
            "scan": {"_desc": "Escaneo de red"},
            "sniff": {"_desc": "Captura de trafico"},
        },
        "wifi": {
            "_desc": "Ataques inalambricos",
            "_help": "Suite para ataques orientados a redes inalámbricas: desautenticación, captura de handshakes y auditoría de redes WiFi.",
            "deauth": {
                "_desc": "Desautenticacion",
                "_help": "Ataques de desautenticación WiFi para desconectar clientes de puntos de acceso.",
                "deauther": {
                    "_desc": "Desconecta a uno o varios clientes de la red wifi seleccionada",
                    "_tool": "pentesting.wifi.deauth.deauther",
                },
            },
        },
        "web": {"_desc": "Pentesting web"},
        "ad": {"_desc": "Active Directory"},
    },
    "osint": {"_desc": "Inteligencia de fuentes abiertas"},
}


def get_node(path_list):
    """Traverse the tree and return the node at the given path."""
    node = CATEGORY_TREE
    for segment in path_list:
        if segment in node and isinstance(node[segment], dict):
            node = node[segment]
        else:
            return None
    return node


def get_children(path_list):
    """Return a dict of {name: node} for children of the current path, excluding _keys."""
    node = get_node(path_list)
    if node is None:
        return {}
    return {k: v for k, v in node.items() if not k.startswith("_") and isinstance(v, dict)}


def is_tool_node(node):
    """Check if a node is a tool (has _tool key)."""
    return node is not None and "_tool" in node


# =================== VALID COMMANDS ===================

BASE_COMMANDS = {'help', 'clear', 'set-style', 'set-prompt', 'config', 'ai', 'salir', 'exit', 'ls', 'cd', 'run', 'x'}


def _get_valid_commands():
    """Return the set of valid commands at the current tree position."""
    return BASE_COMMANDS.copy()


def _is_valid_command(text):
    """Check if text starts with a valid framework command."""
    stripped = text.strip()
    if not stripped:
        return False
    first_word = stripped.split()[0]
    if first_word in BASE_COMMANDS:
        return True
    return False


# =================== PATH RESOLUTION ===================

def _resolve_path(path_str):
    """Resolve a path string to a nav_path list. Returns (path_list, error_msg)."""
    if not path_str or path_str == '/':
        return [], None

    if path_str.startswith('/'):
        parts = [p for p in path_str.split('/') if p]
    else:
        parts = list(nav_path)
        for segment in path_str.split('/'):
            if segment == '..':
                if parts:
                    parts.pop()
                else:
                    return None, "Ya estás en el directorio raíz"
            elif segment and segment != '.':
                parts.append(segment)

    node = get_node(parts)
    if node is None:
        return None, f"La ruta '/{'/'.join(parts)}' no existe"
    if is_tool_node(node):
        return None, f"'{'/'.join(parts)}' es una herramienta, no una categoría (usa 'run')"

    return parts, None


def _collect_tools_at_path(path_list):
    """Recursively collect all tool names accessible from path_list."""
    result = {}
    children = get_children(path_list)
    for name, child in children.items():
        if is_tool_node(child):
            result[name] = child.get("_desc", "tool")
        else:
            result.update(_collect_tools_at_path(path_list + [name]))
    return result


def _collect_direct_tools(path_list):
    """Collect only tools that are direct children of the current path."""
    result = {}
    children = get_children(path_list)
    for name, child in children.items():
        if is_tool_node(child):
            result[name] = child.get("_desc", "tool")
    return result


# =================== PROMPT_TOOLKIT SETUP ===================

_pt_session = None

if HAS_PROMPT_TOOLKIT:
    class FrameworkLexer(Lexer):
        def lex_document(self, document):
            def get_line(lineno):
                text = document.lines[lineno]
                stripped = text.lstrip()
                if not stripped:
                    return [('', text)]

                tokens = []
                leading = text[:len(text) - len(stripped)]
                if leading:
                    tokens.append(('', leading))

                cmd_class = 'class:command' if get_config("command_highlight") != "off" else ''

                first_space = stripped.find(' ')
                if first_space == -1:
                    if stripped in BASE_COMMANDS:
                        tokens.append((cmd_class, stripped))
                    elif any(cmd.startswith(stripped) for cmd in BASE_COMMANDS):
                        tokens.append(('class:partial', stripped))
                    else:
                        tokens.append(('', stripped))
                else:
                    cmd = stripped[:first_space]
                    args = stripped[first_space + 1:]

                    if cmd in BASE_COMMANDS:
                        tokens.append((cmd_class, cmd))
                    elif any(c.startswith(cmd) for c in BASE_COMMANDS):
                        tokens.append(('class:partial', cmd))
                    else:
                        tokens.append(('', cmd))

                    tokens.append(('', ' '))

                    if cmd == 'cd':
                        tokens.extend(self._lex_cd_path(args))
                    elif cmd == 'run':
                        tokens.extend(self._lex_run_arg(args))
                    elif cmd == 'help':
                        tokens.extend(self._lex_help_arg(args))
                    elif cmd == 'ai':
                        # AI prompt — just show as dim text
                        tokens.append(('class:partial', args))
                    else:
                        tokens.append(('', args))

                return tokens
            return get_line

        def _lex_help_arg(self, arg):
            """Tokenize a help argument (module path or tool name)."""
            tokens = []
            if not arg:
                return tokens

            # Check if it's a path with /
            if '/' in arg:
                parts = arg.split('/')
                for i, part in enumerate(parts):
                    test_path = parts[:i + 1]
                    node = get_node(test_path)
                    if node and not is_tool_node(node):
                        tokens.append(('class:path-segment', part))
                    elif node and is_tool_node(node):
                        tokens.append(('class:tool-name', part))
                    else:
                        tokens.append(('class:partial', part))
                    if i < len(parts) - 1:
                        tokens.append(('class:path-segment', '/'))
            else:
                # Single word — could be a module or tool at current path
                tools = _collect_tools_at_path(nav_path)
                if arg in tools:
                    tokens.append(('class:tool-name', arg))
                else:
                    children = get_children(nav_path)
                    top_children = get_children([])
                    found = False
                    for name in children:
                        if name == arg and not is_tool_node(children[name]):
                            tokens.append(('class:path-segment', arg))
                            found = True
                            break
                    if not found:
                        for name in top_children:
                            if name == arg and not is_tool_node(top_children[name]):
                                tokens.append(('class:path-segment', arg))
                                found = True
                                break
                    if not found and any(name.startswith(arg) for name in tools):
                        tokens.append(('class:partial', arg))
                    elif not found:
                        tokens.append(('', arg))
            return tokens

        def _lex_cd_path(self, path_str):
            """Tokenize a cd path argument with per-segment validation."""
            tokens = []
            if not path_str:
                return tokens

            if path_str.startswith('/'):
                current_path = []
            else:
                current_path = list(nav_path)

            parts = path_str.split('/')
            for i, part in enumerate(parts):
                is_last = (i == len(parts) - 1)

                if not part:
                    if i == 0:
                        tokens.append(('class:path-segment', '/'))
                    elif not is_last:
                        if len(current_path) > 0 and get_node(current_path) is not None:
                            tokens.append(('class:path-segment', '/'))
                        else:
                            tokens.append(('', '/'))
                    continue

                if part == '..':
                    tokens.append((cmd_class, part))
                    if current_path:
                        current_path.pop()
                elif part == '.':
                    tokens.append(('', part))
                else:
                    test_path = current_path + [part]
                    node = get_node(test_path)
                    if node is not None and not is_tool_node(node):
                        tokens.append(('class:path-segment', part))
                        current_path.append(part)
                    elif node is not None and is_tool_node(node):
                        tokens.append(('class:partial', part))
                    else:
                        tokens.append(('class:partial', part))

                if not is_last:
                    if len(current_path) > 0 and get_node(current_path) is not None:
                        tokens.append(('class:path-segment', '/'))
                    else:
                        tokens.append(('', '/'))

            return tokens

        def _lex_run_arg(self, tool_arg):
            """Tokenize a run tool-name or path argument."""
            tokens = []
            if not tool_arg:
                return tokens

            direct_tools = _collect_direct_tools(nav_path)

            # Split path part from flag/arg part at first space
            first_space = tool_arg.find(' ')
            if first_space != -1:
                path_part = tool_arg[:first_space]
                rest_part = tool_arg[first_space:]
            else:
                path_part = tool_arg
                rest_part = ""

            # Path-based: tokenize segment by segment
            if '/' in path_part:
                if path_part.startswith('/'):
                    current_path = []
                else:
                    current_path = list(nav_path)

                parts = path_part.split('/')
                for i, part in enumerate(parts):
                    is_last = (i == len(parts) - 1)

                    if not part:
                        if i == 0:
                            tokens.append(('class:path-segment', '/'))
                        elif not is_last:
                            if len(current_path) > 0 and get_node(current_path) is not None:
                                tokens.append(('class:path-segment', '/'))
                            else:
                                tokens.append(('', '/'))
                        continue

                    test_path = current_path + [part]
                    node = get_node(test_path)
                    if node is not None and is_tool_node(node):
                        tokens.append(('class:tool-name', part))
                        current_path.append(part)
                    elif node is not None and not is_tool_node(node):
                        tokens.append(('class:path-segment', part))
                        current_path.append(part)
                    else:
                        tokens.append(('class:partial', part))

                    if not is_last:
                        if len(current_path) > 0 and get_node(current_path) is not None:
                            tokens.append(('class:path-segment', '/'))
                        else:
                            tokens.append(('', '/'))

            elif path_part in direct_tools:
                tokens.append(('class:tool-name', path_part))
            elif any(name.startswith(path_part) for name in direct_tools):
                tokens.append(('class:partial', path_part))
            elif path_part:
                tokens.append(('', path_part))

            # Flags/args after the path
            if rest_part:
                i = 0
                while i < len(rest_part):
                    if rest_part[i] == ' ':
                        j = i
                        while j < len(rest_part) and rest_part[j] == ' ':
                            j += 1
                        tokens.append(('', rest_part[i:j]))
                        i = j
                    elif rest_part[i] == '-':
                        j = i
                        while j < len(rest_part) and rest_part[j] != ' ':
                            j += 1
                        tokens.append(('', rest_part[i:j]))
                        i = j
                    else:
                        j = i
                        while j < len(rest_part) and rest_part[j] != ' ':
                            j += 1
                        tokens.append(('', rest_part[i:j]))
                        i = j

            return tokens

    _PT_STYLE = PTStyle.from_dict({
        'command':      'ansiblue bold',
        'path-segment': 'ansiwhite bold',
        'partial':      '',
        'tool-name':    'ansigreen bold',
    })

    class FrameworkCompleter(Completer):
        def get_completions(self, document, complete_event):
            text = document.text_before_cursor
            stripped = text.lstrip()

            if not stripped:
                for cmd in sorted(BASE_COMMANDS):
                    yield Completion(cmd, start_position=0, display_meta="command")
                return

            first_space = stripped.find(' ')

            if first_space == -1:
                partial = stripped
                for cmd in sorted(BASE_COMMANDS):
                    if cmd.startswith(partial) and cmd != partial:
                        yield Completion(cmd, start_position=-len(partial), display_meta="command")
                return

            cmd = stripped[:first_space]
            arg_part = stripped[first_space + 1:]

            if cmd == 'cd':
                yield from self._complete_cd_path(arg_part)
            elif cmd == 'run':
                yield from self._complete_run_tool(arg_part)
            elif cmd == 'help':
                yield from self._complete_help(arg_part)

        def _complete_cd_path(self, arg_part):
            """Complete cd argument with category paths."""
            if arg_part.startswith('/'):
                current_path = []
                remaining = arg_part[1:]
            else:
                current_path = list(nav_path)
                remaining = arg_part

            segments = [s for s in remaining.split('/') if s]
            trailing_slash = remaining.endswith('/')

            if segments:
                for seg in segments[:-1] if not trailing_slash else segments:
                    if seg == '..':
                        if current_path:
                            current_path.pop()
                    elif seg and seg != '.':
                        current_path.append(seg)

                node = get_node(current_path)
                if node is None or is_tool_node(node):
                    return

                if trailing_slash:
                    partial = ''
                else:
                    partial = segments[-1]
                    if partial == '..':
                        yield Completion('..', start_position=-len(partial), display_meta="parent")
                        return

                children = get_children(current_path)
                for name, child in sorted(children.items()):
                    if name.startswith(partial) and not is_tool_node(child):
                        yield Completion(
                            name + '/',
                            start_position=-len(partial),
                            display_meta=child.get("_desc", "category")
                        )
            else:
                children = get_children(current_path)
                for name, child in sorted(children.items()):
                    if not is_tool_node(child):
                        yield Completion(
                            name + '/',
                            start_position=0,
                            display_meta=child.get("_desc", "category")
                        )

        def _complete_run_tool(self, arg_part):
            """Complete run argument with tool names and paths."""
            partial = arg_part.lstrip()

            # If arg contains /, complete as a path
            if '/' in partial:
                if partial.startswith('/'):
                    current_path = []
                    remaining = partial[1:]
                else:
                    current_path = list(nav_path)
                    remaining = partial

                segments = [s for s in remaining.split('/') if s]
                trailing_slash = remaining.endswith('/')

                if segments:
                    for seg in segments[:-1] if not trailing_slash else segments:
                        if seg and seg != '.':
                            current_path.append(seg)

                    node = get_node(current_path)
                    if node is None or is_tool_node(node):
                        return

                    if trailing_slash:
                        last_partial = ''
                    else:
                        last_partial = segments[-1]

                    children = get_children(current_path)
                    for name, child in sorted(children.items()):
                        if name.startswith(last_partial):
                            if is_tool_node(child):
                                yield Completion(
                                    name,
                                    start_position=-len(last_partial),
                                    display_meta=f"tool: {child.get('_desc', '')}"
                                )
                            else:
                                yield Completion(
                                    name + '/',
                                    start_position=-len(last_partial),
                                    display_meta=child.get("_desc", "category")
                                )
                else:
                    # Just "/" typed — complete from root
                    children = get_children([])
                    for name, child in sorted(children.items()):
                        if not is_tool_node(child):
                            yield Completion(
                                name + '/',
                                start_position=0,
                                display_meta=child.get("_desc", "category")
                            )
                return

            # No / — complete with direct tools in current dir
            tools = _collect_direct_tools(nav_path)
            for name, desc in sorted(tools.items()):
                if name.startswith(partial) and name != partial:
                    yield Completion(name, start_position=-len(partial), display_meta=desc)

        def _complete_help(self, arg_part):
            """Complete help argument with module paths and tool names."""
            partial = arg_part.lstrip()
            if not partial:
                # Show both modules and tools at current path
                children = get_children(nav_path)
                for name, child in sorted(children.items()):
                    if is_tool_node(child):
                        yield Completion(name, start_position=0, display_meta=f"tool: {child.get('_desc', '')}")
                    else:
                        yield Completion(name + '/', start_position=0, display_meta=child.get("_desc", "category"))
                # Also show top-level modules
                top_children = get_children([])
                for name, child in sorted(top_children.items()):
                    if not is_tool_node(child):
                        yield Completion(name + '/', start_position=0, display_meta=child.get("_desc", "category"))
            else:
                # Try to complete as a path
                if '/' in partial:
                    # Path-style completion (e.g., "red/dos")
                    parts = partial.split('/')
                    last = parts[-1]
                    parent = parts[:-1]
                    test_path, _ = _resolve_path('/'.join(parent)) if parent else (list(nav_path), None)
                    if test_path is None:
                        test_path = list(nav_path)
                    node = get_node(test_path)
                    if node and not is_tool_node(node):
                        children = get_children(test_path)
                        for name, child in sorted(children.items()):
                            if name.startswith(last):
                                if is_tool_node(child):
                                    yield Completion(name, start_position=-len(last), display_meta=f"tool: {child.get('_desc', '')}")
                                else:
                                    yield Completion(name + '/', start_position=-len(last), display_meta=child.get("_desc", "category"))
                else:
                    # Single segment: match modules and tools at current path
                    children = get_children(nav_path)
                    for name, child in sorted(children.items()):
                        if name.startswith(partial) and name != partial:
                            if is_tool_node(child):
                                yield Completion(name, start_position=-len(partial), display_meta=f"tool: {child.get('_desc', '')}")
                            else:
                                yield Completion(name + '/', start_position=-len(partial), display_meta=child.get("_desc", "category"))
                    # Also match top-level modules
                    top_children = get_children([])
                    for name, child in sorted(top_children.items()):
                        if name.startswith(partial) and name != partial and not is_tool_node(child):
                            yield Completion(name + '/', start_position=-len(partial), display_meta=child.get("_desc", "category"))

    class MinimalCompleter(Completer):
        """Tab completes like bash: prefix then list below, no dropdown menu."""
        def get_completions(self, document, complete_event):
            text = document.text_before_cursor
            stripped = text.lstrip()

            if not stripped:
                return

            first_space = stripped.find(' ')

            if first_space == -1:
                partial = stripped
                for cmd in sorted(BASE_COMMANDS):
                    if cmd.startswith(partial) and cmd != partial:
                        yield Completion(cmd, start_position=-len(partial))
                return

            cmd = stripped[:first_space]
            arg_part = stripped[first_space + 1:]

            if cmd == 'cd':
                for c in FrameworkCompleter()._complete_cd_path(arg_part):
                    yield Completion(c.text, start_position=c.start_position)
            elif cmd == 'run':
                for c in FrameworkCompleter()._complete_run_tool(arg_part):
                    yield Completion(c.text, start_position=c.start_position)
            elif cmd == 'help':
                for c in FrameworkCompleter()._complete_help(arg_part):
                    yield Completion(c.text, start_position=c.start_position)

    def _get_prompt_session():
        global _pt_session
        if _pt_session is None:
            autocompletion = get_config("autocompletion")
            completer = None
            if autocompletion == "full":
                completer = FrameworkCompleter()
            elif autocompletion == "minimal":
                completer = MinimalCompleter()

            # Key bindings for spotlight (Ctrl+Space)
            kb = KeyBindings()

            @kb.add(Keys.ControlSpace)
            def _spotlight_handler(event):
                """Save state and exit prompt so main loop can open spotlight."""
                global _spotlight_pending, _spotlight_saved_text
                _spotlight_pending = True
                _spotlight_saved_text = event.app.current_buffer.text
                event.app.exit()

            # Minimal mode: block Tab when completions visible (prevent cycling)
            if autocompletion == "minimal":
                def _completions_visible():
                    try:
                        from prompt_toolkit import get_app
                        return get_app().current_buffer.complete_state is not None
                    except Exception:
                        return False

                @kb.add(Keys.Tab, filter=Condition(_completions_visible))
                def _minimal_tab_block(event):
                    pass  # Prevent cycling through completions

            cwt = autocompletion == "full"
            cstyle = CompleteStyle.READLINE_LIKE if autocompletion == "minimal" else CompleteStyle.COLUMN

            _pt_session = PromptSession(
                history=FileHistory(HISTORY_FILE),
                style=_PT_STYLE,
                lexer=FrameworkLexer(),
                completer=completer,
                complete_while_typing=cwt,
                complete_style=cstyle,
                key_bindings=kb,
            )
        return _pt_session

    def _reset_prompt_session():
        """Force recreation of the prompt session (e.g. after config change)."""
        global _pt_session
        _pt_session = None


# =================== SPOTLIGHT (Ctrl+Space) ===================


def _collect_all_items():
    """Collect all tools and directories from CATEGORY_TREE for spotlight search."""
    items = []
    _walk_collect(CATEGORY_TREE, [], items)
    return items


def _walk_collect(node, path, items):
    """Recursively collect all tools and directories."""
    for key, val in node.items():
        if key.startswith("_"):
            continue
        if isinstance(val, dict):
            current_path = path + [key]
            path_str = "/".join(current_path)
            desc = val.get("_desc", "")
            if "_tool" in val:
                items.append({
                    "name": key,
                    "path": path_str,
                    "type": "tool",
                    "desc": desc,
                })
            else:
                items.append({
                    "name": key,
                    "path": path_str,
                    "type": "dir",
                    "desc": desc,
                })
                _walk_collect(val, current_path, items)


_ALL_SPOTLIGHT_ITEMS = None


def _get_spotlight_items():
    """Get cached spotlight items."""
    global _ALL_SPOTLIGHT_ITEMS
    if _ALL_SPOTLIGHT_ITEMS is None:
        _ALL_SPOTLIGHT_ITEMS = _collect_all_items()
    return _ALL_SPOTLIGHT_ITEMS


def _spotlight_filter(query):
    """Filter spotlight items by query. Returns list of matching items."""
    items = _get_spotlight_items()
    if not query:
        return items[:20]
    q = query.lower()
    results = []
    for item in items:
        name = item["name"].lower()
        path = item["path"].lower()
        if q in name or q in path:
            results.append(item)
    return results[:20]


def _spotlight_autocomplete(query, items):
    """Get autocomplete suggestion for current query."""
    if not query or not items:
        return ""
    q = query.lower()
    for item in items:
        name = item["name"]
        if name.lower().startswith(q) and name.lower() != q:
            return name[len(q):]
    return ""


def _show_spotlight(stdscr):
    """Curses-based spotlight search. Returns (path, auto_run) or None.

    auto_run is True when the user pressed Ctrl+Enter (execute command directly).
    """
    import curses

    # Enable modifyOtherKeys mode 2 so Ctrl+Enter sends distinct sequence
    sys.stdout.write("\x1b[>4;2m")
    sys.stdout.flush()

    def _exit(result=None):
        """Disable modifyOtherKeys and return from spotlight."""
        curses.curs_set(0)
        sys.stdout.write("\x1b[>4;0m")
        sys.stdout.flush()
        return result

    curses.curs_set(2)
    _init_colors(stdscr)

    items = _get_spotlight_items()
    if not items:
        return None

    input_text = ""
    cursor_pos = 0
    selected_idx = 0
    scroll_offset = 0
    ac_suffix = ""

    max_results = 10

    def _update():
        nonlocal selected_idx, scroll_offset, ac_suffix
        f = _spotlight_filter(input_text)
        selected_idx = min(selected_idx, max(0, len(f) - 1))
        ac_suffix = _spotlight_autocomplete(input_text, f)
        if selected_idx < scroll_offset:
            scroll_offset = selected_idx
        elif selected_idx >= scroll_offset + max_results:
            scroll_offset = selected_idx - max_results + 1

    def _draw():
        stdscr.clear()
        h, w = stdscr.getmaxyx()

        box_w = min(76, w - 4)
        filtered = _spotlight_filter(input_text)

        result_count = min(len(filtered), max_results)
        box_h = 3 + 1 + 1 + max(result_count, 1) + 1 + 2
        box_x = max(0, (w - box_w) // 2)
        box_y = max(0, (h - box_h) // 2)

        # Top border
        stdscr.addstr(box_y, box_x, "+" + "-" * (box_w - 2) + "+",
                      curses.color_pair(_C_BORDER))

        # Title
        title = " BUSCAR "
        tpad = (box_w - 2 - len(title)) // 2
        row_y = box_y + 1
        stdscr.addstr(row_y, box_x, "|", curses.color_pair(_C_BORDER))
        stdscr.addstr(row_y, box_x + 1, " " * (box_w - 2), curses.color_pair(_C_DIM))
        stdscr.addstr(row_y, box_x + 1 + tpad, title,
                      curses.color_pair(_C_ACCENT) | curses.A_BOLD)
        stdscr.addstr(row_y, box_x + box_w - 1, "|", curses.color_pair(_C_BORDER))

        # Separator
        row_y += 1
        stdscr.addstr(row_y, box_x, "+" + "-" * (box_w - 2) + "+",
                      curses.color_pair(_C_BORDER))

        # Search field row
        row_y += 1
        stdscr.addstr(row_y, box_x, "|", curses.color_pair(_C_BORDER))
        stdscr.addstr(row_y, box_x + 1, " " * (box_w - 2), curses.color_pair(_C_DIM))

        field_w = box_w - 6
        display_typed = input_text[:field_w]
        if ac_suffix and len(display_typed) + len(ac_suffix) <= field_w:
            stdscr.addstr(row_y, box_x + 3, display_typed,
                          curses.color_pair(_C_WHITE) | curses.A_BOLD)
            stdscr.addstr(row_y, box_x + 3 + len(display_typed), ac_suffix,
                          curses.color_pair(_C_BORDER))
        else:
            stdscr.addstr(row_y, box_x + 3, display_typed,
                          curses.color_pair(_C_WHITE) | curses.A_BOLD)

        # Cursor
        cx = box_x + 3 + min(cursor_pos, field_w)
        try:
            stdscr.move(row_y, cx)
        except curses.error:
            pass

        stdscr.addstr(row_y, box_x + box_w - 1, "|", curses.color_pair(_C_BORDER))

        # Separator
        row_y += 1
        stdscr.addstr(row_y, box_x, "+" + "-" * (box_w - 2) + "+",
                      curses.color_pair(_C_BORDER))

        # Results
        row_y += 1
        if not filtered:
            stdscr.addstr(row_y, box_x, "|", curses.color_pair(_C_BORDER))
            stdscr.addstr(row_y, box_x + 1, " " * (box_w - 2), curses.color_pair(_C_DIM))
            stdscr.addstr(row_y, box_x + 3, "Sin resultados",
                          curses.color_pair(_C_DIM))
            stdscr.addstr(row_y, box_x + box_w - 1, "|", curses.color_pair(_C_BORDER))
            row_y += 1
        else:
            visible = filtered[scroll_offset:scroll_offset + max_results]
            for i, item in enumerate(visible):
                real_idx = scroll_offset + i
                is_sel = (real_idx == selected_idx)
                itype = item["type"]

                stdscr.addstr(row_y, box_x, "|",
                              curses.color_pair(_C_ACCENT) | curses.A_BOLD if is_sel
                              else curses.color_pair(_C_BORDER))
                stdscr.addstr(row_y, box_x + 1, " " * (box_w - 2),
                              curses.color_pair(_C_ACCENT) | curses.A_BOLD if is_sel
                              else curses.color_pair(_C_DIM))

                indicator = " >" if itype == "tool" else " /"
                name = item["name"]
                path = item["path"]

                if is_sel:
                    stdscr.addstr(row_y, box_x + 2, indicator,
                                  curses.color_pair(_C_ACCENT) | curses.A_BOLD)
                    stdscr.addstr(row_y, box_x + 5, name,
                                  curses.color_pair(_C_WHITE) | curses.A_BOLD)
                else:
                    stdscr.addstr(row_y, box_x + 2, indicator,
                                  curses.color_pair(_C_DIM))
                    stdscr.addstr(row_y, box_x + 5, name,
                                  curses.color_pair(_C_GREEN if itype == "tool" else _C_GRAY))

                # Path on right side
                path_display = path
                px = box_x + box_w - 2 - len(path_display) - 2
                if px > box_x + 5 + len(name):
                    stdscr.addstr(row_y, px, path_display,
                                  curses.color_pair(_C_CYAN if is_sel else _C_DIM))

                stdscr.addstr(row_y, box_x + box_w - 1, "|",
                              curses.color_pair(_C_ACCENT) | curses.A_BOLD if is_sel
                              else curses.color_pair(_C_BORDER))
                row_y += 1

        # Controls + bottom border
        stdscr.addstr(row_y, box_x, "+" + "-" * (box_w - 2) + "+",
                      curses.color_pair(_C_BORDER))
        row_y += 1
        stdscr.addstr(row_y, box_x, "|", curses.color_pair(_C_BORDER))
        stdscr.addstr(row_y, box_x + 1, " " * (box_w - 2), curses.color_pair(_C_BORDER))
        ctrl = " Tab:completar  Up/Dn:navegar  Enter:seleccionar  Alt+Enter:ejecutar  Esc:cerrar"
        stdscr.addstr(row_y, box_x + 1, ctrl, curses.color_pair(_C_DIM))
        stdscr.addstr(row_y, box_x + box_w - 1, "|", curses.color_pair(_C_BORDER))
        row_y += 1
        stdscr.addstr(row_y, box_x, "+" + "-" * (box_w - 2) + "+",
                      curses.color_pair(_C_BORDER))

        stdscr.refresh()

    _update()
    _draw()

    # Disable keypad so curses doesn't consume escape sequences
    # We'll parse arrow keys and Ctrl+Enter sequences manually
    stdscr.keypad(False)

    # CSI sequence patterns we care about
    _CSI_UP = [91, 65]           # ESC [ A
    _CSI_DOWN = [91, 66]         # ESC [ B
    _CSI_RIGHT = [91, 67]        # ESC [ C
    _CSI_LEFT = [91, 68]         # ESC [ D
    _CSI_HOME = [91, 72]         # ESC [ H
    _CSI_END = [91, 70]          # ESC [ F
    _CSI_DELETE = [91, 51, 126]  # ESC [ 3 ~
    _CSI_CTRL_ENTER_U = [91, 49, 51, 59, 53, 117]            # CSI 13;5u
    _CSI_CTRL_ENTER_T = [91, 50, 55, 59, 53, 59, 49, 51, 126]  # CSI 27;5;13~
    _CSI_CTRL_C_U = [91, 57, 57, 59, 53, 117]               # CSI 99;5u

    while True:
        try:
            key = stdscr.getch()
        except KeyboardInterrupt:
            key = 3

        if key == 27:  # Escape or CSI sequence
            stdscr.nodelay(True)
            seq = []
            try:
                while True:
                    ch = stdscr.getch()
                    if ch == -1:
                        break
                    seq.append(ch)
            except Exception:
                pass
            stdscr.nodelay(False)

            if not seq:
                # Standalone ESC
                return _exit()

            # Alt+Enter: ESC + \r  →  seq = [13]
            # Alt+Enter: ESC + \n  →  seq = [10]
            if seq in ([13], [10]):
                filtered = _spotlight_filter(input_text)
                if filtered and 0 <= selected_idx < len(filtered):
                    item = filtered[selected_idx]
                    return _exit(("/" + item["path"], True))
                return _exit()

            # Alt+Enter CSI format: CSI 13;3u or CSI 27;3;13~
            _CSI_ALT_ENTER_U = [91, 49, 51, 59, 51, 117]
            _CSI_ALT_ENTER_T = [91, 50, 55, 59, 51, 59, 49, 51, 126]
            # Ctrl+Enter CSI format (for terminals that support modifyOtherKeys)
            if seq in (_CSI_CTRL_ENTER_U, _CSI_CTRL_ENTER_T,
                       _CSI_ALT_ENTER_U, _CSI_ALT_ENTER_T):
                filtered = _spotlight_filter(input_text)
                if filtered and 0 <= selected_idx < len(filtered):
                    item = filtered[selected_idx]
                    return _exit(("/" + item["path"], True))
                return _exit()

            # Generic CSI parser for modified Enter keys
            # modifier bits: 1=Shift, 2=Alt, 4=Ctrl
            if len(seq) >= 4 and seq[0] == 91:  # [
                seq_str = "".join(chr(c) for c in seq[1:])
                if seq_str.endswith("u") or seq_str.endswith("~"):
                    params_str = seq_str[:-1]
                    if ";" in params_str:
                        parts = params_str.split(";")
                        try:
                            key_num = int(parts[0])
                            mod = int(parts[1]) if len(parts) > 1 else 0
                            is_alt_or_ctrl = (mod & 6) != 0
                            if is_alt_or_ctrl and key_num in (13, 27):
                                filtered = _spotlight_filter(input_text)
                                if filtered and 0 <= selected_idx < len(filtered):
                                    item = filtered[selected_idx]
                                    return _exit(("/" + item["path"], True))
                                return _exit()
                        except ValueError:
                            pass

            # Ctrl+C in extended format
            if seq == _CSI_CTRL_C_U:
                return _exit()

            # Arrow keys
            if seq == _CSI_UP:
                filtered = _spotlight_filter(input_text)
                if filtered:
                    selected_idx = (selected_idx - 1) % len(filtered)
                    _update()
                    _draw()
                continue
            if seq == _CSI_DOWN:
                filtered = _spotlight_filter(input_text)
                if filtered:
                    selected_idx = (selected_idx + 1) % len(filtered)
                    _update()
                    _draw()
                continue
            if seq == _CSI_LEFT:
                if cursor_pos > 0:
                    cursor_pos -= 1
                    _draw()
                continue
            if seq == _CSI_RIGHT:
                if cursor_pos == len(input_text) and ac_suffix:
                    input_text += ac_suffix
                    cursor_pos = len(input_text)
                    selected_idx = 0
                    scroll_offset = 0
                    _update()
                    _draw()
                elif cursor_pos < len(input_text):
                    cursor_pos += 1
                    _draw()
                continue
            if seq == _CSI_HOME:
                cursor_pos = 0
                _draw()
                continue
            if seq == _CSI_END:
                cursor_pos = len(input_text)
                _draw()
                continue
            if seq == _CSI_DELETE:
                if cursor_pos < len(input_text):
                    input_text = input_text[:cursor_pos] + input_text[cursor_pos + 1:]
                    selected_idx = 0
                    scroll_offset = 0
                    _update()
                    _draw()
                continue

            # Other escape sequence, ignore
            continue

        elif key == 10 or key == 13:  # Enter
            filtered = _spotlight_filter(input_text)
            result = None
            if filtered and 0 <= selected_idx < len(filtered):
                item = filtered[selected_idx]
                result = ("/" + item["path"], False)
            return _exit(result)

        elif key == 9:  # Tab
            if ac_suffix:
                input_text += ac_suffix
                cursor_pos = len(input_text)
                selected_idx = 0
                scroll_offset = 0
                _update()
                _draw()
            else:
                filtered = _spotlight_filter(input_text)
                if filtered:
                    selected_idx = (selected_idx + 1) % len(filtered)
                    _update()
                    _draw()

        elif key == 127 or key == 8:  # Backspace
            if cursor_pos > 0:
                input_text = input_text[:cursor_pos - 1] + input_text[cursor_pos:]
                cursor_pos -= 1
                selected_idx = 0
                scroll_offset = 0
                _update()
                _draw()

        elif key == 3:  # Ctrl+C
            return _exit()

        elif 32 <= key <= 126:
            input_text = input_text[:cursor_pos] + chr(key) + input_text[cursor_pos:]
            cursor_pos += 1
            selected_idx = 0
            scroll_offset = 0
            _update()
            _draw()


def open_spotlight(current_input=""):
    """Open the Spotlight search overlay. Returns (path, auto_run) or None."""
    import curses as _curses
    # Use alternate screen buffer so spotlight doesn't overwrite previous content
    sys.stdout.write("\x1b[?1049h")
    sys.stdout.flush()
    try:
        result = _curses.wrapper(_show_spotlight)
    finally:
        # Restore main screen buffer
        sys.stdout.write("\x1b[?1049l")
        sys.stdout.flush()
    return result


# =================== HISTORY ===================

def _trim_history_file():
    """Keep only the last MAX_HISTORY entries in the history file."""
    if not os.path.exists(HISTORY_FILE):
        return
    try:
        os.makedirs(os.path.dirname(HISTORY_FILE), exist_ok=True)
        with open(HISTORY_FILE, "r") as f:
            lines = f.readlines()
        if len(lines) > MAX_HISTORY:
            with open(HISTORY_FILE, "w") as f:
                f.writelines(lines[-MAX_HISTORY:])
    except (IOError, OSError):
        pass


def _load_history():
    """Load command history."""
    _trim_history_file()
    if HAS_PROMPT_TOOLKIT:
        return
    if HAS_READLINE:
        try:
            readline.read_history_file(HISTORY_FILE)
        except (FileNotFoundError, IOError):
            pass


def _save_history():
    """Save command history on exit."""
    if HAS_PROMPT_TOOLKIT:
        return
    if HAS_READLINE:
        try:
            readline.set_history_length(MAX_HISTORY)
            readline.write_history_file(HISTORY_FILE)
        except (IOError, OSError):
            pass


# =================== TOOL LOADER ===================

def run_tool(tool_import_path, tool_args=""):
    """Dynamically import and run a tool module."""
    module_path = f"modules.{tool_import_path}"
    try:
        mod = importlib.import_module(module_path)
        if hasattr(mod, 'run'):
            try:
                mod.run(tool_args)
            except TypeError:
                mod.run()
        else:
            print(f"{Fore.RED}[!] Tool module '{tool_import_path}' has no run() function.{Style.RESET_ALL}")
    except ImportError as e:
        print(f"{Fore.RED}[!] Failed to load tool: {e}{Style.RESET_ALL}")
    except KeyboardInterrupt:
        print(f"\n{Fore.YELLOW}[*] Tool interrupted.{Style.RESET_ALL}")


# Spotlight state
_spotlight_pending = False
_spotlight_saved_text = ""
def _run_tool_by_name(tool_arg):
    """Find and execute a tool by name or path, with optional args."""
    parts = tool_arg.split()
    tool_name = parts[0]
    extra_args = ' '.join(parts[1:]) if len(parts) > 1 else ""

    # Direct child of current directory
    children = get_children(nav_path)
    if tool_name in children and is_tool_node(children[tool_name]):
        run_tool(children[tool_name]["_tool"], extra_args)
        return

    # Path-based resolution (e.g. /pentesting/red/dos/internetblocker)
    if tool_name.startswith("/"):
        path_str = tool_name.strip("/")
    else:
        path_str = tool_name
    path_parts = [p for p in path_str.split("/") if p]
    node = get_node(path_parts)
    if node is not None and is_tool_node(node):
        run_tool(node["_tool"], extra_args)
        return

    # Category, not tool
    if tool_name in children and not is_tool_node(children[tool_name]):
        print(f"{Fore.RED}[!] '{tool_name}' es una categoría, no una herramienta. Usa {Fore.WHITE}cd {tool_name}{Fore.RED} para navegar.{Style.RESET_ALL}")
        return

    print(f"{Fore.RED}[!] Herramienta '{tool_name}' no encontrada.{Style.RESET_ALL}")
    print(f"{Fore.YELLOW}[*]{Style.RESET_ALL} Usa {Fore.WHITE}ls{Style.RESET_ALL} para ver herramientas en este directorio o escribe la ruta completa.")


def _find_tool_recursive(path_list, tool_name):
    """Recursively search for a tool by name under the given path."""
    children = get_children(path_list)
    for name, child in children.items():
        if name == tool_name and is_tool_node(child):
            return path_list + [name]
        result = _find_tool_recursive(path_list + [name], tool_name)
        if result:
            return result
    return None


# =================== CORE FUNCTIONS ===================

clearL = "clear"
clearW = "cls"


def inicio():
    print(f"{Fore.GREEN}{Style.BRIGHT}[+]{Style.RESET_ALL} Aquí pondré el banner.\n")
    print(f"{Fore.YELLOW}[+] Sistema Operativo:{Fore.BLUE} {sistema}{Style.RESET_ALL}")
    print(f"{Fore.YELLOW}[+] Arquitectura:{Fore.BLUE} {arquitectura}{Style.RESET_ALL}\n")
    if sistema != "Linux":
        print(f"{Fore.RED}[!] Este script está diseñado para linux, puede que algunos módulos no funcionen o algunas funciones no se muestren correctamente!{Style.RESET_ALL}\n")


def show_children(path_list):
    """Display children of the current tree node."""
    children = get_children(path_list)
    if not children:
        print(f"{Fore.YELLOW}[!]{Style.RESET_ALL} No hay herramientas en esta categoría todavía.")
        return

    path_str = "/" + "/".join(path_list) if path_list else "/"
    print(f"\n╭──────────────────────────────────────────╮")
    print(f"│ {path_str:<40} │")
    print(f"╰──────────────────────────────────────────╯")
    print()
    for name in sorted(children.keys()):
        info = children[name]
        desc = info.get("_desc", "")
        if "_tool" in info:
            print(f"  {Fore.GREEN}{name}{Style.RESET_ALL:<20s} {Fore.CYAN}[tool]{Style.RESET_ALL}  - {desc}")
        else:
            print(f"  {Fore.GREEN}{name}{Style.RESET_ALL:<20s}            - {desc}")
    print()


def _verify_path_in_tree(path_str):
    """Verify a path exists in CATEGORY_TREE. Returns True if found."""
    if not path_str:
        return False
    parts = path_str.strip("/").split("/")
    node = CATEGORY_TREE
    for part in parts:
        if not part:
            continue
        if isinstance(node, dict) and part in node:
            node = node[part]
        else:
            return False
    return True


def _verify_tool_in_tree(tool_name):
    """Verify a tool name exists somewhere in CATEGORY_TREE. Returns the full path or None."""
    return _find_tool_recursive([], tool_name)


_SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]


def _wrap_text(text, width=70):
    """Wrap text to a given width, preserving word boundaries."""
    if not text:
        return [""]
    import textwrap
    return textwrap.wrap(text, width=width)


def ai_command(prompt_text):
    """Handle the 'ai' command: send prompt to AI and display suggestion. Returns (action, data) tuple."""
    from config import load_config
    from modules.ai import is_ai_available, chat, COMMENTARY_LABELS
    import threading

    cfg = load_config()
    mode = cfg.get("ai_mode", "off")

    if mode == "off" or not is_ai_available(cfg):
        print(f"\n{Fore.RED}[!] IA no configurada.{Style.RESET_ALL}")
        if mode == "off":
            print(f"{Fore.YELLOW}[*]{Style.RESET_ALL} Activa un modelo desde {Fore.WHITE}config{Style.RESET_ALL} → {Fore.WHITE}Inteligencia artificial{Style.RESET_ALL}")
        elif mode == "cloud":
            print(f"{Fore.YELLOW}[*]{Style.RESET_ALL} Configura tu API key desde {Fore.WHITE}config{Style.RESET_ALL} → {Fore.WHITE}Inteligencia artificial{Style.RESET_ALL}")
        else:
            print(f"{Fore.YELLOW}[*]{Style.RESET_ALL} Instala un modelo desde {Fore.WHITE}config{Style.RESET_ALL} → {Fore.WHITE}Inteligencia artificial{Style.RESET_ALL}")
        return None

    if not prompt_text.strip():
        print(f"\n{Fore.RED}[!] 'ai' necesita un prompt (ej. 'ai como escaneo puertos'){Style.RESET_ALL}")
        return None

    # Spinner animation while waiting
    _spinner_stop = threading.Event()
    _spinner_result = [None]

    def _spin():
        i = 0
        while not _spinner_stop.is_set():
            frame = _SPINNER[i % len(_SPINNER)]
            sys.stdout.write(f"\r  {Fore.CYAN}{frame}{Style.RESET_ALL} Consultando IA...")
            sys.stdout.flush()
            i += 1
            _spinner_stop.wait(0.08)

    spinner_thread = threading.Thread(target=_spin, daemon=True)
    spinner_thread.start()

    # Add current path context
    path_str = "/" + "/".join(nav_path) if nav_path else "/"
    full_prompt = prompt_text
    if path_str != "/":
        full_prompt = f"[Contexto: estas en {path_str}] {prompt_text}"

    result = chat(cfg, CATEGORY_TREE, full_prompt)

    # Stop spinner
    _spinner_stop.set()
    spinner_thread.join(timeout=0.5)
    # Clear spinner line
    sys.stdout.write(f"\r{' ' * 40}\r")
    sys.stdout.flush()

    if result is None:
        print(f"{Fore.RED}[!] No se pudo obtener respuesta de la IA.{Style.RESET_ALL}")
        print(f"{Fore.YELLOW}[*]{Style.RESET_ALL} Verifica tu API key en config")
        return None

    rtype = result.get("type", "none")
    desc = result.get("desc", "")
    name = result.get("name", "")
    path = result.get("path", "")
    command = result.get("command", "")
    reason = result.get("reason", "")
    commentary = cfg.get("ai_commentary", "off")

    if rtype == "tool":
        # Build the command — use name if command is incomplete
        if command and command.startswith("run ") and len(command) > 4:
            run_name = command.replace("run ", "", 1)
        elif name:
            run_name = name
        elif command:
            run_name = command
        else:
            run_name = path.split("/")[-1] if path else ""

        # Verify tool exists
        tool_path = _verify_tool_in_tree(run_name)
        if not tool_path:
            # Try verifying by path
            if path and _verify_path_in_tree(path):
                run_name = path.split("/")[-1]
            else:
                print(f"{Fore.YELLOW}[!]{Style.RESET_ALL} La IA sugirió '{run_name}' pero no se encontró en el framework.")
                return None

        path_display = "/".join(tool_path) if tool_path else path
        if commentary != "off" and reason:
            for line in reason.split("\n"):
                wrapped = _wrap_text(line, width=66)
                for wl in wrapped:
                    print(f"  {Fore.CYAN}{wl}{Style.RESET_ALL}")
        if commentary == "detallados":
            print(f"  {Fore.CYAN}Ruta: {path_display}{Style.RESET_ALL}")
        print()
        print(f"  {Fore.WHITE}run {run_name}{Style.RESET_ALL}")
        return ("tool", run_name)

    elif rtype == "dir":
        # Build the path — use path if command is incomplete
        if command and command.startswith("cd ") and len(command) > 3:
            cd_path = command.replace("cd ", "", 1)
        elif path:
            cd_path = path
        else:
            cd_path = name or command or ""

        # Verify directory exists
        if not _verify_path_in_tree(cd_path):
            print(f"{Fore.YELLOW}[!]{Style.RESET_ALL} La IA sugirió '{cd_path}' pero no se encontró en el framework.")
            return None

        if commentary != "off" and reason:
            for line in reason.split("\n"):
                wrapped = _wrap_text(line, width=66)
                for wl in wrapped:
                    print(f"  {Fore.CYAN}{wl}{Style.RESET_ALL}")
        if commentary == "detallados":
            print(f"  {Fore.CYAN}Ruta: {cd_path}{Style.RESET_ALL}")
        print()
        print(f"  {Fore.WHITE}cd {cd_path}{Style.RESET_ALL}")
        return ("dir", cd_path)

    elif rtype == "none":
        print(f"\r{' ' * 60}\r", end="")
        print(f"{Fore.YELLOW}[!]{Style.RESET_ALL} {desc}")
        return None

    elif rtype == "chat":
        message = result.get("message", "")
        if message:
            # Wrap long messages
            print()
            for line in message.split("\n"):
                wrapped = _wrap_text(line, width=70)
                for wl in wrapped:
                    print(f"  {Fore.CYAN}{wl}{Style.RESET_ALL}")
            print()
        return None

    else:
        print(f"\r{' ' * 60}\r", end="")
        if desc:
            print(f"{Fore.CYAN}[*]{Style.RESET_ALL} {desc}")
        else:
            print(f"{Fore.YELLOW}[!]{Style.RESET_ALL} No se encontro una sugerencia.")
        return None


def instrucciones(arg=""):
    """Show context-aware help. If arg is a module path, show module help. If arg is a tool name, show tool help."""
    # If arg provided, try to resolve it
    if arg:
        # Try to find as a tool first
        tool_path = _find_tool_recursive(nav_path, arg)
        if tool_path:
            node = get_node(tool_path)
            _show_tool_help(arg, node)
            return

        # Try as a module/category path
        new_path, err = _resolve_path(arg)
        if new_path is not None:
            node = get_node(new_path)
            if node is not None:
                _show_module_help(arg, new_path, node)
                return

        # Try resolving from root
        root_path, root_err = _resolve_path("/" + arg)
        if root_path is not None:
            node = get_node(root_path)
            if node is not None and not is_tool_node(node):
                _show_module_help(arg, root_path, node)
                return
            elif root_path is not None and is_tool_node(node):
                _show_tool_help(arg, node)
                return

        print(f"{Fore.RED}[!] No se encontró '{arg}'. Usa {Fore.WHITE}ls{Fore.RED} para ver lo disponible.{Style.RESET_ALL}")
        return

    # No arg — show general help
    _show_general_help()


def _show_general_help():
    """Show general help with available commands."""
    print(f"\n╭────────────────────────────────────╮")
    print(f"│         Comandos {Fore.MAGENTA}Básicos{Style.RESET_ALL}           │")
    print("╰────────────────────────────────────╯")
    print("\nComandos disponibles:")
    print(f"  {Fore.GREEN}ls{Style.RESET_ALL}                - Listar categorías y herramientas")
    print(f"  {Fore.GREEN}cd{Style.RESET_ALL} <path>         - Navegar a una categoría")
    print(f"  {Fore.GREEN}run{Style.RESET_ALL} <tool> [args] - Ejecutar una herramienta")
    print(f"  {Fore.GREEN}ai{Style.RESET_ALL} <prompt>       - Preguntar a la IA")
    print(f"  {Fore.GREEN}Ctrl+Space{Style.RESET_ALL}        - Buscar herramientas y carpetas")
    print(f"  {Fore.GREEN}help{Style.RESET_ALL} [módulo]     - Ayuda general o de un módulo/herramienta")
    print(f"  {Fore.GREEN}clear{Style.RESET_ALL}             - Limpiar la pantalla")
    print(f"  {Fore.GREEN}config{Style.RESET_ALL}            - Abrir la configuración")
    print(f"  {Fore.GREEN}salir{Style.RESET_ALL}/{Fore.GREEN}exit{Style.RESET_ALL}        - Salir del script")
    print(f"  {Fore.GREEN}x{Style.RESET_ALL} <comando>       - Ejecutar un comando del sistema")
    print(f"\nEjemplos: {Fore.CYAN}help wifi{Style.RESET_ALL}, {Fore.CYAN}help deauther{Style.RESET_ALL}, {Fore.CYAN}help red/dos{Style.RESET_ALL}")
    print(f"          {Fore.CYAN}ai como escaneo puertos{Style.RESET_ALL}, {Fore.CYAN}ai herramienta para deauth{Style.RESET_ALL}\n")


def _show_module_help(arg, path_list, node):
    """Show help for a module/category."""
    desc = node.get("_desc", "")
    help_text = node.get("_help", "")
    path_str = "/" + "/".join(path_list)

    print(f"\n╭──────────────────────────────────────────╮")
    print(f"│  {Fore.CYAN}{path_str}{Style.RESET_ALL} — {Fore.WHITE}{desc}{Style.RESET_ALL}")
    print("╰──────────────────────────────────────────╯")

    if help_text:
        print(f"\n{help_text}")

    # Show subcategories and tools
    children = get_children(path_list)
    if children:
        print(f"\n{Fore.YELLOW}Contenido:{Style.RESET_ALL}")
        for name in sorted(children.keys()):
            child = children[name]
            child_desc = child.get("_desc", "")
            if is_tool_node(child):
                print(f"  {Fore.GREEN}{name}{Style.RESET_ALL} — {child_desc}")
            else:
                print(f"  {Fore.CYAN}{name}/{Style.RESET_ALL} — {child_desc}")
    print()


def _show_tool_help(tool_name, node):
    """Show help for a specific tool, including its arguments."""
    tool_import = node.get("_tool", "")
    desc = node.get("_desc", "")

    print(f"\n╭──────────────────────────────────────────╮")
    print(f"│  {Fore.GREEN}{tool_name}{Style.RESET_ALL} — {desc}")
    print("╰──────────────────────────────────────────╯")

    # Try to load the module's HELP_INFO
    if tool_import:
        try:
            mod = importlib.import_module(f"modules.{tool_import}")
            help_info = getattr(mod, "HELP_INFO", None)
            if help_info:
                tool_desc = help_info.get("desc", "")
                args_list = help_info.get("args", [])

                if tool_desc:
                    print(f"\n{tool_desc}")

                if args_list:
                    print(f"\n{Fore.YELLOW}Argumentos:{Style.RESET_ALL}")
                    for flag, explanation in args_list:
                        print(f"  {Fore.WHITE}{flag:<18}{Style.RESET_ALL} {explanation}")
                print()
                return
        except Exception:
            pass

    # Fallback: just show description
    print(f"\n{desc}\n")


# Text preserved after Ctrl+C for next prompt
_ctrl_c_saved_text = ""


def _build_prompt_str():
    """Build the current prompt string (ANSI) and return it."""
    path_str = "/" + "/".join(nav_path) if nav_path else "/"
    current_style = load_prompt_style()
    if current_style == 1:
        return get_kali_prompt(usuario, path_str)
    else:
        return get_prompt(usuario, path_str)


def _prompt_line_count():
    """Calculate how many terminal lines the current prompt takes."""
    prompt_str = _build_prompt_str()
    # Strip ANSI escape codes
    plain = re.sub(r'\033\[[0-9;]*m', '', prompt_str)
    return plain.count('\n') + 1


def prompt():
    """Display the prompt and get user input."""
    global _ctrl_c_saved_text
    prompt_str = _build_prompt_str()
    saved = _ctrl_c_saved_text
    _ctrl_c_saved_text = ""

    if HAS_PROMPT_TOOLKIT:
        session = _get_prompt_session()
        return session.prompt(ANSI(prompt_str), default=saved)
    else:
        return input(prompt_str)


# =================== COMMAND DISPATCHER ===================

def comandos(comando):
    """Process user commands."""
    global nav_path

    stripped = comando.strip()
    if not stripped:
        return

    parts = stripped.split(None, 1)
    cmd = parts[0]
    arg = parts[1] if len(parts) > 1 else ''

    if cmd == "help":
        instrucciones(arg)
    elif cmd == "clear":
        if sistema == "Linux":
            os.system(clearL)
        else:
            os.system(clearW)
    elif cmd == "ai":
        result = ai_command(arg)
        if result:
            action_type, action_data = result
            try:
                if action_type == "tool":
                    confirm = input(f"\n  {Fore.YELLOW}Presiona Enter para ejecutar / Ctrl+C para descartar{Style.RESET_ALL}  ")
                    # Navigate to the tool's parent directory before running
                    tool_path = _find_tool_recursive([], action_data)
                    if tool_path:
                        parent = tool_path[:-1]
                        if parent != nav_path:
                            nav_path = parent
                            path_str = "/" + "/".join(nav_path) if nav_path else "/"
                            print(f"  {Fore.CYAN}→ Navegando a {path_str}{Style.RESET_ALL}")
                    _run_tool_by_name(action_data)
                elif action_type == "dir":
                    confirm = input(f"\n  {Fore.YELLOW}Presiona Enter para navegar / Ctrl+C para descartar{Style.RESET_ALL}  ")
                    new_path, err = _resolve_path(action_data)
                    if err:
                        print(f"{Fore.RED}[!] {err}{Style.RESET_ALL}")
                    else:
                        nav_path = new_path
            except KeyboardInterrupt:
                print(f"\n{Fore.YELLOW}[*] Descartado.{Style.RESET_ALL}")
    elif cmd == "set-style":
        result = prompt_selector()
        if result is not None:
            sel = result["selected"]
            dfl = result["default"]
            print(f"\n{Fore.GREEN}[+] Selecciones guardadas en prompt_selections.txt{Style.RESET_ALL}")
            print(f"{Fore.GREEN}[+] {len(sel)}/10 prompts seleccionados", end="")
            if dfl is not None:
                print(f", default: {Fore.CYAN}{STYLES[dfl]['name']}{Style.RESET_ALL}")
            else:
                print(f"{Style.RESET_ALL}")
            print()
    elif cmd == "set-prompt":
        result = color_selector()
        if result is not None:
            scheme_name = COLOR_SCHEMES[result - 1]["name"]
            print(f"\n{Fore.GREEN}[+] Color scheme cambiado a: {Fore.CYAN}{scheme_name}{Style.RESET_ALL}\n")
    elif cmd == "config":
        result = config_selector()
        if result is not None:
            print(f"\n{Fore.GREEN}[+] Configuración guardada.{Style.RESET_ALL}")
            if HAS_PROMPT_TOOLKIT:
                _reset_prompt_session()
    elif cmd == "salir" or cmd == "exit":
        _save_history()
        sys.exit(0)
    elif cmd == "x":
        if not arg:
            print(f"{Fore.RED}[!] 'x' necesita un comando a ejecutar (ej. 'x whoami'){Style.RESET_ALL}")
        else:
            os.system(arg)
    elif cmd == "ls":
        show_children(nav_path)
    elif cmd == "cd":
        if not arg:
            nav_path = []
        else:
            new_path, err = _resolve_path(arg)
            if err:
                print(f"{Fore.RED}[!] {err}{Style.RESET_ALL}")
            else:
                nav_path = new_path
    elif cmd == "run":
        if not arg:
            print(f"{Fore.RED}[!] 'run' necesita un nombre de herramienta (ej. 'run internetblocker'){Style.RESET_ALL}")
        else:
            _run_tool_by_name(arg)
    else:
        print(f"{Style.BRIGHT}{Fore.RED}[!]{Style.RESET_ALL}{Fore.RED} '{cmd}' no es un comando válido, escribe {Fore.WHITE}help{Fore.RED} para listar los comandos disponibles.{Style.RESET_ALL}\n")


# =================== MAIN LOOP ===================

try:
    if not check_eula():
        print(f"\n{Fore.RED}[!] Debes aceptar el disclaimer para continuar.{Style.RESET_ALL}")
        sys.exit(0)

    _load_history()
    inicio()

    while is_running:
        try:
            user_input = prompt()

            # Check if spotlight was requested (Ctrl+Space exits the prompt)
            if _spotlight_pending:
                _spotlight_pending = False
                saved = _spotlight_saved_text
                _ctrl_c_saved_text = ""  # Don't double-save
                result = open_spotlight(saved)
                if result:
                    path, auto_run = result if isinstance(result, tuple) else (result, False)
                    if auto_run:
                        # Determine command type from the selected item
                        _all = _get_spotlight_items()
                        item_type = None
                        for it in _all:
                            if "/" + it["path"] == path:
                                item_type = it["type"]
                                break
                        if item_type == "tool":
                            parent = path.rsplit("/", 1)[0] if "/" in path else ""
                            tool_name = path.rsplit("/", 1)[-1]
                            if parent:
                                cd_cmd = f"cd /{parent}"
                                print(_build_prompt_str() + f"{Fore.BLUE}{Style.BRIGHT}cd{Style.RESET_ALL} /{parent}")
                                comandos(cd_cmd)
                            run_cmd = f"run {tool_name}"
                            print(_build_prompt_str() + f"{Fore.BLUE}{Style.BRIGHT}run{Style.RESET_ALL} {tool_name}")
                            comandos(run_cmd)
                        elif item_type == "dir":
                            cd_cmd = f"cd {path}"
                            print(_build_prompt_str() + f"{Fore.BLUE}{Style.BRIGHT}cd{Style.RESET_ALL} {path}")
                            comandos(cd_cmd)
                    else:
                        # Add space between saved text and result if needed
                        sep = " " if saved and not saved.endswith(" ") else ""
                        _ctrl_c_saved_text = saved + sep + path
                continue

            comandos(user_input)
        except KeyboardInterrupt:
            # Save any text the user had typed before Ctrl+C
            _saved = ""
            if HAS_PROMPT_TOOLKIT and _pt_session is not None:
                try:
                    _saved = _pt_session.default_buffer.text
                except Exception:
                    pass
            _ctrl_c_saved_text = _saved

            # Double Ctrl+C with drain animation (0.4s total)
            _DRAIN = ["●", "◕", "◓", "◔", "○"]
            _O = "\033[38;5;208m"  # orange
            _CLR = " " * 50

            sys.stdout.write(f"\r{_O}{_DRAIN[0]} Presiona Ctrl+C otra vez para salir{Style.RESET_ALL}{_CLR}\r")
            sys.stdout.write(f"\r{_O}{_DRAIN[0]} Presiona Ctrl+C otra vez para salir{Style.RESET_ALL}")
            sys.stdout.flush()

            try:
                for i in range(1, len(_DRAIN)):
                    time.sleep(0.08)
                    msg = f"{_DRAIN[i]} Presiona Ctrl+C otra vez para salir" if _DRAIN[i] != "○" else _DRAIN[i]
                    sys.stdout.write(f"\r{_O}{msg}{Style.RESET_ALL}{_CLR}\r")
                    sys.stdout.write(f"\r{_O}{msg}{Style.RESET_ALL}")
                    sys.stdout.flush()
                time.sleep(0.08)
            except KeyboardInterrupt:
                # Second Ctrl+C — red exit message
                _save_history()
                sys.stdout.write(f"\r{Fore.RED}[!] Saliendo...{Style.RESET_ALL}{_CLR}\n")
                sys.stdout.flush()
                sys.exit(0)

            # Drain complete — clear drain line
            sys.stdout.write(f"\r{_CLR}\r")
            sys.stdout.flush()

            # Delete the empty drain line to close the gap
            sys.stdout.write("\033[M")
            sys.stdout.flush()

            # Move up and clear each prompt line
            # (prompt_toolkit adds a newline after Ctrl+C, so we're
            # currently below the prompt. Move up to erase all prompt lines.)
            prompt_lines = _prompt_line_count()
            for _ in range(prompt_lines):
                sys.stdout.write("\033[A\033[2K")
            sys.stdout.flush()
            continue
        except EOFError:
            _save_history()
            print(f"\n{Fore.RED}[!] Saliendo...{Style.RESET_ALL}")
            sys.exit(0)

except KeyboardInterrupt:
    print(f"\n{Fore.RED}[!] hasta la vista, baby{Style.RESET_ALL}")