npcsh 1.0.36__tar.gz → 1.1.1__tar.gz

{npcsh-1.0.36 → npcsh-1.1.1}/PKG-INFO

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

@@ -2193,16 +2193,51 @@ def execute_command(
     state: ShellState,
     review = True, 
     router = None,
+    command_history = None,
     ) -> Tuple[ShellState, Any]:
 
     if not command.strip():
         return state, ""
+    
     mode_change, state = check_mode_switch(command, state)
     if mode_change:
         return state, 'Mode changed.'
 
+    npc_name = state.npc.name if isinstance(state.npc, NPC) else "__none__"
+    team_name = state.team.name if state.team else "__none__"
+    
+    if command_history:
+        relevant_memories = get_relevant_memories(
+            command_history=command_history,
+            npc_name=npc_name,
+            team_name=team_name,
+            path=state.current_path,
+            query=command,
+            max_memories=5,
+            state=state
+        )
+        print('Memory jogged...')
+        print(relevant_memories)
+        
+        if relevant_memories:
+            memory_context = "\n".join([
+                f"- {m.get('final_memory', '')}" 
+                for m in relevant_memories
+            ])
+            memory_msg = {
+                "role": "system",
+                "content": f"Relevant memories:\n{memory_context}"
+            }
+            if not state.messages or \
+               state.messages[0].get("role") != "system":
+                state.messages.insert(0, memory_msg)
+            else:
+                state.messages[0]["content"] += \
+                    f"\n\n{memory_msg['content']}"
+
     original_command_for_embedding = command
     commands = split_by_pipes(command)
+
     stdin_for_next = None
     final_output = None
     current_state = state 
@@ -2448,28 +2483,129 @@ def setup_shell() -> Tuple[CommandHistory, Team, Optional[NPC]]:
     team_name_from_ctx = team_ctx.get("name")
     if team_name_from_ctx:
         team.name = team_name_from_ctx
-    elif team_dir and os.path.basename(team_dir) != 'npc_team':
-        team.name = os.path.basename(team_dir)
+    elif team_dir:
+        normalized_dir = os.path.normpath(team_dir)
+        basename = os.path.basename(normalized_dir)
+        if basename and basename != 'npc_team':
+            team.name = basename
+        else:
+            team.name = "npcsh"
     else:
-        team.name = "global_team" 
+        team.name = "npcsh"
+
 
     return command_history, team, forenpc_obj
 
 
 
                 
-from npcpy.memory.memory_processor import MemoryApprovalQueue, MemoryItem, memory_approval_ui
+from npcpy.memory.memory_processor import  memory_approval_ui
 from npcpy.ft.memory_trainer import MemoryTrainer
 from npcpy.llm_funcs import get_facts
 
-_memory_queue = None
+def get_relevant_memories(
+    command_history: CommandHistory,
+    npc_name: str,
+    team_name: str,
+    path: str,
+    query: Optional[str] = None,
+    max_memories: int = 10,
+    state: Optional[ShellState] = None
+) -> List[Dict]:
+    
+    engine = command_history.engine
+    
+    all_memories = command_history.get_memories_for_scope(
+        npc=npc_name,
+        team=team_name,
+        directory_path=path,
+        status='human-approved'
+    )
+    
+    if not all_memories:
+        return []
+    
+    if len(all_memories) <= max_memories and not query:
+        return all_memories
+    
+    if query:
+        query_lower = query.lower()
+        keyword_matches = [
+            m for m in all_memories 
+            if query_lower in (m.get('final_memory') or m.get('initial_memory') or '').lower()
+        ]
+        
+        if keyword_matches:
+            return keyword_matches[:max_memories]
+
+    if state and state.embedding_model and state.embedding_provider:
+        try:
+            from npcpy.gen.embeddings import get_embeddings
+            
+            search_text = query if query else "recent context"
+            query_embedding = get_embeddings(
+                [search_text],
+                state.embedding_model,
+                state.embedding_provider
+            )[0]
+            
+            memory_texts = [
+                m.get('final_memory', '') for m in all_memories
+            ]
+            memory_embeddings = get_embeddings(
+                memory_texts,
+                state.embedding_model,
+                state.embedding_provider
+            )
+            
+            import numpy as np
+            similarities = []
+            for mem_emb in memory_embeddings:
+                similarity = np.dot(query_embedding, mem_emb) / (
+                    np.linalg.norm(query_embedding) * 
+                    np.linalg.norm(mem_emb)
+                )
+                similarities.append(similarity)
+            
+            sorted_indices = np.argsort(similarities)[::-1]
+            return [all_memories[i] for i in sorted_indices[:max_memories]]
+            
+        except Exception as e:
+            print(colored(
+                f"RAG search failed, using recent: {e}", 
+                "yellow"
+            ))
+    
+    return all_memories[-max_memories:]
+
 
-def get_memory_queue(command_history):
-    global _memory_queue
-    if _memory_queue is None:
-        _memory_queue = MemoryApprovalQueue(command_history)
-        _memory_queue.start_background_processing()
-    return _memory_queue
+def search_kg_facts(
+    self,
+    npc: str,
+    team: str,
+    directory_path: str,
+    query: str
+) -> List[Dict]:
+    
+    kg = load_kg_from_db(
+        self.engine, 
+        team, 
+        npc, 
+        directory_path
+    )
+    
+    if not kg or 'facts' not in kg:
+        return []
+    
+    query_lower = query.lower()
+    matching_facts = []
+    
+    for fact in kg['facts']:
+        statement = fact.get('statement', '').lower()
+        if query_lower in statement:
+            matching_facts.append(fact)
+    
+    return matching_facts
 
 def format_memory_context(memory_examples):
     if not memory_examples:
@@ -2556,8 +2692,8 @@ def process_result(
     output: Any,
     command_history: CommandHistory,
 ):
-    team_name = result_state.team.name if result_state.team else "__none__"
-    npc_name = result_state.npc.name if isinstance(result_state.npc, NPC) else "__none__"
+    team_name = result_state.team.name if result_state.team else "npcsh"
+    npc_name = result_state.npc.name if isinstance(result_state.npc, NPC) else "npcsh"
     
     active_npc = result_state.npc if isinstance(result_state.npc, NPC) else NPC(
         name="default", 
@@ -2637,7 +2773,7 @@ def process_result(
                 model=active_npc.model,
                 provider=active_npc.provider,
                 npc=active_npc,
-                context=memory_context
+                context=memory_context + 'Memories should be fully self contained. They should not use vague pronouns or words like that or this or it.  Do not generate more than 1-2 memories at a time.'
             )
             
             if facts:

{npcsh-1.0.36 → npcsh-1.1.1}/npcsh/corca.py

@@ -396,8 +396,8 @@ def execute_command_corca(command: str, state: ShellState, command_history, sele
         cprint("Warning: Corca agent has no tools. No MCP server connected.", "yellow", file=sys.stderr)
 
     if len(state.messages) > 20:
-        compressed_state = state.npc.compress_planning_state(messages)
-        state.messages = [{"role": "system", "content": state.npc.get_system_message() + f' Your current task: {compressed_state}'}]
+        compressed_state = state.npc.compress_planning_state(state.messages)
+        state.messages = [{"role": "system", "content": state.npc.get_system_prompt() + f' Your current task: {compressed_state}'}]
         print("Compressed messages during tool execution.")
     
     response_dict = get_llm_response_with_handling(
@@ -640,27 +640,28 @@ def _resolve_and_copy_mcp_server_path(
             
     cprint("No MCP server script found in any expected location.", "yellow")
     return None
-
-
 def print_corca_welcome_message():
     turq = "\033[38;2;64;224;208m"
     chrome = "\033[38;2;211;211;211m"
+    orange = "\033[38;2;255;165;0m"
     reset = "\033[0m"
     
     print(
         f"""
-Welcome to {turq}C{chrome}o{turq}r{chrome}c{turq}a{reset}!
-{turq}       {turq}       {turq}      {chrome}      {chrome}     
-{turq}   ____ {turq}  ___  {turq} ____ {chrome}  ____  {chrome} __ _ 
-{turq}  /  __|{turq} / _ \\ {turq}|  __\\{chrome} /  __| {chrome}/ _` |
-{turq} |  |__ {turq}| (_) |{turq}| |   {chrome}|  |__{chrome} | (_| |
-{turq}  \\____| {turq}\\___/ {turq}| |    {chrome}\\____| {chrome}\\__,_|
-{turq}       {turq}            {turq}        {chrome}      {chrome}                      
-{reset}
-An MCP-powered shell for advanced agentic workflows.
+{turq} ██████    ██████    ██████    ██████    ██████{reset}
+{turq}██    ██  ██    ██  ██    ██  ██    ██  ██🦌🦌██{reset}
+{turq}██        ██    ██  ██    ██  ██        ██🦌🦌██{reset}
+{chrome}██        ██    ██  ████████  ██        ████████{reset}
+{chrome}██        ██    ██  ██  ███   ██        ██    ██{reset}
+{chrome}██    ██  ██    ██  ██   ███  ██    ██  ██    ██{reset}
+{orange} ██████    ██████   ██    ███  ███████  ██    ██{reset}
+
+{chrome}                🦌 C O R C A 🦌{reset}
+                        
+    {turq}MCP-powered shell for agentic workflows{reset}
         """
-    )
-
+    )    
+    
 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

{npcsh-1.0.36 → npcsh-1.1.1}/npcsh/mcp_server.py

@@ -14,6 +14,7 @@ from typing import Optional, Dict, Any, List, Union, Callable
 from mcp.server.fastmcp import FastMCP
 import importlib
 
+from sqlalchemy import text
 
 
 import os
@@ -46,14 +47,129 @@ mcp = FastMCP("npcsh_mcp")
 DEFAULT_WORKSPACE = os.path.join(os.getcwd(), "workspace")
 os.makedirs(DEFAULT_WORKSPACE, exist_ok=True)
 
+@mcp.tool()
+async def add_memory(
+    npc_name: str,
+    team_name: str,
+    content: str,
+    memory_type: str = "observation",
+    directory_path: str = None
+) -> str:
+    """
+    Add a memory entry to the database.
+    
+    Args:
+        npc_name: Name of the NPC this memory belongs to
+        team_name: Name of the team the NPC belongs to
+        content: The memory content to store
+        memory_type: Type of memory (observation, preference, achievement, etc.)
+        directory_path: Directory path context (defaults to current working directory)
+        
+    Returns:
+        Success message with memory ID or error message
+    """
+    if directory_path is None:
+        directory_path = os.getcwd()
+    
+    try:
+        from npcpy.memory.command_history import generate_message_id
+        message_id = generate_message_id()
+        
+        memory_id = command_history.add_memory_to_database(
+            message_id=message_id,
+            conversation_id='mcp_direct',
+            npc=npc_name,
+            team=team_name,
+            directory_path=directory_path,
+            initial_memory=content,
+            status='active',
+            model=None,
+            provider=None
+        )
+        return f"Memory created successfully with ID: {memory_id}"
+    except Exception as e:
+        return f"Error creating memory: {str(e)}"
 
 @mcp.tool()
-async def run_server_command(command: str) -> str:
+async def search_memory(
+    query: str,
+    npc_name: str = None,
+    team_name: str = None,
+    directory_path: str = None,
+    status_filter: str = None,
+    limit: int = 10
+) -> str:
+    """
+    Search memories in the database.
+    
+    Args:
+        query: Search query text
+        npc_name: Filter by specific NPC (optional)
+        team_name: Filter by specific team (optional)
+        directory_path: Filter by directory path (optional)
+        status_filter: Filter by memory status (active, archived, etc.)
+        limit: Maximum number of results to return
+        
+    Returns:
+        JSON string of matching memories or error message
+    """
+    if directory_path is None:
+        directory_path = os.getcwd()
+    
+    try:
+        results = command_history.search_memory(
+            query=query,
+            npc=npc_name,
+            team=team_name,
+            directory_path=directory_path,
+            status_filter=status_filter,
+            limit=limit
+        )
+        return json.dumps(results, indent=2)
+    except Exception as e:
+        return f"Error searching memories: {str(e)}"
+
+@mcp.tool()
+async def query_npcsh_database(sql_query: str) -> str:
+    """
+    Execute a SQL query against the npcsh_history.db database.
+    
+    Args:
+        sql_query: SQL query to execute (SELECT statements only for safety)
+        
+    Returns:
+        JSON string of query results or error message
+    """
+    # Safety check - only allow SELECT queries
+    if not sql_query.strip().upper().startswith('SELECT'):
+        return "Error: Only SELECT queries are allowed for safety"
+    
+    try:
+        with command_history.engine.connect() as conn:
+            result = conn.execute(text(sql_query))
+            rows = result.fetchall()
+            
+            if not rows:
+                return "Query executed successfully but returned no results"
+            
+            # Convert to list of dictionaries
+            columns = result.keys()
+            results = []
+            for row in rows:
+                row_dict = dict(zip(columns, row))
+                results.append(row_dict)
+            
+            return json.dumps(results, indent=2, default=str)
+    except Exception as e:
+        return f"Database query error: {str(e)}"
+@mcp.tool()
+async def run_server_command(command: str, wd: str) -> str:
     """
     Run a terminal command in the workspace.
     
     Args:
         command: The shell command to run
+        wd: The working directory to run the command in
         
     Returns:
         The command output or an error message.
@@ -61,7 +177,7 @@ async def run_server_command(command: str) -> str:
     try:
         result = subprocess.run(
             command, 
-            cwd=DEFAULT_WORKSPACE, 
+            cwd=wd,
             shell=True, 
             capture_output=True, 
             text=True,
@@ -147,11 +263,7 @@ print("Loading tools from npcpy modules...")
 
 
 def register_selected_npcpy_tools():
-    tools = [generate_group_candidates, 
-             abstract, 
-             extract_facts, 
-             zoom_in, 
-             execute_llm_command, 
+    tools = [              
              gen_image, 
              load_file_contents, 
              capture_screenshot, 

{npcsh-1.0.36 → npcsh-1.1.1}/npcsh/npc_team/corca.npc

@@ -9,5 +9,4 @@ primary_directive: |
     You must distinguish carefully and when in doubt, opt to ask for further
     information or clarification with concrete clear options that make it
     easy for a user to choose.
-model: gpt-4o-mini
-provider: openai
+    

npcsh-1.1.1/npcsh/npc_team/jinxs/kg_search.jinx

@@ -0,0 +1,43 @@
+jinx_name: search_kg
+description: Search knowledge graph for relevant facts
+inputs:
+  - query
+steps:
+  - name: retrieve_facts
+    engine: python
+    code: |
+      from npcpy.memory.command_history import load_kg_from_db
+      import os
+      
+      kg = load_kg_from_db(
+          command_history.engine,
+          team.name if team else '__none__',
+          npc.name if hasattr(npc, 'name') else '__none__',
+          os.getcwd()
+      )
+      
+      query_lower = '{{ query }}'.lower()
+      matching_facts = []
+      
+      if kg and 'facts' in kg:
+          for fact in kg['facts']:
+              statement = fact.get('statement', '').lower()
+              if query_lower in statement:
+                  matching_facts.append(fact)
+      
+      output = []
+      for i, fact in enumerate(matching_facts[:10], 1):
+          statement = fact.get('statement', '')
+          fact_type = fact.get('type', 'unknown')
+          output.append(f"{i}. [{fact_type}] {statement}")
+      
+      output = "\n".join(output) if output else "No facts found"
+  
+  - name: analyze_facts
+    engine: natural
+    code: |
+      Knowledge graph facts for query "{{ query }}":
+      
+      {{ retrieve_facts }}
+      
+      Analyze how these facts relate to the query.

npcsh-1.1.1/npcsh/npc_team/jinxs/memory_search.jinx

@@ -0,0 +1,36 @@
+jinx_name: search_memories
+description: Search through approved memories for relevant context
+inputs:
+  - query
+steps:
+  - name: retrieve_memories
+    engine: python
+    code: |
+      from npcsh._state import get_relevant_memories
+      import os
+      
+      memories = get_relevant_memories(
+          command_history=command_history,
+          npc_name=npc.name if hasattr(npc, 'name') else '__none__',
+          team_name=team.name if team else '__none__',
+          path=os.getcwd(),
+          query='{{ query }}',
+          max_memories=10,
+          state=state
+      )
+      
+      output = []
+      for i, mem in enumerate(memories, 1):
+          content = mem.get('final_memory', mem.get('initial_memory', ''))
+          output.append(f"{i}. {content}")
+      
+      output = "\n".join(output) if output else "No memories found"
+  
+  - name: format_results
+    engine: natural
+    code: |
+      Found memories for query "{{ query }}":
+      
+      {{ retrieve_memories }}
+      
+      Summarize the key points from these memories.

{npcsh-1.0.36 → npcsh-1.1.1}/npcsh/npcsh.py

@@ -52,15 +52,22 @@ def print_welcome_message():
 
     print(
             """
+___________________________________________          
+___________________________________________
+___________________________________________
+
 Welcome to \033[1;94mnpc\033[0m\033[1;38;5;202msh\033[0m!
 \033[1;94m                    \033[0m\033[1;38;5;202m        _       \\\\
 \033[1;94m _ __   _ __    ___ \033[0m\033[1;38;5;202m  ___  | |___    \\\\
-\033[1;94m| '_ \\ | '  \\  / __|\033[0m\033[1;38;5;202m / __/ | |_ _|    \\\\
+\033[1;94m| '_ \\ | '_ \\  / __|\033[0m\033[1;38;5;202m / __/ | |_ _|    \\\\
 \033[1;94m| | | || |_) |( |__ \033[0m\033[1;38;5;202m \\_  \\ | | | |    //
 \033[1;94m|_| |_|| .__/  \\___|\033[0m\033[1;38;5;202m |___/ |_| |_|   //
-       \033[1;94m| |          \033[0m\033[1;38;5;202m                //
-       \033[1;94m| |
-       \033[1;94m|_|
+       \033[1;94m|🤖|          \033[0m\033[1;38;5;202m               //
+       \033[1;94m|🤖|
+       \033[1;94m|🤖|
+___________________________________________
+___________________________________________
+___________________________________________
 
 Begin by asking a question, issuing a bash command, or typing '/help' for more information.
 
@@ -197,7 +204,9 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
             state, output = execute_command(user_input, 
                                             state, 
                                             review = True, 
-                                            router=router)
+                                            router=router, 
+                                            command_history=command_history)
+
             process_result(user_input, 
                            state, 
                            output, 

{npcsh-1.0.36 → npcsh-1.1.1}/npcsh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.36
+Version: 1.1.1
 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.36 → npcsh-1.1.1}/npcsh.egg-info/SOURCES.txt

@@ -46,5 +46,7 @@ npcsh/npc_team/jinxs/bash_executer.jinx
 npcsh/npc_team/jinxs/edit_file.jinx
 npcsh/npc_team/jinxs/image_generation.jinx
 npcsh/npc_team/jinxs/internet_search.jinx
+npcsh/npc_team/jinxs/kg_search.jinx
+npcsh/npc_team/jinxs/memory_search.jinx
 npcsh/npc_team/jinxs/python_executor.jinx
 npcsh/npc_team/jinxs/screen_cap.jinx

{npcsh-1.0.36 → npcsh-1.1.1}/setup.py

@@ -78,7 +78,7 @@ extra_files = package_files("npcsh/npc_team/")
 
 setup(
     name="npcsh",
-    version="1.0.36",
+    version="1.1.1",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  # Only install base requirements by default
     extras_require={
@@ -96,7 +96,7 @@ setup(
             "pti=npcsh.pti:main",
             "guac=npcsh.guac:main",
             "wander=npcsh.wander:main",
-            "spool=npcsh.spool:main",
+            "spool=npcsh.spool:main", 
         ],
     },
     author="Christopher Agostino",