npcpy 1.3.11__py3-none-any.whl → 1.3.13__py3-none-any.whl

npcpy/gen/response.py

@@ -259,6 +259,24 @@ def get_ollama_response(
                                 prompt = f"Content from CSV: {os.path.basename(attachment)} (first 100 rows):\n{csv_sample} \n csv description: {csv_data.describe()}"
                     except Exception:
                         pass
+                else:
+                    # Handle text-based files
+                    text_extensions = {'.txt', '.text', '.log', '.md', '.markdown', '.rst', '.json', '.yaml', '.yml', '.toml', '.ini', '.conf', '.cfg', '.xml', '.html', '.htm', '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.c', '.h', '.cpp', '.hpp', '.go', '.rs', '.rb', '.php', '.sh', '.bash', '.sql', '.css', '.scss'}
+                    filename = os.path.basename(attachment)
+                    if ext in text_extensions or ext == '':
+                        try:
+                            with open(attachment, 'r', encoding='utf-8', errors='replace') as f:
+                                text_content = f.read()
+                            max_chars = 50000
+                            if len(text_content) > max_chars:
+                                text_content = text_content[:max_chars] + f"\n\n... [truncated]"
+                            if text_content.strip():
+                                if prompt:
+                                    prompt += f"\n\nContent from {filename}:\n```\n{text_content}\n```"
+                                else:
+                                    prompt = f"Content from {filename}:\n```\n{text_content}\n```"
+                        except Exception:
+                            pass
 
 
     if prompt:
@@ -797,6 +815,24 @@ def get_litellm_response(
                                 prompt = f"Content from CSV: {os.path.basename(attachment)} (first 10 rows):\n{csv_sample}"
                     except Exception:
                         pass
+                else:
+                    # Handle text-based files
+                    text_extensions = {'.txt', '.text', '.log', '.md', '.markdown', '.rst', '.json', '.yaml', '.yml', '.toml', '.ini', '.conf', '.cfg', '.xml', '.html', '.htm', '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.c', '.h', '.cpp', '.hpp', '.go', '.rs', '.rb', '.php', '.sh', '.bash', '.sql', '.css', '.scss'}
+                    filename = os.path.basename(attachment)
+                    if ext in text_extensions or ext == '':
+                        try:
+                            with open(attachment, 'r', encoding='utf-8', errors='replace') as f:
+                                text_content = f.read()
+                            max_chars = 50000
+                            if len(text_content) > max_chars:
+                                text_content = text_content[:max_chars] + f"\n\n... [truncated]"
+                            if text_content.strip():
+                                if prompt:
+                                    prompt += f"\n\nContent from {filename}:\n```\n{text_content}\n```"
+                                else:
+                                    prompt = f"Content from {filename}:\n```\n{text_content}\n```"
+                        except Exception:
+                            pass
 
     if prompt:
         if result['messages'] and result['messages'][-1]["role"] == "user":

npcpy/memory/knowledge_graph.py

@@ -344,7 +344,6 @@ def kg_evolve_incremental(existing_kg,
 
     current_gen = existing_kg.get('generation', 0)
     next_gen = current_gen + 1
-    print(f"\n--- ABSORBING INFO: Gen {current_gen} -> Gen {next_gen} ---")
 
     newly_added_concepts = []
     concept_links = list(existing_kg.get('concept_links', []))
@@ -359,8 +358,7 @@ def kg_evolve_incremental(existing_kg,
     all_concept_names = list(existing_concept_names)
     
     all_new_facts = []
-    print(npc, npc.model, npc.provider)
-    
+
     if new_facts:
         all_new_facts = new_facts
         print(f'using pre-approved facts: {len(all_new_facts)}')

npcpy/npc_compiler.py

@@ -7,6 +7,41 @@ import sqlite3
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
+import matplotlib as mpl
+
+# Professional plot styling (from kg-research matplotlibrc)
+mpl.rcParams.update({
+    'font.family': 'serif',
+    'axes.labelsize': 20,
+    'axes.grid.axis': 'both',
+    'axes.grid.which': 'major',
+    'axes.prop_cycle': mpl.cycler('color', ['k', 'b', 'r', 'g', 'c', 'm', 'y', 'k']),
+    'xtick.top': True,
+    'xtick.direction': 'in',
+    'xtick.major.size': 10,
+    'xtick.minor.size': 5,
+    'xtick.labelsize': 20,
+    'xtick.minor.visible': True,
+    'xtick.major.top': True,
+    'xtick.major.bottom': True,
+    'xtick.minor.top': True,
+    'xtick.minor.bottom': True,
+    'ytick.left': True,
+    'ytick.right': True,
+    'ytick.direction': 'in',
+    'ytick.major.size': 10,
+    'ytick.minor.size': 5,
+    'ytick.labelsize': 20,
+    'ytick.minor.visible': True,
+    'ytick.major.left': True,
+    'ytick.major.right': True,
+    'ytick.minor.left': True,
+    'ytick.minor.right': True,
+    'legend.frameon': False,
+    'legend.fontsize': 12,
+    'image.cmap': 'plasma',
+    'errorbar.capsize': 1,
+})
 import re
 import random
 from datetime import datetime
@@ -31,9 +66,31 @@ from npcpy.npc_sysenv import (
 from npcpy.memory.command_history import CommandHistory, generate_message_id
 
 class SilentUndefined(Undefined):
+    """Undefined that silently returns empty string instead of raising errors"""
     def _fail_with_undefined_error(self, *args, **kwargs):
         return ""
 
+    def __str__(self):
+        return ""
+
+    def __repr__(self):
+        return ""
+
+    def __bool__(self):
+        return False
+
+    def __eq__(self, other):
+        return other == "" or other is None or isinstance(other, Undefined)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __iter__(self):
+        return iter([])
+
+    def __len__(self):
+        return 0
+
 import math
 from PIL import Image
 from jinja2 import Environment, ChainableUndefined
@@ -152,11 +209,35 @@ def get_log_entries(entity_id, entry_type=None, limit=10, db_path="~/npcsh_histo
         ]
 
 
+def _json_dumps_with_undefined(obj, **kwargs):
+    """Custom JSON dumps that handles SilentUndefined objects"""
+    def default_handler(o):
+        if isinstance(o, Undefined):
+            return ""
+        raise TypeError(f"Object of type {type(o).__name__} is not JSON serializable")
+    return json.dumps(obj, default=default_handler, **kwargs)
+
+
 def load_yaml_file(file_path):
-    """Load a YAML file with error handling"""
+    """Load a YAML file with error handling, rendering Jinja2 first"""
     try:
         with open(os.path.expanduser(file_path), 'r') as f:
-            return yaml.safe_load(f)
+            content = f.read()
+
+        # Check if file has Jinja2 control structures that need pre-rendering
+        # Only render if there are {% %} blocks, otherwise parse directly
+        if '{%' not in content:
+            return yaml.safe_load(content)
+
+        # First pass: render Jinja2 templates to produce valid YAML
+        # This allows {% if %} and other control structures to work
+        jinja_env = Environment(undefined=SilentUndefined)
+        # Configure tojson filter to handle SilentUndefined
+        jinja_env.policies['json.dumps_function'] = _json_dumps_with_undefined
+        template = jinja_env.from_string(content)
+        rendered_content = template.render({})
+
+        return yaml.safe_load(rendered_content)
     except Exception as e:
         print(f"Error loading YAML file {file_path}: {e}")
         return None

npcpy/serve.py

@@ -46,7 +46,8 @@ from npcsh._state import ShellState, initialize_base_npcs_if_needed
 from npcsh.config import NPCSH_DB_PATH
 
 
-from npcpy.memory.knowledge_graph import load_kg_from_db
+from npcpy.memory.knowledge_graph import load_kg_from_db, find_similar_facts_chroma
+from npcpy.memory.command_history import setup_chroma_db
 from npcpy.memory.search import execute_rag_command, execute_brainblast_command
 from npcpy.data.load import load_file_contents
 from npcpy.data.web import search_web
@@ -67,12 +68,14 @@ from npcpy.memory.command_history import (
     save_conversation_message,
     generate_message_id,
 )
-from npcpy.npc_compiler import  Jinx, NPC, Team, load_jinxs_from_directory, build_jinx_tool_catalog, initialize_npc_project
+from npcpy.npc_compiler import  Jinx, NPC, Team, load_jinxs_from_directory, build_jinx_tool_catalog, initialize_npc_project, load_yaml_file
 
 from npcpy.llm_funcs import (
     get_llm_response, check_llm_command
 )
+from npcpy.gen.embeddings import get_embeddings
 from termcolor import cprint
+
 from npcpy.tools import auto_tools
 
 import json
@@ -572,7 +575,7 @@ def fetch_messages_for_conversation(conversation_id):
     try:
         with engine.connect() as conn:
             query = text("""
-                SELECT role, content, timestamp
+                SELECT role, content, timestamp, tool_calls, tool_results
                 FROM conversation_history
                 WHERE conversation_id = :conversation_id
                 ORDER BY timestamp ASC
@@ -580,14 +583,45 @@ def fetch_messages_for_conversation(conversation_id):
             result = conn.execute(query, {"conversation_id": conversation_id})
             messages = result.fetchall()
 
-            return [
-                {
-                    "role": message[0],  
-                    "content": message[1],  
-                    "timestamp": message[2],  
+            parsed_messages = []
+            for message in messages:
+                role = message[0]
+                content = message[1]
+
+                msg_dict = {
+                    "role": role,
+                    "content": content,
+                    "timestamp": message[2],
                 }
-                for message in messages
-            ]
+
+                # Handle tool messages - extract tool_call_id from content JSON
+                if role == "tool" and content:
+                    try:
+                        content_parsed = json.loads(content) if isinstance(content, str) else content
+                        if isinstance(content_parsed, dict):
+                            if "tool_call_id" in content_parsed:
+                                msg_dict["tool_call_id"] = content_parsed["tool_call_id"]
+                            if "tool_name" in content_parsed:
+                                msg_dict["name"] = content_parsed["tool_name"]
+                            if "content" in content_parsed:
+                                msg_dict["content"] = content_parsed["content"]
+                    except (json.JSONDecodeError, TypeError):
+                        pass
+
+                # Parse tool_calls JSON if present (for assistant messages)
+                if message[3]:
+                    try:
+                        msg_dict["tool_calls"] = json.loads(message[3]) if isinstance(message[3], str) else message[3]
+                    except (json.JSONDecodeError, TypeError):
+                        pass
+                # Parse tool_results JSON if present
+                if message[4]:
+                    try:
+                        msg_dict["tool_results"] = json.loads(message[4]) if isinstance(message[4], str) else message[4]
+                    except (json.JSONDecodeError, TypeError):
+                        pass
+                parsed_messages.append(msg_dict)
+            return parsed_messages
     except Exception as e:
         print(f"Error fetching messages for conversation: {e}")
         return []
@@ -681,6 +715,265 @@ def get_centrality_data():
     concept_degree = {node: cent for node, cent in nx.degree_centrality(G).items() if node in concepts_df['name'].values}
     return jsonify(centrality={'degree': concept_degree})
 
+@app.route('/api/kg/search')
+def search_kg():
+    """Search facts and concepts by keyword"""
+    try:
+        q = request.args.get('q', '').strip().lower()
+        generation = request.args.get('generation', type=int)
+        search_type = request.args.get('type', 'both')  # fact, concept, or both
+        limit = request.args.get('limit', 50, type=int)
+
+        if not q:
+            return jsonify({"error": "Query parameter 'q' is required"}), 400
+
+        concepts_df, facts_df, links_df = load_kg_data(generation)
+        results = {"facts": [], "concepts": [], "query": q}
+
+        # Search facts
+        if search_type in ('both', 'fact'):
+            for _, row in facts_df.iterrows():
+                statement = str(row.get('statement', '')).lower()
+                source_text = str(row.get('source_text', '')).lower()
+                if q in statement or q in source_text:
+                    results["facts"].append({
+                        "statement": row.get('statement'),
+                        "source_text": row.get('source_text'),
+                        "type": row.get('type'),
+                        "generation": row.get('generation'),
+                        "origin": row.get('origin')
+                    })
+                    if len(results["facts"]) >= limit:
+                        break
+
+        # Search concepts
+        if search_type in ('both', 'concept'):
+            for _, row in concepts_df.iterrows():
+                name = str(row.get('name', '')).lower()
+                description = str(row.get('description', '')).lower()
+                if q in name or q in description:
+                    results["concepts"].append({
+                        "name": row.get('name'),
+                        "description": row.get('description'),
+                        "generation": row.get('generation'),
+                        "origin": row.get('origin')
+                    })
+                    if len(results["concepts"]) >= limit:
+                        break
+
+        return jsonify(results)
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/kg/embed', methods=['POST'])
+def embed_kg_facts():
+    """Embed existing facts from SQL to Chroma for semantic search"""
+    try:
+        data = request.get_json() or {}
+        generation = data.get('generation')
+        batch_size = data.get('batch_size', 10)
+
+        # Load facts from SQL
+        _, facts_df, _ = load_kg_data(generation)
+
+        if facts_df.empty:
+            return jsonify({"message": "No facts to embed", "count": 0})
+
+        # Setup Chroma
+        chroma_db_path = os.path.expanduser('~/npcsh_chroma_db')
+        _, chroma_collection = setup_chroma_db(
+            "knowledge_graph",
+            "Facts extracted from various sources",
+            chroma_db_path
+        )
+
+        # Process in batches
+        from npcpy.memory.knowledge_graph import store_fact_with_embedding
+        import hashlib
+
+        embedded_count = 0
+        skipped_count = 0
+
+        statements = facts_df['statement'].dropna().tolist()
+
+        for i in range(0, len(statements), batch_size):
+            batch = statements[i:i + batch_size]
+
+            # Get embeddings for batch
+            try:
+                embeddings = get_embeddings(batch)
+            except Exception as e:
+                print(f"Failed to get embeddings for batch {i}: {e}")
+                continue
+
+            for j, statement in enumerate(batch):
+                fact_id = hashlib.md5(statement.encode()).hexdigest()
+
+                # Check if already exists
+                try:
+                    existing = chroma_collection.get(ids=[fact_id])
+                    if existing and existing.get('ids'):
+                        skipped_count += 1
+                        continue
+                except:
+                    pass
+
+                # Get metadata from dataframe
+                row = facts_df[facts_df['statement'] == statement].iloc[0] if len(facts_df[facts_df['statement'] == statement]) > 0 else None
+                metadata = {
+                    "generation": int(row.get('generation', 0)) if row is not None and pd.notna(row.get('generation')) else 0,
+                    "origin": str(row.get('origin', '')) if row is not None else '',
+                    "type": str(row.get('type', '')) if row is not None else '',
+                }
+
+                # Store with embedding
+                result = store_fact_with_embedding(
+                    chroma_collection, statement, metadata, embeddings[j]
+                )
+                if result:
+                    embedded_count += 1
+
+        return jsonify({
+            "message": f"Embedded {embedded_count} facts, skipped {skipped_count} existing",
+            "embedded": embedded_count,
+            "skipped": skipped_count,
+            "total_facts": len(statements)
+        })
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/kg/search/semantic')
+def search_kg_semantic():
+    """Semantic search for facts using vector similarity"""
+    try:
+        q = request.args.get('q', '').strip()
+        generation = request.args.get('generation', type=int)
+        limit = request.args.get('limit', 10, type=int)
+
+        if not q:
+            return jsonify({"error": "Query parameter 'q' is required"}), 400
+
+        # Setup Chroma connection
+        chroma_db_path = os.path.expanduser('~/npcsh_chroma_db')
+        try:
+            _, chroma_collection = setup_chroma_db(
+                "knowledge_graph",
+                "Facts extracted from various sources",
+                chroma_db_path
+            )
+        except Exception as e:
+            return jsonify({
+                "error": f"Chroma DB not available: {str(e)}",
+                "facts": [],
+                "query": q
+            }), 200
+
+        # Get query embedding
+        try:
+            query_embedding = get_embeddings([q])[0]
+        except Exception as e:
+            return jsonify({
+                "error": f"Failed to generate embedding: {str(e)}",
+                "facts": [],
+                "query": q
+            }), 200
+
+        # Build metadata filter for generation if specified
+        metadata_filter = None
+        if generation is not None:
+            metadata_filter = {"generation": generation}
+
+        # Search Chroma
+        similar_facts = find_similar_facts_chroma(
+            chroma_collection,
+            q,
+            query_embedding=query_embedding,
+            n_results=limit,
+            metadata_filter=metadata_filter
+        )
+
+        # Format results
+        results = {
+            "facts": [
+                {
+                    "statement": f["fact"],
+                    "distance": f.get("distance"),
+                    "metadata": f.get("metadata", {}),
+                    "id": f.get("id")
+                }
+                for f in similar_facts
+            ],
+            "query": q,
+            "total": len(similar_facts)
+        }
+
+        return jsonify(results)
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/kg/facts')
+def get_kg_facts():
+    """Get facts, optionally filtered by generation"""
+    try:
+        generation = request.args.get('generation', type=int)
+        limit = request.args.get('limit', 100, type=int)
+        offset = request.args.get('offset', 0, type=int)
+
+        _, facts_df, _ = load_kg_data(generation)
+
+        facts = []
+        for i, row in facts_df.iloc[offset:offset+limit].iterrows():
+            facts.append({
+                "statement": row.get('statement'),
+                "source_text": row.get('source_text'),
+                "type": row.get('type'),
+                "generation": row.get('generation'),
+                "origin": row.get('origin')
+            })
+
+        return jsonify({
+            "facts": facts,
+            "total": len(facts_df),
+            "offset": offset,
+            "limit": limit
+        })
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/kg/concepts')
+def get_kg_concepts():
+    """Get concepts, optionally filtered by generation"""
+    try:
+        generation = request.args.get('generation', type=int)
+        limit = request.args.get('limit', 100, type=int)
+
+        concepts_df, _, _ = load_kg_data(generation)
+
+        concepts = []
+        for _, row in concepts_df.head(limit).iterrows():
+            concepts.append({
+                "name": row.get('name'),
+                "description": row.get('description'),
+                "generation": row.get('generation'),
+                "origin": row.get('origin')
+            })
+
+        return jsonify({
+            "concepts": concepts,
+            "total": len(concepts_df)
+        })
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
 
 
 @app.route("/api/attachments/<message_id>", methods=["GET"])
@@ -822,10 +1115,9 @@ def get_available_jinxs():
         def get_jinx_name_from_file(filepath):
             """Read jinx_name from file, fallback to filename."""
             try:
-                with open(filepath, 'r') as f:
-                    data = yaml.safe_load(f)
-                    if data and 'jinx_name' in data:
-                        return data['jinx_name']
+                data = load_yaml_file(filepath)
+                if data and 'jinx_name' in data:
+                    return data['jinx_name']
             except:
                 pass
             return os.path.basename(filepath)[:-5]
@@ -1893,9 +2185,10 @@ def get_jinxs_global():
         for file in files:
             if file.endswith(".jinx"):
                 jinx_path = os.path.join(root, file)
-                with open(jinx_path, 'r') as f:
-                    raw_data = yaml.safe_load(f)
-                
+                raw_data = load_yaml_file(jinx_path)
+                if raw_data is None:
+                    continue
+
                 # Preserve full input definitions including defaults
                 inputs = raw_data.get("inputs", [])
                 
@@ -1929,9 +2222,10 @@ def get_jinxs_project():
         for file in files:
             if file.endswith(".jinx"):
                 jinx_path = os.path.join(root, file)
-                with open(jinx_path, 'r') as f:
-                    raw_data = yaml.safe_load(f)
-                
+                raw_data = load_yaml_file(jinx_path)
+                if raw_data is None:
+                    continue
+
                 # Preserve full input definitions including defaults
                 inputs = raw_data.get("inputs", [])
                 
@@ -2087,8 +2381,9 @@ def get_npc_team_global():
     for file in os.listdir(global_npc_directory):
         if file.endswith(".npc"):
             npc_path = os.path.join(global_npc_directory, file)
-            with open(npc_path, 'r') as f:
-                raw_data = yaml.safe_load(f)
+            raw_data = load_yaml_file(npc_path)
+            if raw_data is None:
+                continue
             
             npc_data.append({
                 "name": raw_data.get("name", file[:-4]),
@@ -2123,8 +2418,9 @@ def get_npc_team_project():
     for file in os.listdir(project_npc_directory):
         if file.endswith(".npc"):
             npc_path = os.path.join(project_npc_directory, file)
-            with open(npc_path, 'r') as f:
-                raw_npc_data = yaml.safe_load(f)
+            raw_npc_data = load_yaml_file(npc_path)
+            if raw_npc_data is None:
+                continue
             
             serialized_npc = {
                 "name": raw_npc_data.get("name", file[:-4]),
@@ -2402,8 +2698,7 @@ def get_package_contents():
                 if f.endswith('.npc'):
                     npc_path = os.path.join(package_npc_team_dir, f)
                     try:
-                        with open(npc_path, 'r') as file:
-                            npc_data = yaml.safe_load(file) or {}
+                        npc_data = load_yaml_file(npc_path) or {}
                         npcs.append({
                             "name": npc_data.get("name", f[:-4]),
                             "primary_directive": npc_data.get("primary_directive", ""),
@@ -2422,8 +2717,7 @@ def get_package_contents():
                             jinx_path = os.path.join(root, f)
                             rel_path = os.path.relpath(jinx_path, jinxs_dir)
                             try:
-                                with open(jinx_path, 'r') as file:
-                                    jinx_data = yaml.safe_load(file) or {}
+                                jinx_data = load_yaml_file(jinx_path) or {}
                                 jinxs.append({
                                     "name": f[:-5],
                                     "path": rel_path[:-5],
@@ -3935,7 +4229,7 @@ def stream():
                                     input_values=tool_args if isinstance(tool_args, dict) else {},
                                     npc=npc_object
                                 )
-                                tool_content = str(jinx_ctx)
+                                tool_content = str(jinx_ctx.get('output', '')) if isinstance(jinx_ctx, dict) else str(jinx_ctx)
                             except Exception as e:
                                 tool_content = f"Jinx execution error: {str(e)}"
                         else:
@@ -4361,19 +4655,103 @@ def approve_memories():
     try:
         data = request.json
         approvals = data.get("approvals", [])
-        
+
         command_history = CommandHistory(app.config.get('DB_PATH'))
-        
+
         for approval in approvals:
             command_history.update_memory_status(
                 approval['memory_id'],
                 approval['decision'],
                 approval.get('final_memory')
             )
-        
+
         return jsonify({"success": True, "processed": len(approvals)})
-        
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/api/memory/search", methods=["GET"])
+def search_memories():
+    """Search memories with optional scope filtering"""
+    try:
+        q = request.args.get("q", "")
+        npc = request.args.get("npc")
+        team = request.args.get("team")
+        directory_path = request.args.get("directory_path")
+        status = request.args.get("status")
+        limit = int(request.args.get("limit", 50))
+
+        if not q:
+            return jsonify({"error": "Query parameter 'q' is required"}), 400
+
+        command_history = CommandHistory(app.config.get('DB_PATH'))
+        results = command_history.search_memory(
+            query=q,
+            npc=npc,
+            team=team,
+            directory_path=directory_path,
+            status_filter=status,
+            limit=limit
+        )
+
+        return jsonify({"memories": results, "count": len(results)})
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/api/memory/pending", methods=["GET"])
+def get_pending_memories():
+    """Get memories awaiting approval"""
+    try:
+        limit = int(request.args.get("limit", 50))
+        npc = request.args.get("npc")
+        team = request.args.get("team")
+        directory_path = request.args.get("directory_path")
+
+        command_history = CommandHistory(app.config.get('DB_PATH'))
+        results = command_history.get_pending_memories(limit=limit)
+
+        # Filter by scope if provided
+        if npc or team or directory_path:
+            filtered = []
+            for mem in results:
+                if npc and mem.get('npc') != npc:
+                    continue
+                if team and mem.get('team') != team:
+                    continue
+                if directory_path and mem.get('directory_path') != directory_path:
+                    continue
+                filtered.append(mem)
+            results = filtered
+
+        return jsonify({"memories": results, "count": len(results)})
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/api/memory/scope", methods=["GET"])
+def get_memories_by_scope():
+    """Get memories for a specific scope (npc/team/directory)"""
+    try:
+        npc = request.args.get("npc", "")
+        team = request.args.get("team", "")
+        directory_path = request.args.get("directory_path", "")
+        status = request.args.get("status")
+
+        command_history = CommandHistory(app.config.get('DB_PATH'))
+        results = command_history.get_memories_for_scope(
+            npc=npc,
+            team=team,
+            directory_path=directory_path,
+            status=status
+        )
+
+        return jsonify({"memories": results, "count": len(results)})
+
     except Exception as e:
+        traceback.print_exc()
         return jsonify({"error": str(e)}), 500
 
 
@@ -5388,7 +5766,7 @@ def text_to_speech_endpoint():
         import base64
         from npcpy.gen.audio_gen import (
             text_to_speech, get_available_engines,
-            pcm16_to_wav, KOKORO_VOICES
+            pcm16_to_wav
         )
 
         data = request.json or {}

{npcpy-1.3.11.dist-info → npcpy-1.3.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.11
+Version: 1.3.13
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.3.11.dist-info → npcpy-1.3.13.dist-info}/RECORD

@@ -4,10 +4,10 @@ npcpy/llm_funcs.py,sha256=M7GSSjqpcO2kxh7G2sGRBU34lmdW7Imd5KxYqc1PiO0,75114
 npcpy/main.py,sha256=RWoRIj6VQLxKdOKvdVyaq2kwG35oRpeXPvp1CAAoG-w,81
 npcpy/ml_funcs.py,sha256=UI7k7JR4XOH_VXR-xxLaO4r9Kyx_jBaEnp3TUIY7ZLQ,22657
 npcpy/npc_array.py,sha256=fVTxcMiXV-lvltmuwaRnTU9D3ikPq3-7k5wzp7MA5OY,40224
-npcpy/npc_compiler.py,sha256=9U6_F7qweURaL2nQgrF7I9OQEmYjOENmkBV-YChr3oM,118402
+npcpy/npc_compiler.py,sha256=W1umvhsbyCYoRYajPUKa642FcsX5Fcadh78n-Vzu2hM,120983
 npcpy/npc_sysenv.py,sha256=VH7le3xwxHvO55ZYCG1e-gj8X5YTSIqbIiU6ifSqhss,38917
 npcpy/npcs.py,sha256=eExuVsbTfrRobTRRptRpDm46jCLWUgbvy4_U7IUQo-c,744
-npcpy/serve.py,sha256=VjRwD4cDXgawD6L6yVl-8-oUWyYrfIgaKAhu9c0NjDI,229714
+npcpy/serve.py,sha256=IVbJE2RlqpKB-OllvTk-XU4SE8SA_-4bEtoZ21qJwG8,243318
 npcpy/tools.py,sha256=A5_oVmZkzGnI3BI-NmneuxeXQq-r29PbpAZP4nV4jrc,5303
 npcpy/data/__init__.py,sha256=1tcoChR-Hjn905JDLqaW9ElRmcISCTJdE7BGXPlym2Q,642
 npcpy/data/audio.py,sha256=o4auV8DQrAmZ4y84U3SofiwEuq5-ZBjGEZipQ9zPpGQ,22816
@@ -30,13 +30,13 @@ npcpy/gen/audio_gen.py,sha256=RoSElPUGfQimPBUcl9SP-ziIJxeI6XAr0A1882BZxXE,20646
 npcpy/gen/embeddings.py,sha256=QStTJ2ELiC379OEZsLEgGGIIFD267Y8zQchs7HRn2Zg,2089
 npcpy/gen/image_gen.py,sha256=SOZYpvlxSiAdDK9j750OEBKjm22OUNdXg1kQ10sJSy0,21853
 npcpy/gen/ocr.py,sha256=rgmXWHrCYX1Po-qG_LrNFbVYEZ8aaupxFTgparcoB_Y,6554
-npcpy/gen/response.py,sha256=Pw01M0UxjsXOPJlvShAbq9n6IVnvEqxT6MQaLyEwJFs,48505
+npcpy/gen/response.py,sha256=fLd-ORRMI_s3yRNMH1TQodGk17u_G0xofS1lqfqH4r0,51121
 npcpy/gen/video_gen.py,sha256=RFi3Zcq_Hn3HIcfoF3mijQ6G7RYFZaM_9pjPTh-8E64,3239
 npcpy/gen/world_gen.py,sha256=_8ytE7E3QVQ5qiX8DmOby-xd0d9zV20rRI6Wkpf-qcY,18922
 npcpy/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 npcpy/memory/command_history.py,sha256=pjqcSBHXzdQTViSjHsBP2ohRSYnJ33h2bYARGcLvBfs,62253
 npcpy/memory/kg_vis.py,sha256=TrQQCRh_E7Pyr-GPAHLSsayubAfGyf4HOEFrPB6W86Q,31280
-npcpy/memory/knowledge_graph.py,sha256=pjqcHjAh-Bfe6Q9fvNkBpg-TMjPTgynB6PhLSWWtPzI,48720
+npcpy/memory/knowledge_graph.py,sha256=X3qqlDcuzGUjRgQWleQzafGKgNw8QRz2ar2gYuCvUq8,48600
 npcpy/memory/memory_processor.py,sha256=6PfVnSBA9ag5EhHJinXoODfEPTlDDoaT0PtCCuZO6HI,2598
 npcpy/memory/search.py,sha256=glN6WYzaixcoDphTEHAXSMX3vKZGjR12Jx9YVL_gYfE,18433
 npcpy/mix/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -53,8 +53,8 @@ npcpy/work/browser.py,sha256=p2PeaoZdAXipFuAgKCCB3aXXLE_p3yIRqC87KlZKZWc,679
 npcpy/work/desktop.py,sha256=F3I8mUtJp6LAkXodsh8hGZIncoads6c_2Utty-0EdDA,2986
 npcpy/work/plan.py,sha256=QyUwg8vElWiHuoS-xK4jXTxxHvkMD3VkaCEsCmrEPQk,8300
 npcpy/work/trigger.py,sha256=P1Y8u1wQRsS2WACims_2IdkBEar-iBQix-2TDWoW0OM,9948
-npcpy-1.3.11.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
-npcpy-1.3.11.dist-info/METADATA,sha256=jRdfngd30yMIL7slCyAgYQkz_Vx32Bn1fxDv45X-lP8,37885
-npcpy-1.3.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-npcpy-1.3.11.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
-npcpy-1.3.11.dist-info/RECORD,,
+npcpy-1.3.13.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
+npcpy-1.3.13.dist-info/METADATA,sha256=iImjyVCj8NyORUAC5EoruV2IeNAzvGA46JFtB074pI0,37885
+npcpy-1.3.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcpy-1.3.13.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
+npcpy-1.3.13.dist-info/RECORD,,