npcsh 1.1.21__py3-none-any.whl → 1.1.23__py3-none-any.whl

npcsh/_state.py

@@ -190,6 +190,8 @@ class ShellState:
     edit_approval: str = NPCSH_EDIT_APPROVAL
     # Pending file edits for approval
     pending_edits: Dict[str, Dict[str, str]] = field(default_factory=dict)
+    # Command history for jinx execution logging
+    command_history: Optional[Any] = None
 
     def get_model_for_command(self, model_type: str = "chat"):
         if model_type == "chat":
@@ -278,6 +280,9 @@ CONFIG_KEY_MAP = {
     "buildkg": "NPCSH_BUILD_KG",
     "editapproval": "NPCSH_EDIT_APPROVAL",
     "approval": "NPCSH_EDIT_APPROVAL",
+    "ttsengine": "NPCSH_TTS_ENGINE",
+    "ttsvoice": "NPCSH_TTS_VOICE",
+    "yapsetup": "NPCSH_YAP_SETUP_DONE",
 }
 
 
@@ -1671,10 +1676,19 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
     try:
         import shutil
         term_width = shutil.get_terminal_size().columns
-    except json.JSONDecodeError:
+    except Exception:
         term_width = 80
 
+    # Track how many hint lines were drawn last time (for clearing on redraw)
+    _prev_hint_lines = 1
+
+    # Tab completion state
+    _tab_matches = []
+    _tab_index = -1
+    _tab_prefix = ""
+
     def draw():
+        nonlocal _prev_hint_lines
         # Calculate how many lines the input takes
         total_len = prompt_visible_len + len(buf)
         num_lines = (total_len // term_width) + 1
@@ -1688,18 +1702,21 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
         for _ in range(num_lines - 1):
             sys.stdout.write('\033[A')
 
-        # Clear from cursor to end of screen (clears all wrapped lines + hint)
+        # Clear from cursor to end of screen (clears all wrapped lines + all hint lines below)
         sys.stdout.write('\033[J')
 
         # Print prompt and buffer
         sys.stdout.write(prompt + buf)
 
-        # Print hint on next line
-        sys.stdout.write('\n\033[K' + current_hint())
+        # Print hint on next line(s) - hint may contain newlines
+        hint = current_hint()
+        hint_line_count = hint.count('\n') + 1 if hint else 1
+        _prev_hint_lines = hint_line_count
+        sys.stdout.write('\n' + hint)
 
         # Now position cursor back to correct spot
         # Go back up to the line where cursor should be
-        lines_after_cursor = (total_len // term_width) - (cursor_total // term_width) + 1  # +1 for hint line
+        lines_after_cursor = (total_len // term_width) - (cursor_total // term_width) + hint_line_count
         for _ in range(lines_after_cursor):
             sys.stdout.write('\033[A')
 
@@ -1924,6 +1941,9 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
                 if pos > 0:
                     buf = buf[:pos-1] + buf[pos:]
                     pos -= 1
+                    _tab_matches = []
+                    _tab_index = -1
+                    _tab_prefix = ""
                     draw()
 
             elif c == '\x03':  # Ctrl-C
@@ -1941,10 +1961,26 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
                     buf = ""
                     pos = 0
                     pasted_content = None
-                    sys.stdout.write('\r\033[K')  # Clear current line
+                    _tab_matches = []
+                    _tab_index = -1
+                    _tab_prefix = ""
+                    # Clear all previous hint lines + current input
+                    sys.stdout.write('\r')
+                    for _ in range(_prev_hint_lines):
+                        sys.stdout.write('\033[B')
+                    sys.stdout.write('\033[J')  # Clear from cursor to end
+                    for _ in range(_prev_hint_lines):
+                        sys.stdout.write('\033[A')
+                    sys.stdout.write('\r\033[K')
                     sys.stdout.write('^C\n')
-                    # Redraw prompt
-                    sys.stdout.write(prompt + '\n' + current_hint() + '\033[A\r')
+                    # Redraw prompt with fresh hint
+                    hint = current_hint()
+                    _prev_hint_lines = hint.count('\n') + 1 if hint else 1
+                    sys.stdout.write(prompt + '\n' + hint)
+                    # Go back up past all hint lines
+                    for _ in range(_prev_hint_lines):
+                        sys.stdout.write('\033[A')
+                    sys.stdout.write('\r')
                     if prompt_visible_len > 0:
                         sys.stdout.write('\033[' + str(prompt_visible_len) + 'C')
                     sys.stdout.flush()
@@ -1981,8 +2017,55 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
                     pos -= 1
                 draw()
 
-            elif c == '\t':  # Tab - do nothing for now
-                pass
+            elif c == '\t':  # Tab - inline completion
+                try:
+                    if _tab_matches and _tab_prefix == buf:
+                        # Subsequent Tab: cycle through matches
+                        _tab_index = (_tab_index + 1) % len(_tab_matches)
+                        buf = _tab_matches[_tab_index]
+                        pos = len(buf)
+                        draw()
+                    else:
+                        # First Tab: compute matches
+                        matches = []
+                        if buf.startswith('/'):
+                            cmds = _get_slash_commands_set(state, router, buf)
+                            matches = ['/' + c for c in sorted(cmds)]
+                        elif buf.startswith('@'):
+                            npcs = _get_npc_names_set(state, buf)
+                            matches = ['@' + n for n in sorted(npcs)]
+                        else:
+                            # File path completion for non-prefix input
+                            import glob as _glob
+                            pattern = buf + '*'
+                            matches = sorted(_glob.glob(pattern))
+
+                        if len(matches) == 1:
+                            # Exact single match - autocomplete with trailing space
+                            buf = matches[0] + ' '
+                            pos = len(buf)
+                            _tab_matches = []
+                            _tab_index = -1
+                            _tab_prefix = ""
+                            draw()
+                        elif len(matches) > 1:
+                            # Find longest common prefix
+                            common = matches[0]
+                            for m in matches[1:]:
+                                while not m.startswith(common):
+                                    common = common[:-1]
+                            if len(common) > len(buf):
+                                # Complete common prefix
+                                buf = common
+                                pos = len(buf)
+                            # Set up cycling state
+                            _tab_matches = matches
+                            _tab_index = -1
+                            _tab_prefix = buf
+                            draw()
+                except Exception:
+                    pass
+                continue
 
             elif c == '\x0f':  # Ctrl-O - show last tool call args
                 try:
@@ -2022,6 +2105,9 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
             elif c and ord(c) >= 32:  # Printable
                 buf = buf[:pos] + c + buf[pos:]
                 pos += 1
+                _tab_matches = []
+                _tab_index = -1
+                _tab_prefix = ""
                 draw()
 
     finally:
@@ -2030,42 +2116,66 @@ def _input_with_hint_below(prompt: str, state=None, router=None, token_hint: str
         termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
 
 
-def _get_slash_hints(state, router, prefix='/') -> str:
-    """Slash command hints - fits terminal width."""
-    cmds = {'help', 'set', 'agent', 'chat', 'cmd', 'sq', 'quit', 'exit', 'clear', 'npc'}
+def _get_slash_commands_set(state, router, prefix='/') -> set:
+    """Return the set of matching slash command names (without /)."""
+    # Computer-use commands hidden from hints/tab-complete (still callable)
+    _HIDDEN_CMDS = {
+        'browser_action', 'browser_screenshot', 'click', 'close_browser',
+        'key_press', 'launch_app', 'open_browser', 'screenshot',
+        'trigger', 'type_text', 'wait',
+    }
+    cmds = {'help', 'set', 'agent', 'chat', 'cmd', 'sq', 'quit', 'exit', 'clear', 'npc', 'reattach'}
     if state and state.team and hasattr(state.team, 'jinxs_dict'):
         cmds.update(state.team.jinxs_dict.keys())
     if router and hasattr(router, 'jinx_routes'):
         cmds.update(router.jinx_routes.keys())
+    cmds -= _HIDDEN_CMDS
     if len(prefix) > 1:
         f = prefix[1:].lower()
         cmds = {c for c in cmds if c.lower().startswith(f)}
+    return cmds
+
+
+def _layout_hints_multirow(items, term_width, style_fn) -> str:
+    """Lay out hint items across multiple rows that fit terminal width."""
+    if not items:
+        return ""
+    rows = []
+    current_row = []
+    current_len = 2  # leading spaces
+    for item in items:
+        needed = len(item) + 2  # item + spacing
+        if current_len + needed > term_width - 2 and current_row:
+            rows.append(current_row)
+            current_row = [item]
+            current_len = 2 + len(item) + 2
+        else:
+            current_row.append(item)
+            current_len += needed
+    if current_row:
+        rows.append(current_row)
+    return '\n'.join(style_fn('  ' + '  '.join(row)) for row in rows)
+
+
+def _get_slash_hints(state, router, prefix='/') -> str:
+    """Slash command hints - shows ALL commands across multiple rows."""
+    cmds = _get_slash_commands_set(state, router, prefix)
     if cmds:
-        # Get terminal width, default 80
         try:
             import shutil
             term_width = shutil.get_terminal_size().columns
         except Exception:
             term_width = 80
-
-        # Build hint string that fits in terminal
-        sorted_cmds = sorted(cmds)
-        hint_parts = []
-        current_len = 2  # leading spaces
-        for c in sorted_cmds:
-            item = '/' + c
-            if current_len + len(item) + 2 > term_width - 5:  # leave margin
-                break
-            hint_parts.append(item)
-            current_len += len(item) + 2
-
-        if hint_parts:
-            return colored('  ' + '  '.join(hint_parts), 'white', attrs=['dark'])
+        sorted_items = ['/' + c for c in sorted(cmds)]
+        return _layout_hints_multirow(
+            sorted_items, term_width,
+            lambda s: colored(s, 'white', attrs=['dark'])
+        )
     return ""
 
 
-def _get_npc_hints(state, prefix='@') -> str:
-    """NPC hints."""
+def _get_npc_names_set(state, prefix='@') -> set:
+    """Return the set of matching NPC names (without @)."""
     npcs = set()
     if state and state.team:
         if hasattr(state.team, 'npcs') and state.team.npcs:
@@ -2077,8 +2187,23 @@ def _get_npc_hints(state, prefix='@') -> str:
     if len(prefix) > 1:
         f = prefix[1:].lower()
         npcs = {n for n in npcs if n.lower().startswith(f)}
+    return npcs
+
+
+def _get_npc_hints(state, prefix='@') -> str:
+    """NPC hints - shows all NPCs across multiple rows."""
+    npcs = _get_npc_names_set(state, prefix)
     if npcs:
-        return colored('  ' + '  '.join('@' + n for n in sorted(npcs)), 'cyan')
+        try:
+            import shutil
+            term_width = shutil.get_terminal_size().columns
+        except Exception:
+            term_width = 80
+        sorted_items = ['@' + n for n in sorted(npcs)]
+        return _layout_hints_multirow(
+            sorted_items, term_width,
+            lambda s: colored(s, 'cyan')
+        )
     return ""
 
 
@@ -2374,55 +2499,28 @@ def parse_generic_command_flags(parts: List[str]) -> Tuple[Dict[str, Any], List[
         
     return parsed_kwargs, positional_args
 
-def _ollama_supports_tools(model: str) -> Optional[bool]:
-    """
-    Best-effort check for tool-call support on an Ollama model by inspecting its template/metadata.
-    Mirrors the lightweight check used in the Flask serve path.
-    """
-
-
-    try:
-        details = ollama.show(model)
-        template = details.get("template") or ""
-        metadata = details.get("metadata") or {}
-        if any(token in template for token in ["{{- if .Tools", "{{- range .Tools", "{{- if .ToolCalls"]):
-            return True
-        if metadata.get("tools") or metadata.get("tool_calls"):
-            return True
-        return False
-    except Exception:
-        return None
-
-
 def model_supports_tool_calls(model: Optional[str], provider: Optional[str]) -> bool:
-    """
-    Decide whether to attempt tool-calling for the given model/provider.
-    Uses Ollama template inspection when possible and falls back to name heuristics.
-    """
+    """Check whether a model supports tool/function calling."""
     if not model:
         return False
 
     provider = (provider or "").lower()
-    model_lower = model.lower()
 
+    # Ollama: use the capabilities field from the model metadata
     if provider == "ollama":
-        ollama_support = _ollama_supports_tools(model)
-        if ollama_support is not None:
-            return ollama_support
-
-    toolish_markers = [
-        "gpt",
-        "claude",
-        "qwen",
-        "mistral",
-        "llama-3.1",
-        "llama3.1",
-        "llama-3.2",
-        "llama3.2",
-        "gemini",
-        "tool",
-    ]
-    return any(marker in model_lower for marker in toolish_markers)
+        try:
+            details = ollama.show(model)
+            caps = getattr(details, "capabilities", None) or []
+            return "tools" in caps
+        except Exception:
+            pass
+
+    # API providers: always support tools
+    if provider in ("anthropic", "openai", "gemini", "google", "deepseek", "groq", "openrouter"):
+        return True
+
+    # Unknown provider: assume yes
+    return True
 
 
 def wrap_tool_with_display(tool_name: str, tool_func: Callable, state: ShellState) -> Callable:
@@ -2537,19 +2635,16 @@ def collect_llm_tools(state: ShellState) -> Tuple[List[Dict[str, Any]], Dict[str
     elif npc_obj and getattr(npc_obj, "tool_map", None):
         tool_map.update(npc_obj.tool_map)
 
-    # Jinx tools from NPC and Team
+    # Jinx tools from NPC only (NPC.jinxs_dict is already filtered by jinxs_spec
+    # during initialize_jinxs - don't add the full team catalog which overwhelms small models)
     aggregated_jinxs: Dict[str, Any] = {}
     if npc_obj and getattr(npc_obj, "jinxs_dict", None):
         aggregated_jinxs.update(npc_obj.jinxs_dict)
-    if state.team and isinstance(state.team, Team) and getattr(state.team, "jinxs_dict", None):
-        aggregated_jinxs.update({k: v for k, v in state.team.jinxs_dict.items() if k not in aggregated_jinxs})
 
     if aggregated_jinxs:
         jinx_catalog: Dict[str, Dict[str, Any]] = {}
         if npc_obj and getattr(npc_obj, "jinx_tool_catalog", None):
             jinx_catalog.update(npc_obj.jinx_tool_catalog or {})
-        if state.team and isinstance(state.team, Team) and getattr(state.team, "jinx_tool_catalog", None):
-            jinx_catalog.update(state.team.jinx_tool_catalog or {})
         if not jinx_catalog:
             jinx_catalog = build_jinx_tool_catalog(aggregated_jinxs)
 
@@ -2701,15 +2796,45 @@ def execute_slash_command(command: str,
             'vmodel': state.vision_model, 'vprovider': state.vision_provider, 'rmodel': state.reasoning_model, 
             'rprovider': state.reasoning_provider, 'state': state
         }
+        import time as _time
+        _start = _time.monotonic()
+        _status = "success"
+        _error = None
         try:
             result = handler(command=command, **handler_kwargs)
-            if isinstance(result, dict): 
+            if isinstance(result, dict):
                 state.messages = result.get("messages", state.messages)
-            return state, result
         except Exception as e:
             import traceback
             traceback.print_exc()
-            return state, {"output": colored(f"Error executing slash command '{command_name}': {e}", "red"), "messages": state.messages}
+            _status = "error"
+            _error = str(e)
+            result = {"output": colored(f"Error executing slash command '{command_name}': {e}", "red"), "messages": state.messages}
+
+        _duration_ms = int((_time.monotonic() - _start) * 1000)
+
+        # Log jinx execution to jinx_execution_log
+        if hasattr(state, 'command_history') and state.command_history is not None and hasattr(state.command_history, 'save_jinx_execution'):
+            try:
+                _npc_name = state.npc.name if isinstance(state.npc, NPC) else "npcsh"
+                _team_name = state.team.name if state.team else "npcsh"
+                _args = ' '.join(all_command_parts[1:]) if len(all_command_parts) > 1 else ''
+                state.command_history.save_jinx_execution(
+                    triggering_message_id=None,
+                    conversation_id=state.conversation_id,
+                    npc_name=_npc_name,
+                    jinx_name=command_name,
+                    jinx_inputs={"command": command, "args": _args},
+                    jinx_output=result.get('output', '') if isinstance(result, dict) else str(result)[:2000],
+                    status=_status,
+                    team_name=_team_name,
+                    error_message=_error,
+                    duration_ms=_duration_ms,
+                )
+            except Exception:
+                pass  # Don't fail command execution due to logging error
+
+        return state, result
     
     # Fallback for switching NPC by name
     if state.team and command_name in state.team.npcs:
@@ -2758,46 +2883,13 @@ def process_pipeline_command(
     exec_provider = provider_override or npc_provider or state.chat_provider
 
     if cmd_to_process.startswith("/"):
-        command_name = cmd_to_process.split()[0].lstrip('/')
-        
-        # Check if this is an interactive mode
-        is_interactive_mode = False
-
-        # Check if the jinx declares interactive: true
-        if router.is_interactive(command_name):
-            is_interactive_mode = True
-
-        # Also check modes/ directory (legacy)
-        if not is_interactive_mode:
-            global_modes_jinx = os.path.expanduser(f'~/.npcsh/npc_team/jinxs/modes/{command_name}.jinx')
-            if os.path.exists(global_modes_jinx):
-                is_interactive_mode = True
-
-        if not is_interactive_mode and state.team and state.team.team_path:
-            team_modes_jinx = os.path.join(state.team.team_path, 'jinxs', 'modes', f'{command_name}.jinx')
-            if os.path.exists(team_modes_jinx):
-                is_interactive_mode = True
-        
-        if is_interactive_mode:
-            result = execute_slash_command(
-                cmd_to_process, 
-                stdin_input, 
-                state, 
-                stream_final, 
-                router
-            )
-        else:
-            with SpinnerContext(
-                f"Routing to {cmd_to_process.split()[0]}", 
-                style="arrow"
-            ):
-                result = execute_slash_command(
-                    cmd_to_process, 
-                    stdin_input, 
-                    state, 
-                    stream_final, 
-                    router
-                )
+        result = execute_slash_command(
+            cmd_to_process,
+            stdin_input,
+            state,
+            stream_final,
+            router
+        )
         return result
     cmd_parts = parse_command_safely(cmd_to_process)
     if not cmd_parts:
@@ -2898,6 +2990,14 @@ def process_pipeline_command(
             tools_for_llm, tool_exec_map = collect_llm_tools(state)
             if not tools_for_llm:
                 tool_capable = False
+            else:
+                # Add tool guidance so model knows to use function calls
+                tool_names = [t['function']['name'] for t in tools_for_llm if 'function' in t]
+                info += (
+                    f"\nYou have access to these tools: {', '.join(tool_names)}. "
+                    f"You MUST use the function calling interface to invoke them. "
+                    f"Do NOT write tool names as text - call them as functions."
+                )
 
         npc_name = (
             state.npc.name 
@@ -2949,10 +3049,22 @@ def process_pipeline_command(
                     iteration = 0
                     max_iterations = 50  # Safety limit to prevent infinite loops
                     total_usage = {"input_tokens": 0, "output_tokens": 0}
+                    state._agent_nudges = 0  # Track continuation nudges
+
+                    tool_calls_count = 0  # Track how many tool calls have been made
 
                     while iteration < max_iterations:
                         iteration += 1
 
+                        # After a tool has been called, force the model to generate a
+                        # text response on the NEXT iteration by setting tool_choice='none'.
+                        # This prevents models from endlessly repeating tool calls when
+                        # they already have the answer. For multi-step tasks, delegate
+                        # and convene jinxs have their own internal loops.
+                        iter_kwargs = dict(llm_kwargs)
+                        if tool_calls_count > 0:
+                            iter_kwargs["tool_choice"] = 'none'
+
                         llm_result = get_llm_response(
                             full_llm_cmd if iteration == 1 else None,  # Only pass prompt on first call
                             model=exec_model,
@@ -2963,7 +3075,7 @@ def process_pipeline_command(
                             stream=False,  # Don't stream intermediate calls
                             attachments=state.attachments if iteration == 1 else None,
                             context=info if iteration == 1 else None,
-                            **llm_kwargs,
+                            **iter_kwargs,
                         )
 
                         # Accumulate usage
@@ -2994,12 +3106,34 @@ def process_pipeline_command(
                                     else:
                                         render_markdown(tool_content)
 
-                        # Check if LLM made tool calls - if not, it's done
+                        # Check if LLM made tool calls - if not, consider re-prompting
                         tool_calls_made = isinstance(llm_result, dict) and llm_result.get("tool_calls")
                         if not tool_calls_made:
+                            # In agent mode, nudge to use tools — but ONLY if no tools
+                            # have been called yet (model hasn't started working).
+                            # Once tools have been called and returned results,
+                            # the model should synthesize an answer, not call more tools.
+                            if (state.current_mode == 'agent'
+                                    and tool_calls_count == 0
+                                    and iteration < max_iterations
+                                    and state._agent_nudges < 3):
+                                state._agent_nudges += 1
+                                state.messages.append({
+                                    "role": "user",
+                                    "content": (
+                                        "You have not yet completed the task. "
+                                        "Continue working by calling tools. "
+                                        "Use the function calling interface to invoke tools - "
+                                        "do NOT write tool calls as text."
+                                    )
+                                })
+                                continue
                             # LLM is done - no more tool calls
                             break
 
+                        # Track tool calls and reset nudge counter
+                        tool_calls_count += 1
+                        state._agent_nudges = 0
                         # Clear the prompt for continuation calls - context is in messages
                         full_llm_cmd = None
 
@@ -3488,8 +3622,31 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
 
     forenpc_path = os.path.join(team_dir, f"{forenpc_name}.npc")
 
-    team = Team(team_path=team_dir, db_conn=command_history.engine)
-    
+    try:
+        team = Team(team_path=team_dir, db_conn=command_history.engine)
+    except FileNotFoundError as e:
+        print(f"Warning: Team compilation failed - {e}")
+        print("Auto-refreshing npc_team files from package...")
+
+        global_team_path = os.path.expanduser(DEFAULT_NPC_TEAM_PATH)
+        if team_dir == global_team_path:
+            user_jinxs_dir = os.path.join(global_team_path, "jinxs")
+            if os.path.exists(user_jinxs_dir):
+                print(f"Removing stale jinxs directory: {user_jinxs_dir}")
+                shutil.rmtree(user_jinxs_dir)
+            initialize_base_npcs_if_needed(db_path)
+            print("npc_team files refreshed. Retrying team initialization...")
+            try:
+                team = Team(team_path=team_dir, db_conn=command_history.engine)
+            except FileNotFoundError as retry_e:
+                print(f"Error: Team initialization still failed after refresh: {retry_e}")
+                print("This may indicate corrupted NPC files. Try: rm -rf ~/.npcsh/npc_team && npcsh")
+                raise
+        else:
+            print(f"Error: Project team at '{team_dir}' has compilation errors.")
+            print("Please check your .npc files and jinx references.")
+            raise
+
     forenpc_obj = team.forenpc if hasattr(team, 'forenpc') and team.forenpc else None
 
     for npc_name, npc_obj in team.npcs.items():