npcsh 1.0.37__tar.gz → 1.1.2__tar.gz

{npcsh-1.0.37 → npcsh-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.0.37
+Version: 1.1.2
 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.37 → npcsh-1.1.2}/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,10 +2483,16 @@ 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
 
@@ -2462,6 +2503,109 @@ from npcpy.memory.memory_processor import  memory_approval_ui
 from npcpy.ft.memory_trainer import MemoryTrainer
 from npcpy.llm_funcs import get_facts
 
+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 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:
@@ -2548,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", 
@@ -2611,106 +2755,155 @@ def process_result(
             team=team_name,
         )
 
-        conversation_turn_text = f"User: {user_input}\nAssistant: {final_output_str}"
-        engine = command_history.engine
+        result_state.turn_count += 1
 
-        memory_examples = command_history.get_memory_examples_for_context(
-            npc=npc_name,
-            team=team_name, 
-            directory_path=result_state.current_path
-        )
-        
-        memory_context = format_memory_context(memory_examples)
-        
-        approved_facts = []
-        try:
-            facts = get_facts(
-                conversation_turn_text,
-                model=active_npc.model,
-                provider=active_npc.provider,
-                npc=active_npc,
-                context=memory_context
+        if result_state.turn_count % 10 == 0:
+            approved_facts = []
+            
+            conversation_turn_text = f"User: {user_input}\nAssistant: {final_output_str}"
+            engine = command_history.engine
+
+            memory_examples = command_history.get_memory_examples_for_context(
+                npc=npc_name,
+                team=team_name, 
+                directory_path=result_state.current_path
             )
             
-            if facts:
-                memories_for_approval = []
-                for i, fact in enumerate(facts):
-                    memories_for_approval.append({
-                        "memory_id": f"temp_{i}",
-                        "content": fact['statement'],
-                        "context": f"Type: {fact.get('type', 'unknown')}, Source: {fact.get('source_text', '')}",
-                        "npc": npc_name,
-                        "fact_data": fact
-                    })
-                
-                approvals = memory_approval_ui(memories_for_approval)
+            memory_context = format_memory_context(memory_examples)
+            
+            try:
+                facts = get_facts(
+                    conversation_turn_text,
+                    model=active_npc.model,
+                    provider=active_npc.provider,
+                    npc=active_npc,
+                    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.'
+                )
                 
-                for approval in approvals:
-                    fact_data = next(m['fact_data'] for m in memories_for_approval 
-                                   if m['memory_id'] == approval['memory_id'])
+                if facts:
+                    num_memories = len(facts)
+                    print(colored(
+                        f"\nThere are {num_memories} potential memories. Do you want to review them now?", 
+                        "cyan"
+                    ))
+                    review_choice = input("[y/N]: ").strip().lower()
                     
-                    command_history.add_memory_to_database(
-                        message_id=f"{result_state.conversation_id}_{len(result_state.messages)}",
-                        conversation_id=result_state.conversation_id,
-                        npc=npc_name,
-                        team=team_name,
-                        directory_path=result_state.current_path,
-                        initial_memory=fact_data['statement'],
-                        status=approval['decision'],
-                        model=active_npc.model,
-                        provider=active_npc.provider,
-                        final_memory=approval.get('final_memory')
-                    )
+                    if review_choice == 'y':
+                        memories_for_approval = []
+                        for i, fact in enumerate(facts):
+                            memories_for_approval.append({
+                                "memory_id": f"temp_{i}",
+                                "content": fact['statement'],
+                                "context": f"Type: {fact.get('type', 'unknown')}, Source: {fact.get('source_text', '')}",
+                                "npc": npc_name,
+                                "fact_data": fact
+                            })
+                        
+                        approvals = memory_approval_ui(memories_for_approval)
+                        
+                        for approval in approvals:
+                            fact_data = next(
+                                m['fact_data'] for m in memories_for_approval 
+                                if m['memory_id'] == approval['memory_id']
+                            )
+                            
+                            command_history.add_memory_to_database(
+                                message_id=f"{result_state.conversation_id}_{len(result_state.messages)}",
+                                conversation_id=result_state.conversation_id,
+                                npc=npc_name,
+                                team=team_name,
+                                directory_path=result_state.current_path,
+                                initial_memory=fact_data['statement'],
+                                status=approval['decision'],
+                                model=active_npc.model,
+                                provider=active_npc.provider,
+                                final_memory=approval.get('final_memory')
+                            )
+                            
+                            if approval['decision'] in ['human-approved', 'human-edited']:
+                                approved_fact = {
+                                    'statement': approval.get('final_memory') or fact_data['statement'],
+                                    'source_text': fact_data.get('source_text', ''),
+                                    'type': fact_data.get('type', 'explicit'),
+                                    'generation': 0
+                                }
+                                approved_facts.append(approved_fact)
+                    else:
+                        for i, fact in enumerate(facts):
+                            command_history.add_memory_to_database(
+                                message_id=f"{result_state.conversation_id}_{len(result_state.messages)}",
+                                conversation_id=result_state.conversation_id,
+                                npc=npc_name,
+                                team=team_name,
+                                directory_path=result_state.current_path,
+                                initial_memory=fact['statement'],
+                                status='skipped',
+                                model=active_npc.model,
+                                provider=active_npc.provider,
+                                final_memory=None
+                            )
+                        
+                        print(colored(
+                            f"Marked {num_memories} memories as skipped.", 
+                            "yellow"
+                        ))
                     
-                    if approval['decision'] in ['human-approved', 'human-edited']:
-                        approved_fact = {
-                            'statement': approval.get('final_memory') or fact_data['statement'],
-                            'source_text': fact_data.get('source_text', ''),
-                            'type': fact_data.get('type', 'explicit'),
-                            'generation': 0
-                        }
-                        approved_facts.append(approved_fact)
-                
-        except Exception as e:
-            print(colored(f"Memory generation error: {e}", "yellow"))
-
-        if result_state.build_kg and approved_facts:
-            try:
-                if not should_skip_kg_processing(user_input, final_output_str):
-                    npc_kg = load_kg_from_db(engine, team_name, npc_name, result_state.current_path)
-                    evolved_npc_kg, _ = kg_evolve_incremental(
-                        existing_kg=npc_kg, 
-                        new_facts=approved_facts,
-                        model=active_npc.model, 
-                        provider=active_npc.provider, 
-                        npc=active_npc,
-                        get_concepts=True,
-                        link_concepts_facts=False, 
-                        link_concepts_concepts=False, 
-                        link_facts_facts=False,                         
-                    )
-                    save_kg_to_db(
-                        engine,
-                        evolved_npc_kg, 
-                        team_name, 
-                        npc_name, 
-                        result_state.current_path
-                    )
             except Exception as e:
-                print(colored(f"Error during real-time KG evolution: {e}", "red"))
+                print(colored(f"Memory generation error: {e}", "yellow"))
 
-        result_state.turn_count += 1
-
-        if result_state.turn_count % 10 == 0:
-            print(colored("\nChecking for potential team improvements...", "cyan"))
+            if result_state.build_kg and approved_facts:
+                try:
+                    if not should_skip_kg_processing(user_input, final_output_str):
+                        npc_kg = load_kg_from_db(
+                            engine, 
+                            team_name, 
+                            npc_name, 
+                            result_state.current_path
+                        )
+                        evolved_npc_kg, _ = kg_evolve_incremental(
+                            existing_kg=npc_kg, 
+                            new_facts=approved_facts,
+                            model=active_npc.model, 
+                            provider=active_npc.provider, 
+                            npc=active_npc,
+                            get_concepts=True,
+                            link_concepts_facts=False, 
+                            link_concepts_concepts=False, 
+                            link_facts_facts=False,                         
+                        )
+                        save_kg_to_db(
+                            engine,
+                            evolved_npc_kg, 
+                            team_name, 
+                            npc_name, 
+                            result_state.current_path
+                        )
+                except Exception as e:
+                    print(colored(
+                        f"Error during real-time KG evolution: {e}", 
+                        "red"
+                    ))
+
+            print(colored(
+                "\nChecking for potential team improvements...", 
+                "cyan"
+            ))
             try:
-                summary = breathe(messages=result_state.messages[-20:], npc=active_npc)
+                summary = breathe(
+                    messages=result_state.messages[-20:], 
+                    npc=active_npc
+                )
                 characterization = summary.get('output')
 
                 if characterization and result_state.team:
-                    team_ctx_path = get_team_ctx_path(result_state.team.team_path)
+                    team_ctx_path = get_team_ctx_path(
+                        result_state.team.team_path
+                    )
                     if not team_ctx_path:
-                        team_ctx_path = os.path.join(result_state.team.team_path, "team.ctx")
+                        team_ctx_path = os.path.join(
+                            result_state.team.team_path, 
+                            "team.ctx"
+                        )
                     
                     ctx_data = {}
                     if os.path.exists(team_ctx_path):
@@ -2735,11 +2928,20 @@ def process_result(
                     suggestion = response.get("response", {}).get("suggestion")
 
                     if suggestion:
-                        new_context = (current_context + " " + suggestion).strip()
-                        print(colored(f"{npc_name} suggests updating team context:", "yellow"))
-                        print(f"  - OLD: {current_context}\n  + NEW: {new_context}")
+                        new_context = (
+                            current_context + " " + suggestion
+                        ).strip()
+                        print(colored(
+                            f"{npc_name} suggests updating team context:", 
+                            "yellow"
+                        ))
+                        print(
+                            f"  - OLD: {current_context}\n  + NEW: {new_context}"
+                        )
                         
-                        choice = input("Apply? [y/N/e(dit)]: ").strip().lower()
+                        choice = input(
+                            "Apply? [y/N/e(dit)]: "
+                        ).strip().lower()
                         
                         if choice == 'y':
                             ctx_data['context'] = new_context
@@ -2747,21 +2949,29 @@ def process_result(
                                 yaml.dump(ctx_data, f)
                             print(colored("Team context updated.", "green"))
                         elif choice == 'e':
-                            edited_context = input(f"Edit context [{new_context}]: ").strip()
+                            edited_context = input(
+                                f"Edit context [{new_context}]: "
+                            ).strip()
                             if edited_context:
                                 ctx_data['context'] = edited_context
                             else:
                                 ctx_data['context'] = new_context
                             with open(team_ctx_path, 'w') as f:
                                 yaml.dump(ctx_data, f)
-                            print(colored("Team context updated with edits.", "green"))
+                            print(colored(
+                                "Team context updated with edits.", 
+                                "green"
+                            ))
                         else:
                             print("Suggestion declined.")
             except Exception as e:
                 import traceback
-                print(colored(f"Could not generate team suggestions: {e}", "yellow"))
+                print(colored(
+                    f"Could not generate team suggestions: {e}", 
+                    "yellow"
+                ))
                 traceback.print_exc()
-                                                
+                
 initial_state = ShellState(
     conversation_id=start_new_conversation(),
     stream_output=NPCSH_STREAM_OUTPUT,

{npcsh-1.0.37 → npcsh-1.1.2}/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.37 → npcsh-1.1.2}/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.2/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.2/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.37 → npcsh-1.1.2}/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.37 → npcsh-1.1.2}/npcsh.egg-info/PKG-INFO

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

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