npcsh 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

npcsh/_state.py

@@ -645,7 +645,6 @@ BASH_COMMANDS = [
     "fg",
     "getopts",
     "hash",
-    "help",
     "history",
     "if",
     "jobs",
@@ -2206,34 +2205,6 @@ def execute_command(
     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)
@@ -2755,106 +2726,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 + '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 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.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"
+                    ))
 
-        if result_state.turn_count % 10 == 0:
-            print(colored("\nChecking for potential team improvements...", "cyan"))
+            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):
@@ -2879,11 +2899,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
@@ -2891,21 +2920,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/alicanto.py

@@ -12,6 +12,16 @@ from dataclasses import dataclass, asdict, field
 from pathlib import Path
 from concurrent.futures import ThreadPoolExecutor
 
+
+try:
+    from datasets import load_dataset
+except:
+    load_dataset = None
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+
+
 from npcpy.tools import auto_tools
 from npcpy.llm_funcs import get_llm_response
 from npcpy.data.web import search_web
@@ -88,11 +98,6 @@ def list_files(directory: str = ".") -> List[str]:
     return os.listdir(directory)
 
 
-
-from datasets import load_dataset
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-
 DATASET_CACHE = None
 SEARCH_INDEX = None
 

npcsh/build.py

@@ -0,0 +1,291 @@
+import os
+import shutil
+import textwrap
+from pathlib import Path
+
+
+def build_flask_server(config, **kwargs):
+    output_dir = Path(config['output_dir'])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    server_script = output_dir / 'npc_server.py'
+    
+    server_code = textwrap.dedent(f'''
+    import os
+    from npcpy.serve import start_flask_server
+    from npcpy.npc_compiler import Team
+    from sqlalchemy import create_engine
+    
+    if __name__ == "__main__":
+        team_path = os.path.join(
+            os.path.dirname(__file__), 
+            "npc_team"
+        )
+        db_path = os.path.expanduser("~/npcsh_history.db")
+        
+        db_conn = create_engine(f'sqlite:///{{db_path}}')
+        team = Team(team_path=team_path, db_conn=db_conn)
+        
+        start_flask_server(
+            port={config['port']},
+            cors_origins={config.get('cors_origins')},
+            teams={{"main": team}},
+            npcs=team.npcs,
+            db_path=db_path,
+            user_npc_directory=os.path.expanduser(
+                "~/.npcsh/npc_team"
+            )
+        )
+    ''')
+    
+    server_script.write_text(server_code)
+    
+    shutil.copytree(
+        config['team_path'], 
+        output_dir / 'npc_team',
+        dirs_exist_ok=True
+    )
+    
+    requirements = output_dir / 'requirements.txt'
+    requirements.write_text(
+        'npcsh\n'
+        'flask\n'
+        'flask-cors\n'
+        'sqlalchemy\n'
+    )
+    
+    readme = output_dir / 'README.md'
+    readme.write_text(textwrap.dedent(f'''
+    # NPC Team Server
+    
+    Run: python npc_server.py
+    
+    Server will be available at http://localhost:{config['port']}
+    
+    For pyinstaller standalone:
+    pyinstaller --onefile npc_server.py
+    '''))
+    
+    return {
+        "output": f"Flask server built in {output_dir}", 
+        "messages": kwargs.get('messages', [])
+    }
+
+
+def build_docker_compose(config, **kwargs):
+    output_dir = Path(config['output_dir'])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    shutil.copytree(
+        config['team_path'], 
+        output_dir / 'npc_team',
+        dirs_exist_ok=True
+    )
+    
+    dockerfile = output_dir / 'Dockerfile'
+    dockerfile.write_text(textwrap.dedent('''
+    FROM python:3.11-slim
+    
+    WORKDIR /app
+    
+    COPY requirements.txt .
+    RUN pip install --no-cache-dir -r requirements.txt
+    
+    COPY npc_team ./npc_team
+    COPY npc_server.py .
+    
+    EXPOSE 5337
+    
+    CMD ["python", "npc_server.py"]
+    '''))
+    
+    compose = output_dir / 'docker-compose.yml'
+    compose.write_text(textwrap.dedent(f'''
+    version: '3.8'
+    
+    services:
+      npc-server:
+        build: .
+        ports:
+          - "{config['port']}:{config['port']}"
+        volumes:
+          - npc-data:/root/.npcsh
+        environment:
+          - NPCSH_DB_PATH=/root/.npcsh/npcsh_history.db
+    
+    volumes:
+      npc-data:
+    '''))
+    
+    build_flask_server(config, **kwargs)
+    
+    return {
+        "output": f"Docker compose built in {output_dir}. Run: docker-compose up", 
+        "messages": kwargs.get('messages', [])
+    }
+
+
+def build_cli_executable(config, **kwargs):
+    output_dir = Path(config['output_dir'])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    cli_script = output_dir / 'npc_cli.py'
+    
+    cli_code = textwrap.dedent('''
+    import sys
+    from npcsh._state import setup_shell, execute_command, initial_state
+    from npcsh.routes import router
+    
+    def main():
+        if len(sys.argv) < 2:
+            print("Usage: npc_cli <command>")
+            sys.exit(1)
+        
+        command = " ".join(sys.argv[1:])
+        
+        command_history, team, npc = setup_shell()
+        initial_state.npc = npc
+        initial_state.team = team
+        
+        state, result = execute_command(
+            command, 
+            initial_state, 
+            router=router
+        )
+        
+        output = result.get('output') if isinstance(result, dict) else result
+        print(output)
+    
+    if __name__ == "__main__":
+        main()
+    ''')
+    
+    cli_script.write_text(cli_code)
+    
+    shutil.copytree(
+        config['team_path'], 
+        output_dir / 'npc_team',
+        dirs_exist_ok=True
+    )
+    
+    spec_file = output_dir / 'npc_cli.spec'
+    spec_file.write_text(textwrap.dedent('''
+    a = Analysis(
+        ['npc_cli.py'],
+        pathex=[],
+        binaries=[],
+        datas=[('npc_team', 'npc_team')],
+        hiddenimports=[],
+        hookspath=[],
+        hooksconfig={},
+        runtime_hooks=[],
+        excludes=[],
+        win_no_prefer_redirects=False,
+        win_private_assemblies=False,
+        cipher=None,
+        noarchive=False,
+    )
+    pyz = PYZ(a.pure, a.zipped_data, cipher=None)
+    
+    exe = EXE(
+        pyz,
+        a.scripts,
+        a.binaries,
+        a.zipfiles,
+        a.datas,
+        [],
+        name='npc',
+        debug=False,
+        bootloader_ignore_signals=False,
+        strip=False,
+        upx=True,
+        upx_exclude=[],
+        runtime_tmpdir=None,
+        console=True,
+    )
+    '''))
+    
+    return {
+        "output": (
+            f"CLI executable built in {output_dir}. "
+            f"Run: pyinstaller npc_cli.spec"
+        ), 
+        "messages": kwargs.get('messages', [])
+    }
+
+
+def build_static_site(config, **kwargs):
+    output_dir = Path(config['output_dir'])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    html = output_dir / 'index.html'
+    html.write_text(textwrap.dedent(f'''
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>NPC Team Interface</title>
+        <style>
+            body {{ 
+                font-family: monospace; 
+                max-width: 800px; 
+                margin: 50px auto; 
+            }}
+            #output {{ 
+                white-space: pre-wrap; 
+                background: #f5f5f5; 
+                padding: 20px; 
+                min-height: 300px; 
+            }}
+        </style>
+    </head>
+    <body>
+        <h1>NPC Team</h1>
+        <input id="input" type="text" 
+               placeholder="Enter command..." 
+               style="width: 100%; padding: 10px;">
+        <div id="output"></div>
+        
+        <script>
+        const API_URL = '{config.get("api_url", "http://localhost:5337")}';
+        
+        document.getElementById('input').addEventListener('keypress', 
+            async (e) => {{
+            if (e.key === 'Enter') {{
+                const cmd = e.target.value;
+                e.target.value = '';
+                
+                const resp = await fetch(`${{API_URL}}/api/stream`, {{
+                    method: 'POST',
+                    headers: {{'Content-Type': 'application/json'}},
+                    body: JSON.stringify({{
+                        commandstr: cmd,
+                        conversationId: 'web-session',
+                        model: 'llama3.2',
+                        provider: 'ollama'
+                    }})
+                }});
+                
+                const reader = resp.body.getReader();
+                const decoder = new TextDecoder();
+                
+                while (true) {{
+                    const {{done, value}} = await reader.read();
+                    if (done) break;
+                    
+                    const text = decoder.decode(value);
+                    document.getElementById('output').textContent += text;
+                }}
+            }}
+        }});
+        </script>
+    </body>
+    </html>
+    '''))
+    
+    return {
+        "output": (
+            f"Static site built in {output_dir}. "
+            f"Serve with: python -m http.server 8000"
+        ), 
+        "messages": kwargs.get('messages', [])
+    }