npcpy 1.3.4__py3-none-any.whl → 1.3.5__py3-none-any.whl

npcpy/memory/command_history.py

@@ -196,8 +196,19 @@ def init_kg_schema(engine: Engine):
         Column('value', Text),
         schema=None
     )
-    
-    
+
+    # NPC version history for rollback support
+    npc_versions = Table('npc_versions', metadata,
+        Column('id', Integer, primary_key=True, autoincrement=True),
+        Column('npc_name', String(255), nullable=False),
+        Column('team_path', Text, nullable=False),  # path to npc_team directory
+        Column('version', Integer, nullable=False),
+        Column('content', Text, nullable=False),  # full YAML content
+        Column('created_at', DateTime, default=datetime.utcnow),
+        Column('commit_message', Text),  # optional description of change
+        schema=None
+    )
+
     metadata.create_all(engine, checkfirst=True)
 
 def load_kg_from_db(engine: Engine, team_name: str, npc_name: str, directory_path: str) -> Dict[str, Any]:
@@ -402,6 +413,100 @@ def save_kg_to_db(engine: Engine, kg_data: Dict[str, Any], team_name: str, npc_n
     except Exception as e:
         print(f"Failed to save KG for scope '({team_name}, {npc_name}, {directory_path})': {e}")
 
+
+# ============== NPC Version History Functions ==============
+
+def save_npc_version(engine: Engine, npc_name: str, team_path: str, content: str, commit_message: str = None) -> int:
+    """Save a new version of an NPC config. Returns the new version number."""
+    init_kg_schema(engine)  # Ensure table exists
+
+    with engine.begin() as conn:
+        # Get current max version
+        result = conn.execute(text("""
+            SELECT COALESCE(MAX(version), 0) as max_version
+            FROM npc_versions
+            WHERE npc_name = :npc_name AND team_path = :team_path
+        """), {"npc_name": npc_name, "team_path": team_path})
+        row = result.fetchone()
+        new_version = (row[0] if row else 0) + 1
+
+        # Insert new version
+        conn.execute(text("""
+            INSERT INTO npc_versions (npc_name, team_path, version, content, created_at, commit_message)
+            VALUES (:npc_name, :team_path, :version, :content, :created_at, :commit_message)
+        """), {
+            "npc_name": npc_name,
+            "team_path": team_path,
+            "version": new_version,
+            "content": content,
+            "created_at": datetime.utcnow(),
+            "commit_message": commit_message
+        })
+
+    return new_version
+
+
+def get_npc_versions(engine: Engine, npc_name: str, team_path: str) -> List[Dict[str, Any]]:
+    """Get all versions of an NPC config."""
+    init_kg_schema(engine)
+
+    with engine.connect() as conn:
+        result = conn.execute(text("""
+            SELECT id, version, created_at, commit_message
+            FROM npc_versions
+            WHERE npc_name = :npc_name AND team_path = :team_path
+            ORDER BY version DESC
+        """), {"npc_name": npc_name, "team_path": team_path})
+
+        return [
+            {
+                "id": row[0],
+                "version": row[1],
+                "created_at": row[2].isoformat() if row[2] else None,
+                "commit_message": row[3]
+            }
+            for row in result
+        ]
+
+
+def get_npc_version_content(engine: Engine, npc_name: str, team_path: str, version: int = None) -> Optional[str]:
+    """Get the content of a specific NPC version. If version is None, get latest."""
+    init_kg_schema(engine)
+
+    with engine.connect() as conn:
+        if version is None:
+            result = conn.execute(text("""
+                SELECT content FROM npc_versions
+                WHERE npc_name = :npc_name AND team_path = :team_path
+                ORDER BY version DESC LIMIT 1
+            """), {"npc_name": npc_name, "team_path": team_path})
+        else:
+            result = conn.execute(text("""
+                SELECT content FROM npc_versions
+                WHERE npc_name = :npc_name AND team_path = :team_path AND version = :version
+            """), {"npc_name": npc_name, "team_path": team_path, "version": version})
+
+        row = result.fetchone()
+        return row[0] if row else None
+
+
+def rollback_npc_to_version(engine: Engine, npc_name: str, team_path: str, version: int) -> Optional[str]:
+    """Rollback an NPC to a specific version. Returns the content if successful."""
+    content = get_npc_version_content(engine, npc_name, team_path, version)
+    if content is None:
+        return None
+
+    # Save as a new version with rollback message
+    save_npc_version(engine, npc_name, team_path, content, f"Rollback to version {version}")
+
+    # Write to file
+    file_path = os.path.join(team_path, f"{npc_name}.npc")
+    with open(file_path, 'w') as f:
+        f.write(content)
+
+    return content
+
+
 def generate_message_id() -> str:
     return str(uuid.uuid4())
 

npcpy/memory/knowledge_graph.py

@@ -871,7 +871,7 @@ def process_text_with_chroma(
     )
 
     
-    facts = extract_facts(text, model=model, provider=provider, npc=npc)
+    facts = get_facts(text, model=model, provider=provider, npc=npc)
 
     
     for i in range(0, len(facts), batch_size):

npcpy/npc_compiler.py

@@ -411,7 +411,12 @@ class Jinx:
         
         # _raw_steps will now hold the original, potentially templated, steps definition
         self._raw_steps = list(self.steps)
-        self.steps = [] # Will be populated after first-pass rendering
+        # If steps are already valid dicts (not needing Jinja templating), keep them
+        # Otherwise clear for first-pass rendering to populate
+        if self.steps and all(isinstance(s, dict) for s in self.steps):
+            pass  # Keep steps as-is for simple jinxes
+        else:
+            self.steps = []  # Will be populated after first-pass rendering
         self.parsed_files = {}
         if self.file_context:
             self.parsed_files = self._parse_file_patterns(self.file_context)
@@ -420,7 +425,8 @@ class Jinx:
         jinx_data = load_yaml_file(path)
         if not jinx_data:
             raise ValueError(f"Failed to load jinx from {path}")
-        self._source_path = path
+        # Set _source_path in the data so it's preserved after _load_from_data
+        jinx_data['_source_path'] = path
         self._load_from_data(jinx_data)
             
 
@@ -638,7 +644,8 @@ class Jinx:
                 extra_globals=extra_globals
             )
             # If an error occurred in a step, propagate it and stop execution
-            if "error" in context.get("output", ""):
+            output_str = str(context.get("output", ""))
+            if "error" in output_str.lower():
                 self._log_debug(f"DEBUG: Jinx '{self.jinx_name}' execution stopped due to error in step '{step.get('name', 'unnamed_step')}': {context['output']}")
                 break
 
@@ -705,37 +712,54 @@ class Jinx:
         
         if extra_globals:
             exec_globals.update(extra_globals)
-        
-        exec_locals = {} # Locals for this specific exec call
+
+        # Add context values directly as variables so jinx code can use them without Jinja
+        exec_globals.update(context)
+
+        # NOTE: Using same dict for globals and locals because when they're
+        # separate, imports end up in locals but nested functions can only see globals.
+        # This caused "name 'X' is not defined" errors when functions used imported names.
+        exec_locals = exec_globals  # Use same namespace so imports are visible in functions
 
         try:
             exec(rendered_code, exec_globals, exec_locals)
         except Exception as e:
             error_msg = (
-                f"Error executing step '{step_name}': "
+                f"Error executing step '{step_name}' in jinx '{self.jinx_name}': "
                 f"{type(e).__name__}: {e}"
             )
+            print(f"[JINX-ERROR] {error_msg}")
             context['output'] = error_msg
             self._log_debug(error_msg)
             return context
-        
+
         # Update the main context with any variables set in exec_locals
+        # But preserve context['output'] if jinx set it via context['output'] = ...
+        context_output = context.get("output")
         context.update(exec_locals)
-        
-        if "output" in exec_locals:
+
+        # If jinx set context['output'] directly, preserve it
+        if context_output is not None:
+            context["output"] = context_output
+            context[step_name] = context_output
+
+        # Only use exec_locals output if it was explicitly set (not still None from init)
+        if "output" in exec_locals and exec_locals["output"] is not None:
             outp = exec_locals["output"]
             context["output"] = outp
             context[step_name] = outp
 
-            if messages is not None:
-                messages.append({
-                    'role':'assistant', 
-                    'content': (
-                        f'Jinx {self.jinx_name} step {step_name} '
-                        f'executed: {outp}'
-                    )
-                })
-                context['messages'] = messages
+        # Append to messages if we have output
+        final_output = context.get("output")
+        if final_output is not None and messages is not None:
+            messages.append({
+                'role':'assistant',
+                'content': (
+                    f'Jinx {self.jinx_name} step {step_name} '
+                    f'executed: {final_output}'
+                )
+            })
+            context['messages'] = messages
         
         return context
         
@@ -925,6 +949,51 @@ def build_jinx_tool_catalog(jinxs: Dict[str, 'Jinx']) -> Dict[str, Dict[str, Any
     """Helper to build a name->tool_def catalog from a dict of Jinx objects."""
     return {name: jinx_to_tool_def(jinx_obj) for name, jinx_obj in jinxs.items()}
 
+def match_jinx_spec_to_names(jinx_spec: str, team_jinxs_dict: Dict[str, 'Jinx'], jinxs_base_dir: str) -> List[str]:
+    """
+    Match a jinx spec pattern to actual jinx names from the team's jinxs_dict.
+
+    Args:
+        jinx_spec: A spec like 'lib/core/python', 'lib/computer_use/*', or just 'python'
+        team_jinxs_dict: Dict mapping jinx_name -> Jinx object
+        jinxs_base_dir: Base directory where team jinxs are stored (e.g., '/path/to/npc_team/jinxs')
+
+    Returns:
+        List of jinx names that match the spec
+    """
+    matched_names = []
+
+    # First, check if it's a direct jinx name match
+    if jinx_spec in team_jinxs_dict:
+        return [jinx_spec]
+
+    # Normalize the spec (add .jinx extension if not present, for path matching)
+    spec_pattern = jinx_spec
+    if not spec_pattern.endswith('.jinx') and not spec_pattern.endswith('*'):
+        spec_pattern += '.jinx'
+
+    # Handle glob patterns
+    for jinx_name, jinx_obj in team_jinxs_dict.items():
+        source_path = getattr(jinx_obj, '_source_path', None)
+        if not source_path:
+            continue
+
+        # Get relative path from jinxs base directory
+        try:
+            rel_path = os.path.relpath(source_path, jinxs_base_dir)
+        except ValueError:
+            # Can happen on Windows with different drives
+            continue
+
+        # Match using fnmatch for glob support
+        if fnmatch.fnmatch(rel_path, spec_pattern):
+            matched_names.append(jinx_name)
+        # Also try matching without .jinx for patterns like lib/core/python
+        elif fnmatch.fnmatch(rel_path, spec_pattern.replace('.jinx', '') + '.jinx'):
+            matched_names.append(jinx_name)
+
+    return matched_names
+
 def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
     print(f"DEBUG extract_jinx_inputs called with args: {args}")
     print(f"DEBUG jinx.inputs: {jinx.inputs}")
@@ -1055,7 +1124,11 @@ class NPC:
             db_conn: Database connection
         """
         if not file and not name and not primary_directive:
-            raise ValueError("Either 'file' or 'name' and 'primary_directive' must be provided") 
+            raise ValueError("Either 'file' or 'name' and 'primary_directive' must be provided")
+
+        # Set team reference early so _load_from_file can use it for inheritance
+        self.team = team
+
         if file:
             if file.endswith(".npc"):
                 self._load_from_file(file)
@@ -1076,7 +1149,6 @@ class NPC:
                 self.jinxs_directory = None
             self.npc_directory = None
 
-        self.team = team # Store the team reference (can be None)
         # Only set jinxs_spec from parameter if it wasn't already set by _load_from_file
         if not hasattr(self, 'jinxs_spec') or jinxs is not None:
             self.jinxs_spec = jinxs or "*" # Store the jinx specification for later loading
@@ -1188,12 +1260,39 @@ class NPC:
             if self.team and hasattr(self.team, 'jinxs_dict') and self.team.jinxs_dict:
                 self.jinxs_dict.update(self.team.jinxs_dict)
         else: # If specific jinxs are requested, try to get them from team
-            for jinx_name in self.jinxs_spec:
-                if self.team and jinx_name in self.team.jinxs_dict:
-                    self.jinxs_dict[jinx_name] = self.team.jinxs_dict[jinx_name]
-
-        # Load NPC's own jinxs (if not already covered by team or if specific ones are requested)
+            if self.team and hasattr(self.team, 'jinxs_dict') and self.team.jinxs_dict:
+                # Determine the jinxs base directory for path matching
+                jinxs_base_dir = None
+                if hasattr(self.team, 'team_path') and self.team.team_path:
+                    jinxs_base_dir = os.path.join(self.team.team_path, 'jinxs')
+
+                for jinx_spec in self.jinxs_spec:
+                    # Use the helper to match spec patterns (paths, globs) to jinx names
+                    if jinxs_base_dir:
+                        matched_names = match_jinx_spec_to_names(jinx_spec, self.team.jinxs_dict, jinxs_base_dir)
+                    else:
+                        # Fallback to direct name match if no base dir
+                        matched_names = [jinx_spec] if jinx_spec in self.team.jinxs_dict else []
+
+                    for jinx_name in matched_names:
+                        if jinx_name in self.team.jinxs_dict:
+                            self.jinxs_dict[jinx_name] = self.team.jinxs_dict[jinx_name]
+
+        # Load NPC's own jinxs ONLY if:
+        # 1. The NPC has no team (standalone NPC), OR
+        # 2. The NPC's jinxs directory is different from the team's jinxs directory
+        # This prevents team NPCs with specific jinxs_spec from loading all team jinxs
+        should_load_from_directory = False
         if hasattr(self, 'npc_jinxs_directory') and self.npc_jinxs_directory and os.path.exists(self.npc_jinxs_directory):
+            if not self.team:
+                should_load_from_directory = True
+            elif hasattr(self.team, 'team_path') and self.team.team_path:
+                team_jinxs_dir = os.path.join(self.team.team_path, 'jinxs')
+                # Only load if NPC has its own separate jinxs directory
+                if os.path.normpath(self.npc_jinxs_directory) != os.path.normpath(team_jinxs_dir):
+                    should_load_from_directory = True
+
+        if should_load_from_directory:
             for jinx_obj in load_jinxs_from_directory(self.npc_jinxs_directory):
                 if jinx_obj.jinx_name not in self.jinxs_dict: # Only add if not already added from team
                     npc_jinxs_raw_list.append(jinx_obj)
@@ -1499,10 +1598,23 @@ class NPC:
         else:
             self.jinxs_spec = jinxs_spec
 
+        # Get model/provider from NPC file, or inherit from team
         self.model = npc_data.get("model")
         self.provider = npc_data.get("provider")
         self.api_url = npc_data.get("api_url")
         self.api_key = npc_data.get("api_key")
+
+        # Inherit from team if not set on NPC
+        if self.team:
+            if not self.model and hasattr(self.team, 'model'):
+                self.model = self.team.model
+            if not self.provider and hasattr(self.team, 'provider'):
+                self.provider = self.team.provider
+            if not self.api_url and hasattr(self.team, 'api_url'):
+                self.api_url = self.team.api_url
+            if not self.api_key and hasattr(self.team, 'api_key'):
+                self.api_key = self.team.api_key
+
         self.name = npc_data.get("name", self.name)
 
         self.npc_path = file
@@ -1561,7 +1673,7 @@ class NPC:
         if use_core_tools:
             dynamic_core_tools_list = [
                 self.think_step_by_step,
-                self.write_code
+                self.write_code,
             ]
 
             if self.command_history:
@@ -1707,7 +1819,39 @@ class NPC:
         response = self.get_llm_response(thinking_prompt, tool_choice = False)
         return response.get('response', 'Unable to process thinking request')
 
+    def write_code(self, task: str, language: str = "python") -> str:
+        """Write code to accomplish a task.
 
+        Args:
+            task: Description of what the code should do
+            language: Programming language to use (default: python)
+
+        Returns:
+            The generated code as a string
+        """
+        code_prompt = f"""Write {language} code to accomplish the following task:
+
+{task}
+
+Requirements:
+- Write clean, well-commented code
+- Include error handling where appropriate
+- Make sure the code is complete and runnable
+- Only output the code, no explanations before or after
+
+```{language}
+"""
+
+        response = self.get_llm_response(code_prompt, tool_choice=False)
+        code = response.get('response', '')
+
+        # Clean up the response - extract code if wrapped in markdown
+        if f'```{language}' in code:
+            code = code.split(f'```{language}')[-1]
+        if '```' in code:
+            code = code.split('```')[0]
+
+        return code.strip()
 
 
     def create_planning_state(self, goal: str) -> Dict[str, Any]:
@@ -2348,18 +2492,18 @@ class Team:
         if not os.path.exists(self.team_path):
             raise ValueError(f"Team directory not found: {self.team_path}")
         
-        # 1. Load all NPCs first (without initializing their jinxs yet)
+        # 1. Load team context first (model, provider, forenpc name, etc.)
+        self._load_team_context_file()
+
+        # 2. Load all NPCs (they can now inherit team's model/provider)
         for filename in os.listdir(self.team_path):
             if filename.endswith(".npc"):
                 npc_path = os.path.join(self.team_path, filename)
                 # Pass 'self' to NPC constructor for team reference
                 # Do NOT pass jinxs=... here, as it will be initialized later
-                npc = NPC(npc_path, db_conn=self.db_conn, team=self) 
+                npc = NPC(npc_path, db_conn=self.db_conn, team=self)
                 self.npcs[npc.name] = npc
-        
-        # 2. Load team context and determine forenpc name (string)
-        self._load_team_context_file() # This populates self.model, self.provider, self.forenpc_name etc.
-        
+
         # 3. Resolve and set self.forenpc (NPC object)
         if self.forenpc_name and self.forenpc_name in self.npcs:
             self.forenpc = self.npcs[self.forenpc_name]

npcpy/npc_sysenv.py

@@ -848,17 +848,17 @@ The current date and time are : {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
         if team_preferences:
             system_message += f"Team preferences: {team_preferences}\n"
 
-        # Add team members
+        # Add team members with their directives
         if hasattr(team, 'npcs') and team.npcs:
             members = []
             for name, member in team.npcs.items():
                 if name != npc.name:  # Don't list self
                     directive = getattr(member, 'primary_directive', '')
-                    # Get first line or first 100 chars
-                    desc = directive.split('\n')[0][:100] if directive else ''
-                    members.append(f"  - {name}: {desc}")
+                    # Include full directive (up to 500 chars) for better delegation decisions
+                    desc = directive[:500].strip() if directive else ''
+                    members.append(f"  - @{name}: {desc}")
             if members:
-                system_message += "\nTeam members (use delegate tool to assign tasks):\n" + "\n".join(members) + "\n"
+                system_message += "\nTeam members available for delegation:\n" + "\n".join(members) + "\n"
 
     system_message += """
     IMPORTANT: