npcsh 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

npcsh/npc.py

@@ -56,25 +56,41 @@ def load_npc_by_name(npc_name: str = "sibiji", db_path: str = NPCSH_DB_PATH) ->
         if npc_name != "sibiji":
             return load_npc_by_name("sibiji", db_path)
         return None
-
 def main():
     from npcsh.routes import router
     
     parser = argparse.ArgumentParser(
-        description="NPC Command Line Utilities. Call a command or provide a prompt for the default NPC.",
-        usage="npc <command> [command_args...] | <prompt> [--npc NAME] [--model MODEL] [--provider PROV]"
+        description=(
+            "NPC Command Line Utilities. "
+            "Call a command or provide a prompt for the default NPC."
+        ),
+        usage=(
+            "npc <command> [command_args...] | "
+            "<prompt> [--npc NAME] [--model MODEL] [--provider PROV]"
+        )
     )
     parser.add_argument(
-        "--model", "-m", help="LLM model to use (overrides NPC/defaults)", type=str, default=None
+        "--model", 
+        "-m", 
+        help="LLM model to use (overrides NPC/defaults)", 
+        type=str, 
+        default=None
     )
     parser.add_argument(
-        "--provider", "-pr", help="LLM provider to use (overrides NPC/defaults)", type=str, default=None
+        "--provider", 
+        "-pr", 
+        help="LLM provider to use (overrides NPC/defaults)", 
+        type=str, 
+        default=None
     )
     parser.add_argument(
-        "-n", "--npc", help="Name of the NPC to use (default: sibiji)", type=str, default="sibiji"
+        "-n", 
+        "--npc", 
+        help="Name of the NPC to use (default: sibiji)", 
+        type=str, 
+        default="sibiji"
     )
 
-  
     args, all_args = parser.parse_known_args()
     global_model = args.model
     global_provider = args.provider
@@ -93,23 +109,33 @@ def main():
             command_name = '/' + first_arg
             all_args = all_args[1:]
 
-
-
     if is_valid_command:
-        subparsers = parser.add_subparsers(dest="command", title="Available Commands",
-                                         help="Run 'npc <command> --help' for command-specific help")
+        subparsers = parser.add_subparsers(
+            dest="command", 
+            title="Available Commands",
+            help="Run 'npc <command> --help' for command-specific help"
+        )
 
         for cmd_name, help_text in router.help_info.items():
-            cmd_parser = subparsers.add_parser(cmd_name, help=help_text, add_help=False)
-            cmd_parser.add_argument('command_args', nargs=argparse.REMAINDER,
-                                    help='Arguments passed directly to the command handler')
+            cmd_parser = subparsers.add_parser(
+                cmd_name, 
+                help=help_text, 
+                add_help=False
+            )
+            cmd_parser.add_argument(
+                'command_args', 
+                nargs=argparse.REMAINDER,
+                help='Arguments passed directly to the command handler'
+            )
 
-      
         args = parser.parse_args([command_name.lstrip('/')] + all_args)
-        command_args = args.command_args if hasattr(args, 'command_args') else []
+        command_args = (
+            args.command_args 
+            if hasattr(args, 'command_args') 
+            else []
+        )
         unknown_args = []
     else:
-      
         args.command = None
         command_args = []
         unknown_args = all_args
@@ -119,20 +145,26 @@ def main():
     if args.provider is None:
         args.provider = global_provider
 
-  
     try:
         command_history, team, forenpc_obj = setup_shell()
     except Exception as e:
-        print(f"Warning: Could not set up full npcsh environment: {e}", file=sys.stderr)
+        print(
+            f"Warning: Could not set up full npcsh environment: {e}", 
+            file=sys.stderr
+        )
         print("Falling back to basic NPC loading...", file=sys.stderr)
         team = None
         forenpc_obj = load_npc_by_name(args.npc, NPCSH_DB_PATH)
 
-  
     npc_instance = None
     if team and args.npc in team.npcs:
         npc_instance = team.npcs[args.npc]
-    elif team and args.npc == team.forenpc.name if team.forenpc else False:
+    elif (
+        team 
+        and args.npc == team.forenpc.name 
+        if team.forenpc 
+        else False
+    ):
         npc_instance = team.forenpc
     else:
         npc_instance = load_npc_by_name(args.npc, NPCSH_DB_PATH)
@@ -141,41 +173,55 @@ def main():
         print(f"Error: Could not load NPC '{args.npc}'", file=sys.stderr)
         sys.exit(1)
 
-  
     if not is_valid_command and all_args:
         first_arg = all_args[0]
         
-      
         jinx_found = False
         if team and first_arg in team.jinxs_dict:
             jinx_found = True
-        elif isinstance(npc_instance, NPC) and hasattr(npc_instance, 'jinxs_dict') and first_arg in npc_instance.jinxs_dict:
+        elif (
+            isinstance(npc_instance, NPC) 
+            and hasattr(npc_instance, 'jinxs_dict') 
+            and first_arg in npc_instance.jinxs_dict
+        ):
             jinx_found = True
             
         if jinx_found:
             is_valid_command = True
             command_name = '/' + first_arg
             all_args = all_args[1:]
+            unknown_args = all_args
 
-  
     shell_state = initial_state
     shell_state.npc = npc_instance
     shell_state.team = team
     shell_state.current_path = os.getcwd()
     shell_state.stream_output = NPCSH_STREAM_OUTPUT
 
-  
-    effective_model = args.model or (npc_instance.model if npc_instance.model else NPCSH_CHAT_MODEL)
-    effective_provider = args.provider or (npc_instance.provider if npc_instance.provider else NPCSH_CHAT_PROVIDER)
+    effective_model = (
+        args.model 
+        or (
+            npc_instance.model 
+            if npc_instance.model 
+            else NPCSH_CHAT_MODEL
+        )
+    )
+    effective_provider = (
+        args.provider 
+        or (
+            npc_instance.provider 
+            if npc_instance.provider 
+            else NPCSH_CHAT_PROVIDER
+        )
+    )
     
-  
     if args.model:
         npc_instance.model = effective_model
     if args.provider:
         npc_instance.provider = effective_provider
+        
     try:
         if is_valid_command:
-          
             full_command_str = command_name
             if command_args:
                 full_command_str += " " + " ".join(command_args)
@@ -187,56 +233,91 @@ def main():
                 stdin_input=None, 
                 state=shell_state, 
                 stream=NPCSH_STREAM_OUTPUT, 
-                router = router
+                router=router
             )
 
-          
             if isinstance(result, dict):
                 output = result.get("output") or result.get("response")
                 model_for_stream = result.get('model', effective_model)
-                provider_for_stream = result.get('provider', effective_provider)
+                provider_for_stream = result.get(
+                    'provider', 
+                    effective_provider
+                )
                 
-                if NPCSH_STREAM_OUTPUT and not isinstance(output, str):
-                     print_and_process_stream_with_markdown(output, model_for_stream, provider_for_stream)
+                if (
+                    NPCSH_STREAM_OUTPUT 
+                    and not isinstance(output, str)
+                ):
+                    print_and_process_stream_with_markdown(
+                        output, 
+                        model_for_stream, 
+                        provider_for_stream
+                    )
                 elif output is not None:
-                     render_markdown(str(output))
+                    render_markdown(str(output))
             elif result is not None:
                 render_markdown(str(result))
             else:
                 print(f"Command '{command_name}' executed.")
 
         else:
-          
             prompt = " ".join(unknown_args)
 
             if not prompt:
-              
                 parser.print_help()
                 sys.exit(1)
 
-            print(f"Processing prompt: '{prompt}' with NPC: '{args.npc}'...")
+            print(
+                f"Processing prompt: '{prompt}' with NPC: '{args.npc}'..."
+            )
             
-          
             shell_state.current_mode = 'chat'
-            updated_state, result = execute_command(prompt, shell_state)
+            updated_state, result = execute_command(
+                prompt, 
+                shell_state, 
+                router=router, 
+                command_history=command_history
+            )
 
-          
             if isinstance(result, dict):
                 output = result.get("output")
                 model_for_stream = result.get('model', effective_model)
-                provider_for_stream = result.get('provider', effective_provider)
+                provider_for_stream = result.get(
+                    'provider', 
+                    effective_provider
+                )
                 
-                if NPCSH_STREAM_OUTPUT and hasattr(output, '__iter__') and not isinstance(output, (str, bytes, dict, list)):
-                    print_and_process_stream_with_markdown(output, model_for_stream, provider_for_stream)
+                if (
+                    hasattr(output, '__iter__') 
+                    and not isinstance(output, (str, bytes, dict, list))
+                ):
+                    final_output = print_and_process_stream_with_markdown(
+                        output, 
+                        model_for_stream, 
+                        provider_for_stream,
+                        show=True
+                    )
                 elif output is not None:
                     render_markdown(str(output))
+            elif (
+                hasattr(result, '__iter__') 
+                and not isinstance(result, (str, bytes, dict, list))
+            ):
+                final_output = print_and_process_stream_with_markdown(
+                    result,
+                    effective_model,
+                    effective_provider,
+                    show=True
+                )
             elif result is not None:
-                 render_markdown(str(result))
+                render_markdown(str(result))
+
 
     except Exception as e:
         print(f"Error executing command: {e}", file=sys.stderr)
         traceback.print_exc()
         sys.exit(1)
 
+
 if __name__ == "__main__":
     main()

npcsh/npcsh.py

@@ -203,7 +203,7 @@ def run_repl(command_history: CommandHistory, initial_state: ShellState):
 
             state, output = execute_command(user_input, 
                                             state, 
-                                            review = True, 
+                                            review = False, 
                                             router=router, 
                                             command_history=command_history)
 

npcsh/routes.py

@@ -56,7 +56,9 @@ from npcsh._state import (
     NPCSH_SEARCH_PROVIDER,
     CANONICAL_ARGS, 
     normalize_and_expand_flags, 
-    get_argument_help
+    get_argument_help, 
+    get_relevant_memories
+
 )
 from npcsh.corca import enter_corca_mode
 from npcsh.guac import enter_guac_mode
@@ -190,6 +192,41 @@ def get_help_text():
 def safe_get(kwargs, key, default=None):
     return kwargs.get(key, default)
 
+
+@router.route("build", "Build deployment artifacts for NPC team")
+def build_handler(command: str, **kwargs):
+    parts = shlex.split(command)
+    
+    target = safe_get(kwargs, 'target', 'flask')
+    output_dir = safe_get(kwargs, 'output', './build')
+    team_path = safe_get(kwargs, 'team', './npc_team')
+    
+    if len(parts) > 1:
+        target = parts[1]
+    
+    build_config = {
+        'team_path': os.path.abspath(team_path),
+        'output_dir': os.path.abspath(output_dir),
+        'target': target,
+        'port': safe_get(kwargs, 'port', 5337),
+        'cors_origins': safe_get(kwargs, 'cors', None),
+    }
+    
+    builders = {
+        'flask': build_flask_server,
+        'docker': build_docker_compose,
+        'cli': build_cli_executable,
+        'static': build_static_site,
+    }
+    
+    if target not in builders:
+        return {
+            "output": f"Unknown target: {target}. Available: {list(builders.keys())}", 
+            "messages": kwargs.get('messages', [])
+        }
+    
+    return builders[target](build_config, **kwargs)
+
 @router.route("breathe", "Condense context on a regular cadence")
 def breathe_handler(command: str, **kwargs):
   
@@ -730,40 +767,211 @@ def sample_handler(command: str, **kwargs):
     except Exception as e:
         traceback.print_exc()
         return {"output": f"Error sampling LLM: {e}", "messages": messages}
-@router.route("search", "Execute a web search command")
+
+
+
+@router.route("search", "Execute web search or memory/KG search")
 def search_handler(command: str, **kwargs):
-    """    
-    Executes a search command.
-  
-  
-  
-  
-  
-  
-    """
     messages = safe_get(kwargs, "messages", [])
     
-  
     positional_args = safe_get(kwargs, 'positional_args', [])
-    query = " ".join(positional_args)
+    
+    search_type = None
+    query_parts = []
+    
+    i = 0
+    while i < len(positional_args):
+        arg = positional_args[i]
+        if arg in ['-m', '-mem', '--memory']:
+            search_type = 'memory'
+            i += 1
+        elif arg in ['-kg', '--knowledge-graph']:
+            search_type = 'kg'
+            i += 1
+        else:
+            query_parts.append(arg)
+            i += 1
+    
+    query = " ".join(query_parts)
     
     if not query:
-        return {"output": "Usage: /search [-sp name --sprovider name] query", 
-                "messages": messages}
-    search_provider = safe_get(kwargs, 'sprovider', NPCSH_SEARCH_PROVIDER)
-    render_markdown(f'- Searching {search_provider} for "{query}"'    )
+        return {
+            "output": (
+                "Usage:\n"
+                "  /search <query>              - Web search\n"
+                "  /search -m <query>           - Memory search\n"
+                "  /search -kg <query>          - Knowledge graph search"
+            ), 
+            "messages": messages
+        }
+    
+    if search_type == 'memory':
+        return search_memories(query, kwargs, messages)
+    elif search_type == 'kg':
+        return search_knowledge_graph(query, kwargs, messages)
+    else:
+        return search_web_default(query, kwargs, messages)
 
+def search_memories(query: str, kwargs: dict, messages: list):
+    command_history = kwargs.get('command_history')
+    
+    if not command_history:
+        db_path = safe_get(
+            kwargs, 
+            "history_db_path", 
+            os.path.expanduser('~/npcsh_history.db')
+        )
+        try:
+            command_history = CommandHistory(db_path)
+        except Exception as e:
+            return {
+                "output": f"Error connecting to history: {e}", 
+                "messages": messages
+            }
+    
+    state = kwargs.get('state')
+    npc = safe_get(kwargs, 'npc')
+    team = safe_get(kwargs, 'team')
+    
+    npc_name = npc.name if isinstance(npc, NPC) else "__none__"
+    team_name = team.name if team else "__none__"
+    current_path = safe_get(kwargs, 'current_path', os.getcwd())
+    
+    try:
+        memories = get_relevant_memories(
+            command_history=command_history,
+            npc_name=npc_name,
+            team_name=team_name,
+            path=current_path,
+            query=query,
+            max_memories=10,
+            state=state
+        )
+        
+        if not memories:
+            output = f"No memories found for query: '{query}'"
+        else:
+            output = f"Found {len(memories)} memories:\n\n"
+            for i, mem in enumerate(memories, 1):
+                final_mem = (
+                    mem.get('final_memory') or 
+                    mem.get('initial_memory')
+                )
+                timestamp = mem.get('timestamp', 'unknown')
+                output += f"{i}. [{timestamp}] {final_mem}\n"
+        
+        return {"output": output, "messages": messages}
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return {
+            "output": f"Error searching memories: {e}", 
+            "messages": messages
+        }
 
+def search_knowledge_graph(query: str, kwargs: dict, messages: list):
+    command_history = kwargs.get('command_history')
+    
+    if not command_history:
+        db_path = safe_get(
+            kwargs, 
+            "history_db_path", 
+            os.path.expanduser('~/npcsh_history.db')
+        )
+        try:
+            command_history = CommandHistory(db_path)
+        except Exception as e:
+            return {
+                "output": f"Error connecting to history: {e}", 
+                "messages": messages
+            }
+    
+    npc = safe_get(kwargs, 'npc')
+    team = safe_get(kwargs, 'team')
+    
+    npc_name = npc.name if isinstance(npc, NPC) else "__none__"
+    team_name = team.name if team else "__none__"
+    current_path = safe_get(kwargs, 'current_path', os.getcwd())
+    
+    try:
+        engine = command_history.engine
+        kg = load_kg_from_db(
+            engine, 
+            team_name, 
+            npc_name, 
+            current_path
+        )
+        
+        if not kg or not kg.get('facts'):
+            return {
+                "output": (
+                    f"No knowledge graph found for current scope.\n"
+                    f"Scope: Team='{team_name}', "
+                    f"NPC='{npc_name}', Path='{current_path}'"
+                ),
+                "messages": messages
+            }
+        
+        query_lower = query.lower()
+        matching_facts = []
+        matching_concepts = []
+        
+        for fact in kg.get('facts', []):
+            statement = fact.get('statement', '').lower()
+            if query_lower in statement:
+                matching_facts.append(fact)
+        
+        for concept in kg.get('concepts', []):
+            name = concept.get('name', '').lower()
+            desc = concept.get('description', '').lower()
+            if query_lower in name or query_lower in desc:
+                matching_concepts.append(concept)
+        
+        output = f"Knowledge Graph Search Results for '{query}':\n\n"
+        
+        if matching_facts:
+            output += f"## Facts ({len(matching_facts)}):\n"
+            for i, fact in enumerate(matching_facts, 1):
+                output += f"{i}. {fact.get('statement')}\n"
+            output += "\n"
+        
+        if matching_concepts:
+            output += f"## Concepts ({len(matching_concepts)}):\n"
+            for i, concept in enumerate(matching_concepts, 1):
+                name = concept.get('name')
+                desc = concept.get('description', '')
+                output += f"{i}. {name}: {desc}\n"
+        
+        if not matching_facts and not matching_concepts:
+            output += "No matching facts or concepts found."
+        
+        return {"output": output, "messages": messages}
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return {
+            "output": f"Error searching KG: {e}", 
+            "messages": messages
+        }
+
+def search_web_default(query: str, kwargs: dict, messages: list):
+    search_provider = safe_get(kwargs, 'sprovider', NPCSH_SEARCH_PROVIDER)
+    render_markdown(f'- Searching {search_provider} for "{query}"')
     
-    if not query:
-        return {"output": "Usage: /search <query>", "messages": messages}
-    search_provider = safe_get(kwargs, 'search_provider', NPCSH_SEARCH_PROVIDER)
     try:
         search_results = search_web(query, provider=search_provider)
-        output = "\n".join([f"- {res}" for res in search_results]) if search_results else "No results found."
+        output = (
+            "\n".join([f"- {res}" for res in search_results]) 
+            if search_results 
+            else "No results found."
+        )
     except Exception as e:
+        import traceback
         traceback.print_exc()
         output = f"Error during web search: {e}"
+    
     return {"output": output, "messages": messages}
 
 

{npcsh-1.1.2.dist-info → npcsh-1.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.1.2
+Version: 1.1.4
 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
@@ -194,6 +194,14 @@ and you will enter the NPC shell. Additionally, the pip installation includes th
     /corca --mcp-server-path /path.to.server.py
     ```
 
+  - **Build an NPC Team**: 
+
+    ``` bash
+    npc build flask --output ./dist --port 5337
+    npc build docker --output ./deploy
+    npc build cli --output ./bin
+    npc build static --api_url https://api.example.com
+    ```
 
 # NPC Data Layer
 
@@ -217,6 +225,7 @@ Importantly, users can switch easily between the NPCs they are chatting with by
 -  activated by invoking `/<command> ...` in `npcsh`, macros can be called in bash or through the `npc` CLI. In our examples, we provide both `npcsh` calls as well as bash calls with the `npc` cli where relevant. For converting any `/<command>` in `npcsh` to a bash version, replace the `/` with `npc ` and the macro command will be invoked as a positional argument. Some, like breathe, flush,
     
     - `/alicanto` - Conduct deep research with multiple perspectives, identifying gold insights and cliff warnings. Usage: `/alicanto 'query to be researched' --num-npcs <int> --depth <int>`
+    - `/build` - Builds the current npc team to an executable format . Usage: `/build <output[flask,docker,cli,static]> --options`
     - `/brainblast` - Execute an advanced chunked search on command history. Usage:     `/brainblast 'query'  --top_k 10`
     - `/breathe` - Condense context on a regular cadence. Usage: `/breathe -p <provider: NPCSH_CHAT_PROVIDER> -m <model: NPCSH_CHAT_MODEL>`
     - `/compile` - Compile NPC profiles. Usage: `/compile <path_to_npc> `