npcsh 1.0.28__tar.gz → 1.0.29__tar.gz

{npcsh-1.0.28 → npcsh-1.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.28
+Version: 1.0.29
 Summary: npcsh is a command-line toolkit for using AI agents in novel ways.
 Home-page: https://github.com/NPC-Worldwide/npcsh
 Author: Christopher Agostino

{npcsh-1.0.28 → npcsh-1.0.29}/npcsh/_state.py

@@ -436,6 +436,12 @@ def get_shell_config_file() -> str:
         return os.path.expanduser("~/.bashrc")
 
 
+def get_team_ctx_path(team_path: str) -> Optional[str]:
+    """Find the first .ctx file in the team directory"""
+    team_dir = Path(team_path)
+    ctx_files = list(team_dir.glob("*.ctx"))
+    return str(ctx_files[0]) if ctx_files else None
+
 
 def add_npcshrc_to_shell_config() -> None:
     """
@@ -2384,17 +2390,16 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
         
 
     team_ctx = {}
-    for filename in os.listdir(team_dir):
-        if filename.endswith(".ctx"):
-            try:
-                with open(os.path.join(team_dir, filename), "r") as f:
-                    team_ctx = yaml.safe_load(f) or {}
-                break
-            except Exception as e:
-                print(f"Warning: Could not load context file {filename}: {e}")
-
+    team_ctx_path = get_team_ctx_path(team_dir)
+    if team_ctx_path:
+        try:
+            with open(team_ctx_path, "r") as f:
+                team_ctx = yaml.safe_load(f) or {}
+        except Exception as e:
+            print(f"Warning: Could not load context file {os.path.basename(team_ctx_path)}: {e}")
     forenpc_name = team_ctx.get("forenpc", default_forenpc_name)
   
+    print('forenpc_name:', forenpc_name)
 
     if team_ctx.get("use_global_jinxs", False):
         jinxs_dir = os.path.expanduser("~/.npcsh/npc_team/jinxs")
@@ -2407,11 +2412,8 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     forenpc_obj = None
     forenpc_path = os.path.join(team_dir, f"{forenpc_name}.npc")
 
+    print('forenpc_path:', forenpc_path)
 
-  
-
-
-    
     if os.path.exists(forenpc_path):
         forenpc_obj = NPC(file = forenpc_path, 
                           jinxs=jinxs_list, 
@@ -2558,7 +2560,8 @@ def process_result(
                 characterization = summary.get('output')
 
                 if characterization and result_state.team:
-                    team_ctx_path = os.path.join(result_state.team.team_path, "team.ctx")
+
+                    team_ctx_path = os.path.join(result_state.team.team_path, ".ctx")
                     ctx_data = {}
                     if os.path.exists(team_ctx_path):
                         with open(team_ctx_path, 'r') as f:

{npcsh-1.0.28 → npcsh-1.0.29}/npcsh/corca.py

@@ -33,6 +33,7 @@ from npcsh._state import (
     should_skip_kg_processing, 
     NPCSH_CHAT_PROVIDER, 
     NPCSH_CHAT_MODEL,
+    get_team_ctx_path
 )
 import yaml 
 from pathlib import Path
@@ -179,23 +180,21 @@ def process_mcp_stream(stream_response, active_npc):
     tool_calls = []
     
     interrupted = False
-    
     sys.stdout.write('\033[s')
     sys.stdout.flush()
+    
     try:
         for chunk in stream_response:        
             if hasattr(active_npc, 'provider') and active_npc.provider == "ollama" and 'gpt-oss' not in active_npc.model:
                 if hasattr(chunk, 'message') and hasattr(chunk.message, 'tool_calls') and chunk.message.tool_calls:
                     for tool_call in chunk.message.tool_calls:
-                        tool_call_data = {
-                            'id': getattr(tool_call, 'id', ''),
+                        tool_call_data = {'id': getattr(tool_call, 'id', ''),
                             'type': 'function',
                             'function': {
                                 'name': getattr(tool_call.function, 'name', '') if hasattr(tool_call, 'function') else '',
                                 'arguments': getattr(tool_call.function, 'arguments', {}) if hasattr(tool_call, 'function') else {}
                             }
                         }
-                        
                         if isinstance(tool_call_data['function']['arguments'], str):
                             try:
                                 tool_call_data['function']['arguments'] = json.loads(tool_call_data['function']['arguments'])
@@ -203,7 +202,6 @@ def process_mcp_stream(stream_response, active_npc):
                                 tool_call_data['function']['arguments'] = {'raw': tool_call_data['function']['arguments']}
                         
                         tool_calls.append(tool_call_data)
-                
                 if hasattr(chunk, 'message') and hasattr(chunk.message, 'content') and chunk.message.content:
                     collected_content += chunk.message.content
                     print(chunk.message.content, end='', flush=True)
@@ -230,7 +228,6 @@ def process_mcp_stream(stream_response, active_npc):
                                 
                                 if hasattr(tool_call_delta, 'id') and tool_call_delta.id:
                                     tool_calls[idx]['id'] = tool_call_delta.id
-                                
                                 if hasattr(tool_call_delta, 'function'):
                                     if hasattr(tool_call_delta.function, 'name') and tool_call_delta.function.name:
                                         tool_calls[idx]['function']['name'] = tool_call_delta.function.name
@@ -239,66 +236,63 @@ def process_mcp_stream(stream_response, active_npc):
                                         tool_calls[idx]['function']['arguments'] += tool_call_delta.function.arguments
     except KeyboardInterrupt:
         interrupted = True
-        print('\n⚠️ Stream interrupted by user')
+        print('⚠️ Stream interrupted by user')
     
     sys.stdout.write('\033[u')
     sys.stdout.write('\033[J')
     sys.stdout.flush()
     
+    # Use the render_markdown function for proper markdown rendering
     render_markdown(collected_content)
-    print('\n')
     return collected_content, tool_calls
-
 def execute_command_corca(command: str, state: ShellState, command_history, selected_mcp_tools_names: Optional[List[str]] = None) -> Tuple[ShellState, Any]:
-   mcp_tools_for_llm = []
-   
-   if hasattr(state, 'mcp_client') and state.mcp_client and state.mcp_client.session:
-       all_available_mcp_tools = state.mcp_client.available_tools_llm
-       
-       if selected_mcp_tools_names and len(selected_mcp_tools_names) > 0:
-           mcp_tools_for_llm = [
-               tool_def for tool_def in all_available_mcp_tools
-               if tool_def['function']['name'] in selected_mcp_tools_names
-           ]
-           if not mcp_tools_for_llm:
-               cprint("Warning: No selected MCP tools found or matched. Corca will proceed without tools.", "yellow", file=sys.stderr)
-       else:
-           mcp_tools_for_llm = all_available_mcp_tools
-   else:
-       cprint("Warning: Corca agent has no tools. No MCP server connected.", "yellow", file=sys.stderr)
-
-   active_npc = state.npc if isinstance(state.npc, NPC) else NPC(name="default")
-
-   response_dict = get_llm_response(
-       prompt=command,
-       npc=state.npc,
-       messages=state.messages,
-       tools=mcp_tools_for_llm,
-       auto_process_tool_calls=False,
-       stream=state.stream_output
-   )
-   
-   stream_response = response_dict.get('response')
-   messages = response_dict.get('messages', state.messages)
+    mcp_tools_for_llm = []
+    
+    if hasattr(state, 'mcp_client') and state.mcp_client and state.mcp_client.session:
+        all_available_mcp_tools = state.mcp_client.available_tools_llm
+        
+        if selected_mcp_tools_names and len(selected_mcp_tools_names) > 0:
+            mcp_tools_for_llm = [
+                tool_def for tool_def in all_available_mcp_tools
+                if tool_def['function']['name'] in selected_mcp_tools_names
+            ]
+            if not mcp_tools_for_llm:
+                cprint("Warning: No selected MCP tools found or matched. Corca will proceed without tools.", "yellow", file=sys.stderr)
+        else:
+            mcp_tools_for_llm = all_available_mcp_tools
+    else:
+        cprint("Warning: Corca agent has no tools. No MCP server connected.", "yellow", file=sys.stderr)
+
+    active_npc = state.npc if isinstance(state.npc, NPC) else NPC(name="default")
+
+    response_dict = get_llm_response(
+        prompt=command,
+        npc=state.npc,
+        messages=state.messages,
+        tools=mcp_tools_for_llm,
+        auto_process_tool_calls=False,
+        stream=state.stream_output,
+        team=state.team  
+    )
    
-   print("DEBUG: Processing stream response...")
-   collected_content, tool_calls = process_mcp_stream(stream_response, active_npc)
+    stream_response = response_dict.get('response')
+    messages = response_dict.get('messages', state.messages)
+    
+    collected_content, tool_calls = process_mcp_stream(stream_response, active_npc)
 
-   print(f"\nDEBUG: Final collected_content: {collected_content}")
-   print(f"DEBUG: Final tool_calls: {tool_calls}")
-   
-   state.messages = messages
-   if collected_content or tool_calls:
-       assistant_message = {"role": "assistant", "content": collected_content}
-       if tool_calls:
-           assistant_message["tool_calls"] = tool_calls
-       state.messages.append(assistant_message)
-   
-   return state, {
-       "output": collected_content,
-       "tool_calls": tool_calls,
-       "messages": state.messages
-   }
+    
+    state.messages = messages
+    if collected_content or tool_calls:
+        assistant_message = {"role": "assistant", "content": collected_content}
+        if tool_calls:
+            assistant_message["tool_calls"] = tool_calls
+        state.messages.append(assistant_message)
+    
+    return state, {
+        "output": collected_content,
+        "tool_calls": tool_calls,
+        "messages": state.messages
+    }
 
 
 def _resolve_and_copy_mcp_server_path(
@@ -306,7 +300,7 @@ def _resolve_and_copy_mcp_server_path(
     current_path: Optional[str],
     team_ctx_mcp_servers: Optional[List[Dict[str, str]]],
     interactive: bool = False,
-    auto_copy_bypass: bool = False # <-- New parameter
+    auto_copy_bypass: bool = False
 ) -> Optional[str]:
     default_mcp_server_name = "mcp_server.py"
     npcsh_default_template_path = Path(__file__).parent / default_mcp_server_name
@@ -318,13 +312,12 @@ def _resolve_and_copy_mcp_server_path(
             return None
         
         if not destination_file.exists():
-            # Check auto_copy_bypass first
-            if auto_copy_bypass or not interactive: # If bypass is true OR not interactive, auto-copy
+            if auto_copy_bypass or not interactive:
                 destination_dir.mkdir(parents=True, exist_ok=True)
                 shutil.copy(npcsh_default_template_path, destination_file)
                 print(colored(f"Automatically copied default {default_mcp_server_name} to {destination_file}", "green"))
                 return destination_file
-            else: # Only ask if interactive and no bypass
+            else: 
                 choice = input(colored(f"No {default_mcp_server_name} found in {description}. Copy default template to {destination_file}? (y/N): ", "yellow")).strip().lower()
                 if choice == 'y':
                     destination_dir.mkdir(parents=True, exist_ok=True)
@@ -417,15 +410,31 @@ def create_corca_state_and_mcp_client(conversation_id, command_history, npc=None
     )
     state.command_history = command_history
     
-    # Read NPCSH_CORCA_AUTO_COPY_MCP_SERVER from environment for non-interactive calls
+    team_ctx_mcp_servers = None
+    if team and hasattr(team, 'team_path'):
+        team_ctx = _load_team_context(team.team_path)
+        team_ctx_mcp_servers = team_ctx.get('mcp_servers', [])
+        
+        if npc and isinstance(npc, NPC):
+            if not npc.model and team_ctx.get('model'):
+                npc.model = team_ctx['model']
+            if not npc.provider and team_ctx.get('provider'):
+                npc.provider = team_ctx['provider']
+        
+        if not state.chat_model and team_ctx.get('model'):
+            state.chat_model = team_ctx['model']
+        if not state.chat_provider and team_ctx.get('provider'):
+            state.chat_provider = team_ctx['provider']
+    
     auto_copy_bypass = os.getenv("NPCSH_CORCA_AUTO_COPY_MCP_SERVER", "false").lower() == "true"
 
     resolved_server_path = _resolve_and_copy_mcp_server_path(
         explicit_path=mcp_server_path_from_request,
         current_path=current_path,
-        team_ctx_mcp_servers=team.team_ctx.get('mcp_servers', []) if team and hasattr(team, 'team_ctx') else None,
-        interactive=False, # Always non-interactive for Flask API calls
-        auto_copy_bypass=auto_copy_bypass # Pass env var setting
+        team_ctx_mcp_servers=team_ctx_mcp_servers,
+        interactive=False,
+        auto_copy_bypass=auto_copy_bypass,
+        force_global=False
     )
 
     state.mcp_client = None
@@ -513,9 +522,9 @@ def process_corca_result(
                 
                 tool_content = ""
                 if hasattr(mcp_result, 'content') and mcp_result.content:
-                    print(f"DEBUG: content type: {type(mcp_result.content)}")
+
                     for i, content_item in enumerate(mcp_result.content):
-                        print(f"DEBUG: content_item[{i}]: {content_item} (type: {type(content_item)})")
+
                         if hasattr(content_item, 'text'):
                             tool_content += content_item.text
                         else:
@@ -523,8 +532,7 @@ def process_corca_result(
                 else:
                     tool_content = str(mcp_result)
                 
-                print(f"DEBUG: Extracted content length: {len(tool_content)}")
-                print(f"DEBUG: Extracted content preview: {tool_content[:200]}")
+
                 
                 tool_responses.append({
                     "role": "tool",
@@ -703,11 +711,11 @@ def process_corca_result(
                 characterization = summary.get('output')
 
                 if characterization and result_state.team:
-                    team_ctx_path = os.path.join(result_state.team.team_path, "team.ctx")
-                    ctx_data = {}
-                    if os.path.exists(team_ctx_path):
-                        with open(team_ctx_path, 'r') as f:
-                            ctx_data = yaml.safe_load(f) or {}
+                    team_ctx_path = get_team_ctx_path(result_state.team.team_path)
+                    if not team_ctx_path:
+                        team_ctx_path = os.path.join(result_state.team.team_path, "team.ctx")
+                    
+                    ctx_data = _load_team_context(result_state.team.team_path)
                     current_context = ctx_data.get('context', '')
 
                     prompt = f"""Based on this characterization: {characterization},
@@ -722,28 +730,39 @@ def process_corca_result(
                     "suggestion": "Your sentence.
                     }
                     """
-                    response = get_llm_response(prompt, npc=active_npc, format="json")
+                    response = get_llm_response(prompt, 
+                                        npc=active_npc, 
+                                        format="json",
+                                        team=result_state.team)   
                     suggestion = response.get("response", {}).get("suggestion")
 
                     if suggestion:
                         new_context = (current_context + " " + suggestion).strip()
                         print(colored(f"{result_state.npc.name} suggests updating team context:", "yellow"))
                         print(f"  - OLD: {current_context}\n  + NEW: {new_context}")
-                        if input("Apply? [y/N]: ").strip().lower() == 'y':
+                        
+                        choice = input("Apply? [y/N/e(dit)]: ").strip().lower()
+                        
+                        if choice == 'y':
                             ctx_data['context'] = new_context
                             with open(team_ctx_path, 'w') as f:
                                 yaml.dump(ctx_data, f)
                             print(colored("Team context updated.", "green"))
+                        elif choice == 'e':
+                            edited_context = input(f"Edit context [{new_context}]: ").strip()
+                            if edited_context:
+                                ctx_data['context'] = edited_context
+                            else:
+                                ctx_data['context'] = new_context
+                            with open(team_ctx_path, 'w') as f:
+                                yaml.dump(ctx_data, f)
+                            print(colored("Team context updated with edits.", "green"))
                         else:
-                            print("Suggestion declined.")
+                            print("Suggestion declined.")        
             except Exception as e:
                 import traceback
                 print(colored(f"Could not generate team suggestions: {e}", "yellow"))
                 traceback.print_exc()
-             
-             
-
-
 
 def _read_npcsh_global_env() -> Dict[str, str]:
     global_env_file = Path(".npcsh_global")
@@ -760,6 +779,20 @@ def _read_npcsh_global_env() -> Dict[str, str]:
             print(f"Warning: Could not read .npcsh_global: {e}")
     return env_vars
 
+def _load_team_context(team_path: str) -> Dict[str, Any]:
+    """Load team context from any .ctx file in the team directory"""
+    ctx_path = get_team_ctx_path(team_path)
+    if not ctx_path or not os.path.exists(ctx_path):
+        return {}
+    
+    try:
+        with open(ctx_path, 'r') as f:
+            return yaml.safe_load(f) or {}
+    except Exception as e:
+        print(f"Warning: Could not load team context from {ctx_path}: {e}")
+        return {}
+
+
 def _write_to_npcsh_global(key: str, value: str) -> None:
     global_env_file = Path(".npcsh_global")
     env_vars = _read_npcsh_global_env()
@@ -772,6 +805,7 @@ def _write_to_npcsh_global(key: str, value: str) -> None:
     except Exception as e:
         print(f"Warning: Could not write to .npcsh_global: {e}")
 
+
 def _resolve_and_copy_mcp_server_path(
     explicit_path: Optional[str],
     current_path: Optional[str],
@@ -859,7 +893,6 @@ def _resolve_and_copy_mcp_server_path(
             
     cprint("No MCP server script found in any expected location.", "yellow")
     return None
-
 def create_corca_state_and_mcp_client(conversation_id, command_history, npc=None, team=None,
                                      current_path=None, mcp_server_path_from_request: Optional[str] = None):
     from npcsh._state import ShellState
@@ -1018,7 +1051,7 @@ def main():
     elif os.path.exists(global_corca_path):
         default_npc = NPC(file=global_corca_path, 
                           db_conn=command_history.engine)
-    print('Team Default: ', team.provider, team.model)
+
     if default_npc.model is None:
         if team.model is not None:
             default_npc.model = team.model

{npcsh-1.0.28 → npcsh-1.0.29}/npcsh/guac.py

@@ -1,4 +1,3 @@
-from chroptiks.plotting_utils import * 
 from datetime import datetime
 import json
 import numpy as np
@@ -7,12 +6,24 @@ import pandas as pd
 import sys
 import argparse
 import importlib.metadata
-import matplotlib.pyplot as plt 
+import matplotlib
+import platform
+import queue
+plot_queue = queue.Queue()
+
+if platform.system() == 'Darwin':
+    try:
+        matplotlib.use('TkAgg')
+    except ImportError:
+        matplotlib.use('Agg')
+else:
+    matplotlib.use('TkAgg')
+
+import matplotlib.pyplot as plt
+from chroptiks.plotting_utils import * 
 
 import logging
-plt.ioff()
 import shlex
-import platform
 import yaml
 import re
 from pathlib import Path
@@ -30,7 +41,7 @@ from npcpy.memory.command_history import CommandHistory, start_new_conversation
 from npcpy.npc_compiler import Team, NPC
 from npcpy.llm_funcs import get_llm_response
 from npcpy.npc_sysenv import render_markdown,print_and_process_stream
-
+from npcpy.data.load import load_file_contents
 
 from npcsh._state import (
     ShellState,
@@ -40,7 +51,8 @@ from npcsh._state import (
     readline_safe_prompt,
     setup_shell,
     get_multiline_input,
-    orange
+    orange, 
+    get_team_ctx_path,
 )
 import threading
 import time
@@ -97,9 +109,6 @@ def _clear_readline_buffer():
         return False
 
 def _file_drop_monitor(npc_team_dir: Path, state: ShellState, locals_dict: Dict[str, Any], poll_interval: float = 0.2):
-    """
-    Background thread: poll readline.get_line_buffer() and process file drops immediately.
-    """
     processed_bufs = set()
     stop_event = _guac_monitor_stop_event
     while stop_event is None or not stop_event.is_set():
@@ -113,48 +122,35 @@ def _file_drop_monitor(npc_team_dir: Path, state: ShellState, locals_dict: Dict[
                 time.sleep(poll_interval)
                 continue
 
-          
             candidate = buf.strip()
-          
             if (candidate.startswith("'") and candidate.endswith("'")) or (candidate.startswith('"') and candidate.endswith('"')):
                 inner = candidate[1:-1]
             else:
                 inner = candidate
 
-          
             if " " not in inner and Path(inner.replace('~', str(Path.home()))).expanduser().exists() and Path(inner.replace('~', str(Path.home()))).expanduser().is_file():
-              
                 if buf in processed_bufs:
                     time.sleep(poll_interval)
                     continue
                 processed_bufs.add(buf)
 
-              
                 try:
-                  
-                  
                     modified_input, processed_files = _handle_file_drop(buf, npc_team_dir)
                     if processed_files:
                         target_path = processed_files[0]
-                      
                         loading_code = _generate_file_analysis_code(inner, target_path)
-                      
-                        print("\n[guac] Detected file drop — processing automatically...")
-                      
-                        _state, exec_output = execute_python_code(loading_code, state, locals_dict)
-                      
-                        if exec_output:
-                            print(exec_output)
-                      
+                        
+                        plot_queue.put(('execute_code', loading_code, state, locals_dict))
+                        print("\n[guac] Detected file drop — queued for processing...")
                         _clear_readline_buffer()
                 except Exception as e:
                     print(f"[guac][ERROR] file drop processing failed: {e}")
         except Exception:
-          
             pass
         time.sleep(poll_interval)
 
 
+
 def is_python_code(text: str) -> bool:
     text = text.strip()
     if not text:
@@ -476,13 +472,43 @@ def ensure_global_guac_team():
         print(f"✅ Created global guac team.ctx at {ctx_path}")
 
     return team_dir
-def setup_guac_mode(config_dir=None, plots_dir=None, npc_team_dir=None,
-                    lang='python', default_mode_choice=None):
-    base_dir = Path.cwd()                
+
+
+def setup_guac_mode(config_dir=None, 
+                    plots_dir=None, 
+                    npc_team_dir=None,
+                    lang='python', 
+                    default_mode_choice=None):
+    base_dir = Path.cwd()
     
-  
-    if GUAC_GLOBAL_FLAG_FILE.exists():
-        print("💡 Using global Guac team as default (previously set).")
+    local_npc_team = base_dir / "npc_team"
+    if local_npc_team.exists():
+        npc_team_dir = local_npc_team
+        workspace_dirs = _get_workspace_dirs(npc_team_dir)
+        _ensure_workspace_dirs(workspace_dirs)
+        
+        team_ctx_path = npc_team_dir / "team.ctx"
+        existing_ctx = {}
+        if team_ctx_path.exists():
+            try:
+                with open(team_ctx_path, "r") as f:
+                    existing_ctx = yaml.safe_load(f) or {}
+            except Exception as e:
+                print(f"Warning: Could not read team.ctx: {e}")
+        
+        package_root = existing_ctx.get("GUAC_PACKAGE_ROOT", str(base_dir))
+        package_name = existing_ctx.get("GUAC_PACKAGE_NAME", "project")
+        project_description = existing_ctx.get("GUAC_PROJECT_DESCRIPTION", "Local guac team")
+        
+        return {
+            "language": lang, "package_root": Path(package_root), "plots_dir": plots_dir,
+            "npc_team_dir": npc_team_dir, "config_dir": config_dir, "default_mode": default_mode_choice or "agent",
+            "project_description": project_description, "package_name": package_name
+        }
+
+    global_flag_file = base_dir / ".npcsh_global"
+    if global_flag_file.exists() or os.environ.get("GUAC_USE_GLOBAL") == "1":
+        print("Using global Guac team")
         team_dir = ensure_global_guac_team()
         return {
             "language": lang, "package_root": team_dir, "plots_dir": plots_dir,
@@ -490,7 +516,6 @@ def setup_guac_mode(config_dir=None, plots_dir=None, npc_team_dir=None,
             "project_description": "Global guac team for analysis.", "package_name": "guac"
         }
 
-  
     if npc_team_dir is None:
         npc_team_dir = base_dir / "npc_team"
     else:
@@ -518,8 +543,9 @@ def setup_guac_mode(config_dir=None, plots_dir=None, npc_team_dir=None,
             response = input("Enter package name (Enter for 'project'): ").strip()
             package_name = response if response else "project"
         except (KeyboardInterrupt, EOFError):
-            print("⚠️ Project setup interrupted. Falling back to global guac team...")
-            GUAC_GLOBAL_FLAG_FILE.touch() 
+            print("Project setup interrupted. Falling back to global guac team...")
+            global_flag_file.touch()
+            os.environ["GUAC_USE_GLOBAL"] = "1"
             team_dir = ensure_global_guac_team()
             return {
                 "language": lang, "package_root": team_dir, "plots_dir": plots_dir,
@@ -573,6 +599,7 @@ setup(name="{package_name}", version="0.0.1", description="{desc}", packages=fin
         "npc_team_dir": npc_team_dir, "config_dir": config_dir, "default_mode": default_mode_val,
         "project_description": project_description, "package_name": package_name
     }
+
 def setup_npc_team(npc_team_dir, lang, is_subteam=False):
   
     guac_npc = {
@@ -694,50 +721,6 @@ class FileAnalysisState(Base):
     variable_names = Column(Text)
     timestamp = Column(DateTime, default=func.now())
 
-def _capture_plot_state(session_id: str, db_path: str, npc_team_dir: Path):
-    """Capture plot state if significant change"""
-    if not plt.get_fignums():
-        return
-    
-    engine = create_engine(f'sqlite:///{db_path}')
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    
-  
-    fig = plt.gcf()
-    axes = fig.get_axes()
-    data_points = sum(len(line.get_xdata()) for ax in axes for line in ax.get_lines())
-    
-  
-    plot_hash = hashlib.md5(f"{len(axes)}{data_points}".encode()).hexdigest()
-    
-    last = session.query(PlotState).filter(PlotState.session_id == session_id).order_by(PlotState.timestamp.desc()).first()
-    if last and last.plot_hash == plot_hash:
-        session.close()
-        return
-    
-  
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    workspace_dirs = _get_workspace_dirs(npc_team_dir)
-    plot_path = workspace_dirs["plots"] / f"state_{timestamp}.png"
-    plt.savefig(plot_path, dpi=150, bbox_inches='tight')
-    
-  
-    plot_state = PlotState(
-        session_id=session_id,
-        plot_hash=plot_hash,
-        plot_description=f"Plot with {len(axes)} axes, {data_points} points",
-        figure_path=str(plot_path),
-        data_summary=f"{data_points} data points",
-        change_significance=1.0 if not last else 0.5
-    )
-    
-    session.add(plot_state)
-    session.commit()
-    session.close()
-    print(f"📊 Plot state captured -> {plot_path.name}")
-
 def _capture_file_state(session_id: str, db_path: str, file_path: str, analysis_code: str, locals_dict: Dict):
     """Capture file analysis state"""
     engine = create_engine(f'sqlite:///{db_path}')
@@ -986,24 +969,23 @@ def _handle_file_drop(input_text: str, npc_team_dir: Path) -> Tuple[str, List[st
 
     return modified_input, processed_files, file_paths
 
-
 def _capture_plot_state(session_id: str, db_path: str, npc_team_dir: Path):
-    """Capture plot state if significant change"""
     if not plt.get_fignums():
         return
     
     try:
+        workspace_dirs = _get_workspace_dirs(npc_team_dir)
+        workspace_dirs["plots"].mkdir(parents=True, exist_ok=True)
+        
         engine = create_engine(f'sqlite:///{db_path}')
         Base.metadata.create_all(engine)
         Session = sessionmaker(bind=engine)
         session = Session()
         
-      
         fig = plt.gcf()
         axes = fig.get_axes()
         data_points = sum(len(line.get_xdata()) for ax in axes for line in ax.get_lines())
         
-      
         plot_hash = hashlib.md5(f"{len(axes)}{data_points}".encode()).hexdigest()
         
         last = session.query(PlotState).filter(PlotState.session_id == session_id).order_by(PlotState.timestamp.desc()).first()
@@ -1011,13 +993,10 @@ def _capture_plot_state(session_id: str, db_path: str, npc_team_dir: Path):
             session.close()
             return
         
-      
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        workspace_dirs = _get_workspace_dirs(npc_team_dir)
         plot_path = workspace_dirs["plots"] / f"state_{timestamp}.png"
         plt.savefig(plot_path, dpi=150, bbox_inches='tight')
         
-      
         plot_state = PlotState(
             session_id=session_id,
             plot_hash=plot_hash,
@@ -1026,15 +1005,14 @@ def _capture_plot_state(session_id: str, db_path: str, npc_team_dir: Path):
             data_summary=f"{data_points} data points",
             change_significance=1.0 if not last else 0.5
         )
-    
+
         session.add(plot_state)
         session.commit()
         session.close()
-        print(f"📊 Plot state captured -> {plot_path.name}")
+        print(f"Plot state captured -> {plot_path.name}")
         
     except Exception as e:
         print(f"Error capturing plot state: {e}")
-
 def _capture_file_state(session_id: str, db_path: str, file_path: str, analysis_code: str, locals_dict: Dict):
     """Capture file analysis state"""
     try:
@@ -1165,7 +1143,7 @@ def _get_guac_agent_emoji(failures: int, max_fail: int = 3) -> str:
         return "🥑❓" 
 
 
-GUAC_GLOBAL_FLAG_FILE = Path.home() / ".npcsh" / ".guac_use_global"
+
 
 
 def _run_agentic_mode(command: str,
@@ -1211,8 +1189,9 @@ def _run_agentic_mode(command: str,
 
         DO NOT SIMPLY COPY A PREVIOUS ATTEMPT.        
         
-        Your goal is to generate Python code that BUILDS ON EXISTING VARIABLES to accomplish this task: {current_command}, with this next step planned: `{next_step} `
+        Your goal is to generate Python code that BUILDS ON EXISTING VARIABLES to respond to this task: USER TASK: "{current_command}", with this next step planned: `{next_step} `
 
+        If there is no relevant code to build on or the user is simply asking a question, generate new code as needed to respond to their questions.
         
         You will notice in the local envs that there are functions for reading, editing, and loading files. 
         You should use these to your advantage as they will help you to clearly understand the user's system best.
@@ -1250,21 +1229,26 @@ def _run_agentic_mode(command: str,
 
         Do not over- complicate the code.
 
-        Do not include any '__name__'=='__main__' block.
+        DO NOT include any '__name__'=='__main__' block.
         """
         
         npc_model = state.npc.model if state.npc and state.npc.model else state.chat_model
         npc_provider = state.npc.provider if state.npc and state.npc.provider else state.chat_provider
         
+        print(state.npc.model)
+        print(state.chat_model)
         llm_response = get_llm_response(prompt,
                                         npc=state.npc,
                                         stream=True,
                                         messages=state.messages, 
                                         thinking=False)
 
+        print(llm_response.get('response'))
+        print(npc_model, npc_provider)
+
         generated_code = print_and_process_stream(llm_response.get('response'),
                                                   npc_model,
-                                                  npc_provider
+                                                  npc_provider, 
                                                   )
         
         state.messages.append({'role':'user', 'content':current_command })
@@ -1560,8 +1544,6 @@ def execute_guac_command(command: str, state: ShellState, locals_dict: Dict[str,
 def run_guac_repl(state: ShellState, project_name: str, package_root: Path, package_name: str):
     from npcsh.routes import router
 
-    
-  
     npc_team_dir = Path.cwd() / "npc_team"
     workspace_dirs = _get_workspace_dirs(npc_team_dir)
     _ensure_workspace_dirs(workspace_dirs)
@@ -1593,15 +1575,8 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
             
     except Exception as e:
         print(f"Warning: Could not load package {package_name}: {e}", file=sys.stderr)
-            
-    from npcpy.data.load import load_file_contents
 
     def read_file(file_path, max_lines=10000, encoding='utf-8'):
-        """
-        Read and print file contents up to max_lines.
-        Uses npcpy.data.load for specialized file types, falls back to text reading.
-        Returns the content as a string for further processing.
-        """
         path = Path(file_path).expanduser().resolve()
         
         if not path.exists():
@@ -1613,7 +1588,6 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
             return None
         
         try:
-          
             file_ext = path.suffix.upper().lstrip('.')
             if file_ext in ['PDF', 'DOCX', 'PPTX', 'HTML', 'HTM', 'CSV', 'XLS', 'XLSX', 'JSON']:
                 chunks = load_file_contents(str(path), chunk_size=10000)
@@ -1635,7 +1609,6 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
                     print(f"End of {path.name}")
                     return content
             
-          
             with open(path, 'r', encoding=encoding) as f:
                 lines = []
                 for i, line in enumerate(f, 1):
@@ -1674,19 +1647,10 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
             return None
 
     def edit_file(file_path, content=None, line_number=None, new_line=None, insert_at=None, append=False, backup=True):
-        """
-        Edit file contents in various ways:
-        - edit_file(path, content="new content") - replace entire file
-        - edit_file(path, line_number=5, new_line="new text") - replace specific line
-        - edit_file(path, insert_at=5, new_line="inserted text") - insert at line
-        - edit_file(path, append=True, content="appended") - append to file
-        """
         path = Path(file_path).expanduser().resolve()
         
-      
         path.parent.mkdir(parents=True, exist_ok=True)
         
-      
         if backup and path.exists():
             backup_path = path.with_suffix(path.suffix + '.backup')
             import shutil
@@ -1694,7 +1658,6 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
             print(f"Backup saved: {backup_path.name}")
         
         try:
-          
             existing_lines = []
             if path.exists():
                 with open(path, 'r', encoding='utf-8') as f:
@@ -1754,10 +1717,6 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
             return False
 
     def load_file(file_path):
-        """
-        Simple wrapper around npcpy's load_file_contents for direct data loading.
-        Returns the loaded data in appropriate format.
-        """
         path = Path(file_path).expanduser().resolve()
         
         if not path.exists():
@@ -1782,7 +1741,6 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
         'load_file':load_file,
     }
 
-
     locals_dict.update(core_imports)
     locals_dict.update({f"guac_{k}": v for k, v in workspace_dirs.items()})
     
@@ -1801,10 +1759,20 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
     
     while True:
         try:
+            try:
+                while True:
+                    operation, code, exec_state, exec_locals = plot_queue.get_nowait()
+                    if operation == 'execute_code':
+                        print("\n[guac] Processing queued file drop...")
+                        exec_state, exec_output = execute_python_code(code, exec_state, exec_locals)
+                        if exec_output:
+                            print(exec_output)
+            except queue.Empty:
+                pass
+            
             state.current_path = os.getcwd()
             
             display_model = state.chat_model
-          
             if isinstance(state.npc, NPC) and state.npc.model:
                 display_model = state.npc.model
             
@@ -1865,7 +1833,6 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
 
 
 
-
 def enter_guac_mode(npc=None, 
                     team=None,
                     config_dir=None, 
@@ -1897,25 +1864,6 @@ def enter_guac_mode(npc=None,
   
     command_history, default_team, default_npc = setup_shell()
 
-  
-    if npc is None and default_npc is None:
-      
-        guac_npc_path = Path(npc_team_dir) / "guac.npc" 
-        if guac_npc_path.exists():
-            npc = NPC(file=str(guac_npc_path), db_conn=command_history.engine)
-          
-            team_ctx_path = Path(npc_team_dir) / "team.ctx"
-            if team_ctx_path.exists():
-                with open(team_ctx_path, "r") as f:
-                    team_ctx = yaml.safe_load(f) or {}
-                team = Team(team_path=str(npc_team_dir), forenpc=npc, jinxs={}) 
-                team.name = team_ctx.get("team_name", "guac_global_team")
-        else:
-            raise RuntimeError(f"No NPC loaded and {guac_npc_path} not found!")
-    elif default_npc and npc is None:
-      
-        npc = default_npc
-
 
     state = ShellState(
         conversation_id=start_new_conversation(),
@@ -1930,6 +1878,45 @@ def enter_guac_mode(npc=None,
     
     state.command_history = command_history
 
+    if npc is None and default_npc is None:
+        guac_npc_path = Path(npc_team_dir) / "guac.npc" 
+        if guac_npc_path.exists():
+            npc = NPC(file=str(guac_npc_path), 
+                      db_conn=command_history.engine)
+            print(guac_npc_path, npc)
+
+            team_ctx_path = get_team_ctx_path(str(npc_team_dir))
+            team_ctx = {}
+            if team_ctx_path and Path(team_ctx_path).exists():
+                with open(team_ctx_path, "r") as f:
+                    team_ctx = yaml.safe_load(f) or {}
+            print(team_ctx, team_ctx_path)
+            team = Team(team_path=str(npc_team_dir), 
+                        forenpc=npc, 
+                        jinxs={}) 
+            team.name = team_ctx.get("team_name", "guac_global_team")
+            team.team_ctx = team_ctx
+            print(team)
+            if npc.model is None:
+                npc.model = team_ctx.get("model", state.chat_model)
+            if npc.provider is None:
+                npc.provider = team_ctx.get("provider", state.chat_provider)
+                
+            for npc_name, npc_obj in team.npcs.items():
+                if not npc_obj.model:
+                    npc_obj.model = team_ctx.get("model", state.chat_model)
+                if not npc_obj.provider:
+                    npc_obj.provider = team_ctx.get("provider", state.chat_provider)
+        else:
+            raise RuntimeError(f"No NPC loaded and {guac_npc_path} not found!")
+    elif default_npc and npc is None:
+        npc = default_npc
+    state.npc = npc or default_npc
+    state.team = team or default_team
+
+    state.plots_dir = setup_result.get("plots_dir")
+    state.config_dir = setup_result.get("config_dir")
+
     try:
         readline.read_history_file(READLINE_HISTORY_FILE)
         readline.set_history_length(1000)

{npcsh-1.0.28 → npcsh-1.0.29}/npcsh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.28
+Version: 1.0.29
 Summary: npcsh is a command-line toolkit for using AI agents in novel ways.
 Home-page: https://github.com/NPC-Worldwide/npcsh
 Author: Christopher Agostino

{npcsh-1.0.28 → npcsh-1.0.29}/setup.py

@@ -78,7 +78,7 @@ extra_files = package_files("npcsh/npc_team/")
 
 setup(
     name="npcsh",
-    version="1.0.28",
+    version="1.0.29",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  # Only install base requirements by default
     extras_require={