npcsh 1.0.28__py3-none-any.whl → 1.0.30__py3-none-any.whl

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,14 +1143,12 @@ 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,
                       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 = 5
     iteration = 0
     full_output = []
@@ -1180,6 +1156,37 @@ def _run_agentic_mode(command: str,
     consecutive_failures = 0
     max_consecutive_failures = 3 
 
+    if len(state.messages) > 15:
+        planning_state = {
+            "goal": "ongoing guac session", 
+            "facts": [f"Working in {state.current_path}", f"Variables: {list(locals_dict.keys())[:10]}"], 
+            "successes": [], 
+            "mistakes": [],
+            "todos": [],
+            "constraints": ["Focus on Python code execution", "Use existing variables when possible"]
+        }
+        compressed_state = state.npc.compress_planning_state(planning_state)
+        state.messages = [{"role": "system", "content": f"Session context: {compressed_state}"}]
+
+    existing_vars_context = "EXISTING VARIABLES IN ENVIRONMENT:\n"
+    for var_name, var_value in locals_dict.items():
+        if not var_name.startswith('_') and var_name not in ['In', 'Out', 'exit', 'quit', 'get_ipython']:
+            try:
+                var_type = type(var_value).__name__
+                var_repr = repr(var_value)
+                if len(var_repr) > 100:
+                    var_repr = var_repr[:97] + "..."
+                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{_get_guac_agent_emoji(consecutive_failures, max_consecutive_failures)} Agentic iteration {iteration} ")
+        
+        
   
     existing_vars_context = "EXISTING VARIABLES IN ENVIRONMENT:\n"
     for var_name, var_value in locals_dict.items():
@@ -1211,8 +1218,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 +1258,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 +1573,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 +1604,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 +1617,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 +1638,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 +1676,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 +1687,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 +1746,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 +1770,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 +1788,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 +1862,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 +1893,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 +1907,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/npcsh.py

@@ -68,22 +68,14 @@ Begin by asking a question, issuing a bash command, or typing '/help' for more i
         )
 
 
-
 def run_repl(command_history: CommandHistory, initial_state: ShellState):
-    
-
-    '''
-    Func for running the npcsh repl    
-    '''
     state = initial_state
     print_welcome_message()
 
-
     render_markdown(f'- Using {state.current_mode} mode. Use /agent, /cmd, or /chat to switch to other modes')
     render_markdown(f'- To switch to a different NPC, type /npc <npc_name> or /n <npc_name> to switch to that NPC.')
     render_markdown('\n- Here are the current NPCs available in your team: ' + ', '.join([npc_name for npc_name in state.team.npcs.keys()]))
 
-
     is_windows = platform.system().lower().startswith("win")
     try:
         completer = make_completer(state)
@@ -92,23 +84,16 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
         pass
     session_scopes = set()
 
-
     def exit_shell(current_state: ShellState):
-        """
-        On exit, iterates through all active scopes from the session and
-        creates/updates the specific knowledge graph for each one.
-        """
         print("\nGoodbye!")
         print(colored("Processing and archiving all session knowledge...", "cyan"))
         
         engine = command_history.engine
 
-
         for team_name, npc_name, path in session_scopes:
             try:
                 print(f"  -> Archiving knowledge for: T='{team_name}', N='{npc_name}', P='{path}'")
                 
-
                 convo_id = current_state.conversation_id
                 all_messages = command_history.get_conversations_by_id(convo_id)
                 
@@ -123,10 +108,8 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                     print("     ...No content for this scope, skipping.")
                     continue
 
-
                 current_kg = load_kg_from_db(engine, team_name, npc_name, path)
                 
-
                 evolved_kg, _ = kg_evolve_incremental(
                     existing_kg=current_kg,
                     new_content_text=full_text,
@@ -137,10 +120,8 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                     link_concepts_facts = True, 
                     link_concepts_concepts = True, 
                     link_facts_facts = True, 
-
                 )
                 
-              
                 save_kg_to_db(engine,
                               evolved_kg,
                               team_name, 
@@ -154,10 +135,20 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
 
         sys.exit(0)
 
-
-
     while True:
         try:
+            if len(state.messages) > 20:
+                planning_state = {
+                    "goal": "ongoing npcsh session", 
+                    "facts": [f"Working in {state.current_path}", f"Current mode: {state.current_mode}"], 
+                    "successes": [], 
+                    "mistakes": [],
+                    "todos": [],
+                    "constraints": ["Follow user requests", "Use appropriate mode for tasks"]
+                }
+                compressed_state = state.npc.compress_planning_state(planning_state)
+                state.messages = [{"role": "system", "content": f"Session context: {compressed_state}"}]
+
             try:
                 completer = make_completer(state)
                 readline.set_completer(completer)
@@ -198,6 +189,7 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
                     continue
                 else:
                     exit_shell(state)
+            
             team_name = state.team.name if state.team else "__none__"
             npc_name = state.npc.name if isinstance(state.npc, NPC) else "__none__"
             session_scopes.add((team_name, npc_name, state.current_path))
@@ -224,7 +216,8 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
             if is_windows and "EOF" in str(e).lower():
                 print("\nHint: On Windows, use Ctrl+Z then Enter for EOF, or type 'exit'")
                 continue
-            raise  # Re-raise if it's not the expected case
+            raise
+        
 
 def main() -> None:
     parser = argparse.ArgumentParser(description="npcsh - An NPC-powered shell.")