npcsh 1.0.20__tar.gz → 1.0.21__tar.gz

{npcsh-1.0.20 → npcsh-1.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.20
+Version: 1.0.21
 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.20 → npcsh-1.0.21}/npcsh/_state.py

@@ -2198,10 +2198,10 @@ def execute_command(
     active_model = npc_model or state.chat_model
     active_provider = npc_provider or state.chat_provider
     if state.current_mode == 'agent':
-        print('# of parsed commands: ', len(commands))
-        print('Commands:' '\n'.join(commands))
+        #print('# of parsed commands: ', len(commands))
+        #print('Commands:' '\n'.join(commands))
         for i, cmd_segment in enumerate(commands):
-            render_markdown(f'- executing command {i+1}/{len(commands)}')
+            render_markdown(f'- Executing command {i+1}/{len(commands)}')
             is_last_command = (i == len(commands) - 1)
             stream_this_segment = state.stream_output and not is_last_command 
             try:
@@ -2353,8 +2353,9 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
                 ctx_path = os.path.join(team_dir, "team.ctx")
                 folder_context = input("Enter a short description for this project/team (optional): ").strip()
                 team_ctx_data = {
-                    "forenpc": default_forenpc_name, "model": forenpc_model,
-                    "provider": forenpc_provider, "api_key": None, "api_url": None,
+                    "forenpc": default_forenpc_name, 
+                    "model": forenpc_model,
+                    "provider": forenpc_provider, 
                     "context": folder_context if folder_context else None
                 }
                 use_jinxs = input("Use global jinxs folder (g) or copy to this project (c)? [g/c, default: g]: ").strip().lower()

{npcsh-1.0.20 → npcsh-1.0.21}/npcsh/corca.py

@@ -163,97 +163,131 @@ class MCPClientNPC:
                     pass
             self.session = None
 
-def execute_command_corca(command: str, state: ShellState, command_history) -> Tuple[ShellState, Any]:
-    mcp_tools = []
-    
-    if hasattr(state, 'mcp_client') and state.mcp_client and state.mcp_client.session:
-        mcp_tools = state.mcp_client.available_tools_llm
-    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")
-
-    # Get the initial response with tools available but don't auto-process
-    response_dict = get_llm_response(
-        prompt=command,
-        model=active_npc.model or state.chat_model,
-        provider=active_npc.provider or state.chat_provider,
-        npc=state.npc,
-        messages=state.messages,
-        tools=mcp_tools,
-        auto_process_tool_calls=False,
-        stream=state.stream_output
-    )
-    
-    # Process the streaming response to extract tool calls
-    stream_response = response_dict.get('response')
-    messages = response_dict.get('messages', state.messages)
-    
-    # Collect the streamed content and extract tool calls
+
+def process_mcp_stream(stream_response, active_npc):
+    """Process streaming response and extract content + tool calls for both Ollama and OpenAI providers"""
     collected_content = ""
     tool_calls = []
-    current_tool_call = None
     
-    print("DEBUG: Processing stream response...")
+    interrupted = False
     
-    if hasattr(stream_response, '__iter__'):
-        # Process the stream to extract content and tool calls
-        for chunk in stream_response:
-            print(f"DEBUG: Chunk type: {type(chunk)}")
-            
-            if hasattr(chunk, 'choices') and chunk.choices:
-                delta = chunk.choices[0].delta
-                
-                if hasattr(delta, 'content') and delta.content:
-                    collected_content += delta.content
-                    print(delta.content, end='', flush=True)
-                
-                if hasattr(delta, 'tool_calls') and delta.tool_calls:
-                    for tool_call_delta in delta.tool_calls:
-                        print(f"DEBUG: Tool call delta: {tool_call_delta}")
+    # Save cursor position at the start
+    sys.stdout.write('\033[s')  # Save cursor position
+    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', ''),
+                            '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 hasattr(tool_call_delta, 'index'):
-                            idx = tool_call_delta.index
-                            
-                            # Initialize tool call if needed
-                            while len(tool_calls) <= idx:
-                                tool_calls.append({
-                                    'id': '',
-                                    'type': 'function',
-                                    'function': {
-                                        'name': '',
-                                        'arguments': ''
-                                    }
-                                })
-                            
-                            # Update tool call data
-                            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
+                        if isinstance(tool_call_data['function']['arguments'], str):
+                            try:
+                                tool_call_data['function']['arguments'] = json.loads(tool_call_data['function']['arguments'])
+                            except json.JSONDecodeError:
+                                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)
+                    
+            # Handle OpenAI-style responses (including gpt-oss)
+            else:
+                if hasattr(chunk, 'choices') and chunk.choices:
+                    delta = chunk.choices[0].delta
+                    
+                    if hasattr(delta, 'content') and delta.content:
+                        collected_content += delta.content
+                        print(delta.content, end='', flush=True)
+                    
+                    if hasattr(delta, 'tool_calls') and delta.tool_calls:
+                        for tool_call_delta in delta.tool_calls:
+                            if hasattr(tool_call_delta, 'index'):
+                                idx = tool_call_delta.index
                                 
-                                if hasattr(tool_call_delta.function, 'arguments') and tool_call_delta.function.arguments:
-                                    tool_calls[idx]['function']['arguments'] += tool_call_delta.function.arguments
-    
-    print(f"\nDEBUG: Final collected_content: {collected_content}")
-    print(f"DEBUG: Final tool_calls: {tool_calls}")
-    
-    # Update messages with the assistant response
-    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)
+                                while len(tool_calls) <= idx:
+                                    tool_calls.append({
+                                        'id': '',
+                                        'type': 'function',
+                                        'function': {'name': '', 'arguments': ''}
+                                    })
+                                
+                                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
+                                    
+                                    if hasattr(tool_call_delta.function, 'arguments') and tool_call_delta.function.arguments:
+                                        tool_calls[idx]['function']['arguments'] += tool_call_delta.function.arguments
+    except KeyboardInterrupt:
+        interrupted = True
+        print('\n⚠️ Stream interrupted by user')
+    if interrupted:
+        str_output += "\n\n[⚠️ Response interrupted by user]"
+    # Always restore cursor position and clear everything after it
+    sys.stdout.write('\033[u')  # Restore cursor position
+    sys.stdout.write('\033[J')  # Clear from cursor down
+    sys.stdout.flush()
     
-    return state, {
-        "output": collected_content,
-        "tool_calls": tool_calls,
-        "messages": state.messages
-    }
-        
+    # Now render the markdown at the restored position
+    render_markdown(collected_content)
+    print('\n')
+    return collected_content, tool_calls
+
+def execute_command_corca(command: str, state: ShellState, command_history) -> Tuple[ShellState, Any]:
+   mcp_tools = []
+   
+   if hasattr(state, 'mcp_client') and state.mcp_client and state.mcp_client.session:
+       mcp_tools = state.mcp_client.available_tools_llm
+   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,
+       model=active_npc.model or state.chat_model,
+       provider=active_npc.provider or state.chat_provider,
+       npc=state.npc,
+       messages=state.messages,
+       tools=mcp_tools,
+       auto_process_tool_calls=False,
+       stream=state.stream_output
+   )
+   
+   stream_response = response_dict.get('response')
+   messages = response_dict.get('messages', state.messages)
+   
+   print("DEBUG: Processing stream response...")
+   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
+   }
+
 def print_corca_welcome_message():
     turq = "\033[38;2;64;224;208m"
     chrome = "\033[38;2;211;211;211m"
@@ -313,11 +347,13 @@ def process_corca_result(
         tool_responses = []
         for tool_call in tool_calls:
             tool_name = tool_call['function']['name']
-            tool_args_str = tool_call['function']['arguments']
+            tool_args = tool_call['function']['arguments']
             tool_call_id = tool_call['id']
             
             try:
-                tool_args = json.loads(tool_args_str) if tool_args_str.strip() else {}
+                if isinstance(tool_args, str):
+                    tool_args = json.loads(tool_args) if tool_args.strip() else {}
+
             except json.JSONDecodeError:
                 tool_args = {}
             
@@ -389,45 +425,10 @@ def process_corca_result(
             follow_up_tool_calls = []
             
             if result_state.stream_output:
-                collected_content = ""
-                follow_up_tool_calls = []
-                
                 if hasattr(follow_up_content, '__iter__'):
-                    for chunk in follow_up_content:
-                        if hasattr(chunk, 'choices') and chunk.choices:
-                            delta = chunk.choices[0].delta
-                            
-                            if hasattr(delta, 'content') and delta.content:
-                                collected_content += delta.content
-                                print(delta.content, end='', flush=True)
-                            
-                            if hasattr(delta, 'tool_calls') and delta.tool_calls:
-                                for tool_call_delta in delta.tool_calls:
-                                    if hasattr(tool_call_delta, 'index'):
-                                        idx = tool_call_delta.index
-                                        
-                                        while len(follow_up_tool_calls) <= idx:
-                                            follow_up_tool_calls.append({
-                                                'id': '',
-                                                'type': 'function',
-                                                'function': {
-                                                    'name': '',
-                                                    'arguments': ''
-                                                }
-                                            })
-                                        
-                                        if hasattr(tool_call_delta, 'id') and tool_call_delta.id:
-                                            follow_up_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:
-                                                follow_up_tool_calls[idx]['function']['name'] = tool_call_delta.function.name
-                                            
-                                            if hasattr(tool_call_delta.function, 'arguments') and tool_call_delta.function.arguments:
-                                                follow_up_tool_calls[idx]['function']['arguments'] += tool_call_delta.function.arguments
+                    collected_content, follow_up_tool_calls = process_mcp_stream(follow_up_content, active_npc)
                 else:
-                    collected_content = str(follow_up_content)
-                
+                    collected_content = str(follow_up_content)                
                 follow_up_content = collected_content
             else:
                 if follow_up_messages:
@@ -452,11 +453,11 @@ def process_corca_result(
             print(colored("\n🔧 Executing follow-up MCP tools...", "cyan"))
             for tool_call in follow_up_tool_calls:
                 tool_name = tool_call['function']['name']
-                tool_args_str = tool_call['function']['arguments']
+                tool_args = tool_call['function']['arguments']
                 tool_call_id = tool_call['id']
                 
                 try:
-                    tool_args = json.loads(tool_args_str) if tool_args_str.strip() else {}
+                    tool_args = json.loads(tool_args) if tool_args.strip() else {}
                 except json.JSONDecodeError:
                     tool_args = {}
                 
@@ -648,7 +649,7 @@ def enter_corca_mode(command: str,
             if state.npc:
                 prompt_npc_name = state.npc.name
             
-            prompt_str = f"{colored(os.path.basename(state.current_path), 'blue')}:corca:{prompt_npc_name}🦌> "
+            prompt_str = f"{colored(os.path.basename(state.current_path), 'blue')}:{prompt_npc_name}🦌> "
             prompt = readline_safe_prompt(prompt_str)
             
             user_input = get_multiline_input(prompt).strip()
@@ -680,14 +681,31 @@ def enter_corca_mode(command: str,
     
     render_markdown("\n# Exiting Corca Mode")
     return {"output": "", "messages": state.messages}
-
 def main():
     parser = argparse.ArgumentParser(description="Corca - An MCP-powered npcsh shell.")
     parser.add_argument("--mcp-server-path", type=str, help="Path to an MCP server script to connect to.")
     args = parser.parse_args()
 
     command_history, team, default_npc = setup_shell()
-
+    
+    # Override default_npc with corca priority
+    project_team_path = os.path.abspath('./npc_team/')
+    global_team_path = os.path.expanduser('~/.npcsh/npc_team/')
+    
+    project_corca_path = os.path.join(project_team_path, "corca.npc")
+    global_corca_path = os.path.join(global_team_path, "corca.npc")
+    
+    if os.path.exists(project_corca_path):
+        default_npc = NPC(file=project_corca_path, 
+                          db_conn=command_history.engine)
+    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:
+        default_npc.model = team.model
+    if default_npc.provider is None:
+        default_npc.provider = team.provider
     from npcsh._state import initial_state
     initial_shell_state = initial_state
     initial_shell_state.team = team
@@ -704,6 +722,5 @@ def main():
     }
     
     enter_corca_mode(**kwargs)
-
 if __name__ == "__main__":
     main()

{npcsh-1.0.20 → npcsh-1.0.21}/npcsh/guac.py

@@ -9,6 +9,7 @@ import argparse
 import importlib.metadata
 import matplotlib.pyplot as plt 
 
+import logging
 plt.ioff()
 
 import platform
@@ -28,7 +29,7 @@ import sys
 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_with_markdown
+from npcpy.npc_sysenv import render_markdown,print_and_process_stream
 
 
 from npcsh._state import (
@@ -434,28 +435,15 @@ def _handle_guac_refresh(state: ShellState, project_name: str, src_dir: Path):
         print(f"Error during /refresh: {e}")
         traceback.print_exc()
 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 config_dir is None:
-        config_dir = base_dir / ".guac"
-    else:
-        config_dir = Path(config_dir)
-        
-    if plots_dir is None:
-        plots_dir = base_dir / "plots"
-    else:
-        plots_dir = Path(plots_dir)
-        
+    base_dir = Path.cwd()                
     if npc_team_dir is None:
         npc_team_dir = base_dir / "npc_team"
     else:
         npc_team_dir = Path(npc_team_dir)
-    
-    for p in [config_dir, plots_dir, npc_team_dir]:
-        p.mkdir(parents=True, exist_ok=True)
-
+    npc_team_dir.mkdir(parents=True, exist_ok=True)
     # Setup Guac workspace
     workspace_dirs = _get_workspace_dirs(npc_team_dir)
+
     _ensure_workspace_dirs(workspace_dirs)
 
     # Rest of existing setup_guac_mode code...
@@ -483,14 +471,8 @@ def setup_guac_mode(config_dir=None, plots_dir=None, npc_team_dir=None, lang='py
             package_root = str(base_dir)
             package_name = "project"
 
-    project_name = existing_ctx.get("GUAC_PROJECT_NAME")
     project_description = existing_ctx.get("GUAC_PROJECT_DESCRIPTION")
-    
-    if project_name is None:
-        try:
-            project_name = input("Enter the project name: ").strip() or "unknown_project"
-        except EOFError:
-            project_name = "unknown_project"
+
     if project_description is None:
         try:
             project_description = input("Enter a short description of the project: ").strip() or "No description provided."
@@ -500,35 +482,68 @@ def setup_guac_mode(config_dir=None, plots_dir=None, npc_team_dir=None, lang='py
     updated_ctx = {**existing_ctx}
     updated_ctx.update({
         "GUAC_TEAM_NAME": "guac_team",
-        "GUAC_DESCRIPTION": f"A team of NPCs specialized in {lang} analysis for project {project_name}",
+        "GUAC_DESCRIPTION": f"A team of NPCs specialized in {lang} analysis for project {package_name}",
         "GUAC_FORENPC": "guac",
-        "GUAC_PROJECT_NAME": project_name,
         "GUAC_PROJECT_DESCRIPTION": project_description,
         "GUAC_LANG": lang,
         "GUAC_PACKAGE_ROOT": package_root,
         "GUAC_PACKAGE_NAME": package_name,
         "GUAC_WORKSPACE_PATHS": {k: str(v) for k, v in workspace_dirs.items()},
     })
-
+                                                                                          
+    pkg_root_path = Path(package_root)                                                                                                                                           
+    try:                                                                                     
+        pkg_root_path.mkdir(parents=True, exist_ok=True)                                                                                                   
+        package_dir = pkg_root_path / package_name                                           
+                                                                                            
+        if not package_dir.exists():                                            
+            package_dir.mkdir(parents=True, exist_ok=True)                                                                                                  
+            (package_dir / "__init__.py").write_text("# package initialized by setup_guac_mode\n")                                                                                                                                            
+            logging.info("Created minimal package directory at %s", package_dir)              
+    except Exception as e:                                                                                                                                           
+        logging.warning("Could not ensure package root/dir: %s", e)                           
     with open(team_ctx_path, "w") as f:
         yaml.dump(updated_ctx, f, default_flow_style=False)
     print("Updated team.ctx with GUAC-specific information.")
 
+                                                                                          
+                                                                                          
+    setup_py_path = pkg_root_path / "setup.py"                                               
+                                                                                          
+                                                                                          
+    try:                                                                                  
+        if not setup_py_path.exists():                                                       
+            setup_content = f'''
+from setuptools import setup, find_packages                                                                                              
+setup(                                                                 
+ name="{package_name}", 
+ version="{existing_ctx.get("GUAC_PACKAGE_VERSION", "0.0.0")}", 
+ description="{project_description.replace('"', '\\"')}",                                 
+ packages=find_packages(),                                                                
+ include_package_data=True,                                                               
+ install_requires=[],                                                                                                                                                              
+)                                                                                         
+'''                                                                                      
+            setup_py_path.write_text(setup_content)                 
+            logging.info("Created minimal setup.py at %s", setup_py_path)                                               
+    except Exception as e:                                                                             
+        logging.warning("Could not write setup.py: %s", e)                                    
+       
     default_mode_val = default_mode_choice or "agent"
     setup_npc_team(npc_team_dir, lang)
     
+
+
     print(f"\nGuac mode configured for package: {package_name} at {package_root}")
     print(f"Workspace created at: {workspace_dirs['workspace']}")
 
     return {
         "language": lang, 
         "package_root": Path(package_root), 
-        "config_path": config_dir / "config.json",
         "plots_dir": plots_dir, 
         "npc_team_dir": npc_team_dir,
         "config_dir": config_dir, 
         "default_mode": default_mode_val,
-        "project_name": project_name, 
         "project_description": project_description,
         "package_name": package_name
     }
@@ -944,33 +959,11 @@ def _handle_file_drop(input_text: str, npc_team_dir: Path) -> Tuple[str, List[st
     
     if not file_paths:
 
-        return input_text, processed_files
+        return input_text, processed_files, file_paths
     
     modified_input = input_text
-    for file_path in file_paths:
-        expanded_path = Path(file_path.replace('~', str(Path.home()))).resolve()
-        
-        if expanded_path.exists() and expanded_path.is_file():
-            workspace_dirs = _get_workspace_dirs(npc_team_dir)
-            _ensure_workspace_dirs(workspace_dirs)
-            
-            ext = expanded_path.suffix[1:].upper() if expanded_path.suffix else "OTHERS"
-            category = EXTENSION_MAP.get(ext, "data_inputs")
-            target_dir = workspace_dirs.get(category, workspace_dirs["data_inputs"])
-            
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            new_filename = f"{timestamp}_{expanded_path.name}"
-            target_path = target_dir / new_filename
-            
-            try:
-                shutil.copy2(expanded_path, target_path)
-                processed_files.append(str(target_path))
-                modified_input = modified_input.replace(file_path, str(target_path))
-                print(f"📁 Copied {expanded_path.name} to workspace: {target_path}")
-            except Exception as e:
-                print(f"[ERROR] Failed to copy file: {e}")
-    
-    return modified_input, processed_files
+
+    return modified_input, processed_files, file_paths
 
 
 def _capture_plot_state(session_id: str, db_path: str, npc_team_dir: Path):
@@ -1125,19 +1118,22 @@ def _save_matplotlib_figures(npc_team_dir: Path) -> List[str]:
     
     return saved_figures
 
+import sys
+from io import StringIO
+from contextlib import redirect_stdout, redirect_stderr
 
-def _run_agentic_mode(command: str, 
-                      state: ShellState, 
-                      locals_dict: Dict[str, Any], 
+def _run_agentic_mode(command: str,
+                      state: ShellState,
+                      locals_dict: Dict[str, Any],
                       npc_team_dir: Path) -> Tuple[ShellState, Any]:
     """Run agentic mode with continuous iteration based on progress"""
-    max_iterations = 10  # Higher maximum as a safety limit
+    max_iterations = 3  # low maximum as a safety limit
     iteration = 0
     full_output = []
     current_command = command
     consecutive_failures = 0
-    max_consecutive_failures = 2
-    
+    max_consecutive_failures = 3
+
     # Build context of existing variables
     existing_vars_context = "EXISTING VARIABLES IN ENVIRONMENT:\n"
     for var_name, var_value in locals_dict.items():
@@ -1150,52 +1146,121 @@ def _run_agentic_mode(command: str,
                 existing_vars_context += f"- {var_name} ({var_type}): {var_repr}\n"
             except:
                 existing_vars_context += f"- {var_name} ({type(var_value).__name__}): <unrepresentable>\n"
-    
+    previous_code = ''
+    next_step = ''
+    steps = []
     while iteration < max_iterations and consecutive_failures < max_consecutive_failures:
         iteration += 1
         print(f"\n🔄 Agentic iteration {iteration}")
-        
+
         prompt = f"""
-        USER REQUEST: {current_command}
-        
+        USER REQUEST: {current_command} {next_step} 
+
+        Here is the existing variable context:
+
+        ```
         {existing_vars_context}
+        ```
+        PREVIOUS ATTEMPTS: ```{full_output[-1] if full_output else 'None'}```
+
+        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} `
+
         
-        PREVIOUS ATTEMPTS: {full_output[-1] if full_output else 'None'}
+        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.
+
+        Here are all the previous steps: {steps}
         
-        Generate Python code that BUILDS ON EXISTING VARIABLES to accomplish this task.
         DO NOT redefine variables that already exist unless absolutely necessary.
         Use the existing variables and add/modify as needed.
-        Be sure to generate logs and information  that oncne executed provide us with enough information to keep moving forward.
-        log variables and behaviors so we can pinpoint fixes clearly rather than getting stufck in nonsensical problematic loops.
-        
+        Be sure to generate logs and information  that once executed provide us with enough information to keep moving forward.
+        log variables and behaviors so we can pinpoint fixes clearly rather than getting stuck in nonsensical problematic loops.
         
         Provide ONLY executable Python code without any explanations or markdown formatting.
-        Focus on incremental changes rather than rewriting everything. Do not re-write any functions that are currently within the existing vars contxt or which appear to have no need to be changed.
+        Focus on incremental changes rather than rewriting everything. Do not re-write any functions that are currently within the existing vars context or which appear to have no need to be changed.
 
         Do not include any leading ```python. Begin directly with the code.
+        Do not write your code to include a __main__ check or portion unless the user asks.
+        These should be functional components and building blocks that you and the user will take and build a great
+        library of modules. Keep things straightforward and do not do unnecessary exception handling unless requested.
+        Failing fast in research is important and so it is necessary to  
+        No try except blocks unless requested.
+        Determine and log information in a way that helps us move forward rather than by exception handling.
+        Do not simply generate code that resembles the previous code. 
+        While this code may one day be `production` code with such error handling,
+        at the moment, we are simply in the business of experimentation.
+        Do not use the python `input()` function. if you have a question, ask directly by typing <request_for_input> request </request_for_input>        
+    
+        users may ask you to edit code directly. do this by loading the code in and evaluating it. once it is evaluated, you may attempt to write changes to it.
+
+        Always evaluate before attempting to fix. Read first. Gather information. Look at files. This will not be your final code, this is just part of 
+        an ongoing workflow. 
+
+
+        If a user is asking for help debugging, it's better to figure out what is wrong by attempting to run it yourself, and if they do not prefer that,
+        then it's best to use static parsing methods and arguments based on deduction rather than attempting to just fix everything over and over. 
+
+        Do not over-complicate the code.
+
+        Do not include any '__name__'=='__main__' block.
         """
+        #
         
-        llm_response = get_llm_response(prompt, 
-                                        npc=state.npc, 
-                                        stream=True)
-      
+        
+        llm_response = get_llm_response(prompt,
+                                        npc=state.npc,
+                                        stream=True,
+                                        messages=state.messages)
 
-        generated_code = print_and_process_stream_with_markdown(llm_response.get('response'),
-                                                                state.npc.model, 
-                                                                state.npc.provider, 
-                                                                show=True)
+        generated_code = print_and_process_stream(llm_response.get('response'),
+                                                  state.npc.model,
+                                                  state.npc.provider
+                                                  )
         
+
+        state.messages.append({'role':'user', 'content':current_command })
+        state.messages.append({'role':'assistant', 'content': generated_code})        
+
+        if '<request_for_input>' in generated_code:
+            generated_code = generated_code.split('>')[1].split('<')[0]
+            user_feedback = input("\n🤔 Agent requests feedback (press Enter to continue or type your input): ").strip()
+
+            current_command = f"{current_command} - User feedback: {user_feedback}"
+            max_iterations += int(max_iterations/2)
+
+            continue
+
         if generated_code.startswith('```python'):
             generated_code = generated_code[len('```python'):].strip()
         if generated_code.endswith('```'):
             generated_code = generated_code[:-3].strip()
         
-        print(f"\n# Generated Code (Iteration {iteration}):\n---\n{generated_code}\n---\n")
-        
+        #print(f"\n# Generated Code (Iteration {iteration}):\n---\n{generated_code}\n---\n")
+
         try:
-            state, exec_output = execute_python_code(generated_code, state, locals_dict)
-            full_output.append(f"Iteration {iteration}:\nCode:\n{generated_code}\nOutput:\n{exec_output}")
-            
+            # Capture stdout/stderr during execution
+            stdout_capture = StringIO()
+            stderr_capture = StringIO()
+
+            with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+                state, exec_output = execute_python_code(generated_code, 
+                                                         state, 
+                                                         locals_dict)
+
+            captured_stdout = stdout_capture.getvalue()
+            captured_stderr = stderr_capture.getvalue()
+            print(exec_output)
+
+            if captured_stdout:
+                print("\n📤 Captured stdout:\n", captured_stdout)
+            if captured_stderr:
+                print("\n❌ Captured stderr:\n", captured_stderr)
+
+            combined_output = f"{exec_output}\nstdout:\n{captured_stdout}\nstderr:\n{captured_stderr}"
+            full_output.append(f"Iteration {iteration}:\nCode:\n{generated_code}\nOutput:\n{combined_output}")
+
             # Update the context with new variables
             new_vars = []
             for var_name, var_value in locals_dict.items():
@@ -1203,66 +1268,82 @@ def _run_agentic_mode(command: str,
                     var_name not in existing_vars_context and 
                     var_name not in ['In', 'Out', 'exit', 'quit', 'get_ipython']):
                     new_vars.append(var_name)
-            
+
             if new_vars:
                 existing_vars_context += f"\nNEW VARIABLES CREATED: {', '.join(new_vars)}\n"
-            
+
             analysis_prompt = f"""
-            CODE EXECUTION RESULTS: {exec_output}
+            CODE EXECUTION RESULTS: {combined_output}
             
             EXISTING VARIABLES: {existing_vars_context}
+
+            EXECUTED_CODE: {generated_code}
+
+            PREVIOUS_CODE: {previous_code}
             
+            PREVIOUS ATTEMPTS: ```{full_output[-3:] if full_output else 'None'}```
+
+            Here are the steps so far: {steps}
+
             ANALYSIS: 
-            - Is there MEANINGFUL PROGRESS? Return 'progress' if making good progress
+            - Is there MEANINGFUL PROGRESS? Return 'progress' if making good progress. If the previous code and current executed code are essentially accomplishing the same thing, that is not progress. If the steps have been too similar or not improved, then consider it a problem.
             - Is there a PROBLEM? Return 'problem' if stuck or error occurred
-    
-            - Return ONLY one of these words followed by a brief explanation.
+            - Is there an ambiguity that should be resolved? Return 'question'.
+            - Is the analysis complete enough to get feedback from the user? If it's pretty much done, return 'complete'
+            - Return ONLY one of these words followed by a brief explanation to take the next step forward.
             """
-            
             analysis_response = get_llm_response(analysis_prompt,
-                                                 model=state.chat_model, 
-                                                 provider=state.chat_provider, 
-                                                 npc=state.npc, 
+                                                 npc=state.npc,
                                                  stream=False)
-            
+
             analysis = analysis_response.get("response", "").strip().lower()
-            print(f"\n# Analysis:\n{analysis}")
-            
+            next_step = analysis[8:]
+            state.messages.append({'role':'assistant', 'content':f'''- Is there MEANINGFUL PROGRESS? Is there a PROBLEM? Is there an ambiguity that should be resolved? 
+                            Indeed: {analysis}   '''})
+            print(f"\n# Analysis:\n{analysis}") 
+
+            previous_code = generated_code
+
             if analysis.startswith('complete'):
                 print("✅ Task completed successfully!")
                 break
+            if analysis.startswith('question'):
+                print('Please help answer')
+                break
             elif analysis.startswith('progress'):
                 consecutive_failures = 0  # Reset failure counter on progress
-                print("➡️  Making progress, continuing to next iteration...")
-                # Continue to next iteration
+                print("➡️ Making progress, continuing to next iteration...")
+                current_command = next_step
             elif analysis.startswith('problem'):
-                consecutive_failures += 1
-                print(f"⚠️  Problem detected ({consecutive_failures}/{max_consecutive_failures} consecutive failures)")
-                
-                user_feedback = input("\n🤔 Agent requests feedback (press Enter to continue or type your response): ").strip()
-                if user_feedback:
-                    current_command = f"{current_command} - User feedback: {user_feedback}"
-                elif consecutive_failures >= max_consecutive_failures:
-                    print("❌ Too many consecutive failures, stopping iteration")
-                    break
+
+                print(f"⚠️ Problem detected ({consecutive_failures}/{max_consecutive_failures} consecutive failures)")
+
+                current_command = f"{current_command} - PROBLEM in addressing it: {analysis}"
+                max_iterations += int(max_iterations/2)
+                continue
             else:
                 # Default behavior for unexpected responses
                 consecutive_failures += 1
                 print(f"❓ Unexpected analysis response, counting as failure ({consecutive_failures}/{max_consecutive_failures})")
-                
+                if consecutive_failures >= max_consecutive_failures:
+                    print("❌ Too many consecutive failures, stopping iteration.")
+                    break
+        except KeyboardInterrupt as e:
+            user_input = input('User input: ')
+            current_command = current_command+user_input
         except Exception as e:
             error_msg = f"Error in iteration {iteration}: {str(e)}"
             print(error_msg)
             full_output.append(error_msg)
             consecutive_failures += 1
             current_command = f"{current_command} - Error: {str(e)}"
-            
+
+
             if consecutive_failures >= max_consecutive_failures:
-                print("❌ Too many consecutive errors, stopping iteration")
+                print("❌ Too many consecutive errors, stopping iteration.")
                 break
-    
-    return state, "# Agentic execution completed\n" + '\n'.join(full_output)
 
+    return state, "# Agentic execution completed\n" + '\n'.join(full_output)
 
 def print_guac_bowl():
     bowl_art = """
@@ -1353,10 +1434,10 @@ def execute_guac_command(command: str, state: ShellState, locals_dict: Dict[str,
                 return state, f"Error loading file: {e}"
 
     # Handle file drops in text (multiple files or files with other text)
-    processed_command, processed_files = _handle_file_drop(stripped_command, npc_team_dir)
+    processed_command, processed_files, file_paths = _handle_file_drop(stripped_command, npc_team_dir)
     if processed_files:
         print(f"📁 Processed {len(processed_files)} files")
-        stripped_command = processed_command
+        stripped_command = processed_command + 'Here are the files associated with the request'
 
     # Handle /refresh command
     if stripped_command == "/refresh":
@@ -1416,7 +1497,6 @@ def execute_guac_command(command: str, state: ShellState, locals_dict: Dict[str,
             {locals_context_string}
             Begin directly with the code
             """
-    
         llm_response = get_llm_response(prompt_cmd, 
                                         model=state.chat_model, 
                                         provider=state.chat_provider, 
@@ -1485,12 +1565,196 @@ 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():
+            print(f"File not found: {path}")
+            return None
+        
+        if not path.is_file():
+            print(f"Not a file: {path}")
+            return None
+        
+        try:
+            # Try using npcpy's load_file_contents first for specialized formats
+            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)  # Large chunk to get full content
+                if chunks and not chunks[0].startswith("Error") and not chunks[0].startswith("Unsupported"):
+                    content = '\n'.join(chunks)
+                    lines = content.split('\n')
+                    
+                    if len(lines) > max_lines:
+                        lines = lines[:max_lines]
+                        print(f"File truncated at {max_lines} lines. Use windowed reading for larger files.")
+                    
+                    print(f"Reading {path.name} ({len(lines)} lines, {len(content)} chars)")
+                    print("=" * 60)
+                    
+                    for i, line in enumerate(lines, 1):
+                        print(f"{i:4d} | {line}")
+                    
+                    print("=" * 60)
+                    print(f"End of {path.name}")
+                    return content
+            
+            # Fall back to regular text reading
+            with open(path, 'r', encoding=encoding) as f:
+                lines = []
+                for i, line in enumerate(f, 1):
+                    if i > max_lines:
+                        print(f"File truncated at {max_lines} lines. Use windowed reading for larger files.")
+                        break
+                    lines.append(line.rstrip('\n\r'))
+            
+            content = '\n'.join(lines)
+            
+            print(f"Reading {path.name} ({len(lines)} lines, {len(content)} chars)")
+            print("=" * 60)
+            
+            for i, line in enumerate(lines, 1):
+                print(f"{i:4d} | {line}")
+            
+            print("=" * 60)
+            print(f"End of {path.name}")
+            
+            return content
+            
+        except UnicodeDecodeError:
+            try:
+                with open(path, 'rb') as f:
+                    data = f.read(min(1024, max_lines * 80))
+                print(f"Binary file {path.name} ({len(data)} bytes)")
+                print("=" * 60)
+                print(data.hex()[:1000] + ("..." if len(data) > 500 else ""))
+                print("=" * 60)
+                return data
+            except Exception as e:
+                print(f"Error reading file: {e}")
+                return None
+        except Exception as e:
+            print(f"Error reading file: {e}")
+            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()
+        
+        # Create parent directories if needed
+        path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Backup original if it exists
+        if backup and path.exists():
+            backup_path = path.with_suffix(path.suffix + '.backup')
+            import shutil
+            shutil.copy2(path, backup_path)
+            print(f"Backup saved: {backup_path.name}")
+        
+        try:
+            # Read existing content if file exists
+            existing_lines = []
+            if path.exists():
+                with open(path, 'r', encoding='utf-8') as f:
+                    existing_lines = [line.rstrip('\n\r') for line in f]
+            
+            if content is not None:
+                if append:
+                    with open(path, 'a', encoding='utf-8') as f:
+                        f.write('\n' + content if existing_lines else content)
+                    print(f"Appended to {path.name}")
+                else:
+                    with open(path, 'w', encoding='utf-8') as f:
+                        f.write(content)
+                    print(f"Wrote {path.name} ({len(content)} chars)")
+            
+            elif line_number is not None and new_line is not None:
+                if line_number < 1:
+                    print("Line numbers start at 1")
+                    return False
+                
+                while len(existing_lines) < line_number:
+                    existing_lines.append("")
+                
+                if line_number <= len(existing_lines):
+                    old_line = existing_lines[line_number - 1] if line_number <= len(existing_lines) else ""
+                    existing_lines[line_number - 1] = new_line
+                    
+                    with open(path, 'w', encoding='utf-8') as f:
+                        f.write('\n'.join(existing_lines))
+                    
+                    print(f"Line {line_number} in {path.name}:")
+                    print(f"  - OLD: {old_line}")
+                    print(f"  + NEW: {new_line}")
+                else:
+                    print(f"File only has {len(existing_lines)} lines")
+                    return False
+            
+            elif insert_at is not None and new_line is not None:
+                if insert_at < 1:
+                    insert_at = 1
+                
+                existing_lines.insert(insert_at - 1, new_line)
+                
+                with open(path, 'w', encoding='utf-8') as f:
+                    f.write('\n'.join(existing_lines))
+                
+                print(f"Inserted at line {insert_at} in {path.name}: {new_line}")
+            
+            else:
+                print("Must specify either 'content', or 'line_number + new_line', or 'insert_at + new_line'")
+                return False
+            
+            return True
+            
+        except Exception as e:
+            print(f"Error editing file: {e}")
+            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():
+            print(f"File not found: {path}")
+            return None
+        
+        chunks = load_file_contents(str(path))
+        if chunks and not chunks[0].startswith("Error") and not chunks[0].startswith("Unsupported"):
+            content = '\n'.join(chunks)
+            print(f"Loaded {path.name} using npcpy loader")
+            return content
+        else:
+            print(f"Could not load {path.name}: {chunks[0] if chunks else 'Unknown error'}")
+            return None
+                
     core_imports = {
         'pd': pd, 'np': np, 'plt': plt, 'datetime': datetime, 
         'Path': Path, 'os': os, 'sys': sys, 'json': json, 
-        'yaml': yaml, 're': re, 'traceback': traceback
+        'yaml': yaml, 're': re, 'traceback': traceback, 
+        'edit_file': edit_file, 
+        'read_file':read_file, 
+        'load_file':load_file,
     }
+
+
     locals_dict.update(core_imports)
     locals_dict.update({f"guac_{k}": v for k, v in workspace_dirs.items()})
     
@@ -1532,17 +1796,24 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
             
             process_result(user_input, state, result, state.command_history)
             
-        except (KeyboardInterrupt, EOFError):
+        except EOFError:
             print("\nExiting Guac Mode...")
+            try:
+                readline.write_history_file(READLINE_HISTORY_FILE)
+            except:
+                pass
             if _guac_monitor_stop_event:
                 _guac_monitor_stop_event.set()
             if _guac_monitor_thread:
                 _guac_monitor_thread.join(timeout=1.0)
             break
-
-            break
         except SystemExit as e:
+            try:
+                readline.write_history_file(READLINE_HISTORY_FILE)
+            except:
+                pass
             print(f"\n{e}")
+
             if _guac_monitor_stop_event:
                 _guac_monitor_stop_event.set()
             if _guac_monitor_thread:
@@ -1552,6 +1823,10 @@ def run_guac_repl(state: ShellState, project_name: str, package_root: Path, pack
         except Exception:
             print("An unexpected error occurred in the REPL:")
             traceback.print_exc()
+            try:
+                readline.write_history_file(READLINE_HISTORY_FILE)
+            except:
+                pass
 
             if _guac_monitor_stop_event:
                 _guac_monitor_stop_event.set()

{npcsh-1.0.20 → npcsh-1.0.21}/npcsh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.20
+Version: 1.0.21
 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.20 → npcsh-1.0.21}/setup.py

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