npcsh 1.1.13__py3-none-any.whl → 1.1.15__py3-none-any.whl

npcsh/mcp_server.py

@@ -30,7 +30,8 @@ from typing import Optional, Dict, Any, List, Union, Callable, get_type_hints
 from functools import wraps
 import sys 
 
-from npcpy.llm_funcs import  generate_group_candidates, abstract, extract_facts, zoom_in,   execute_llm_command, gen_image
+from npcpy.llm_funcs import  generate_group_candidates, abstract, 
+zoom_in,   execute_llm_command, gen_image
 from npcpy.memory.search import search_similar_texts, execute_search_command, execute_rag_command,  answer_with_rag, execute_brainblast_command
 from npcpy.data.load import load_file_contents
 from npcpy.memory.command_history import CommandHistory

npcsh/npc.py

@@ -95,9 +95,20 @@ def main():
     global_model = args.model
     global_provider = args.provider
 
+    # Load team early so we can check for jinxs
+    try:
+        command_history, team, forenpc_obj = setup_shell()
+        # Load jinxs into router so they're recognized as commands
+        from npcsh._state import initialize_router_with_jinxs
+        initialize_router_with_jinxs(team, router)
+    except Exception as e:
+        print(f"Warning: Could not set up full npcsh environment: {e}", file=sys.stderr)
+        team = None
+        forenpc_obj = None
+
     is_valid_command = False
     command_name = None
-    
+
     if all_args:
         first_arg = all_args[0]
         if first_arg.startswith('/'):
@@ -145,15 +156,8 @@ 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("Falling back to basic NPC loading...", file=sys.stderr)
-        team = None
+    # Team already loaded above, just set up NPC
+    if not forenpc_obj:
         forenpc_obj = load_npc_by_name(args.npc, NPCSH_DB_PATH)
 
     npc_instance = None
@@ -173,25 +177,6 @@ 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
-        ):
-            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
@@ -245,12 +230,13 @@ def main():
                 )
                 
                 if (
-                    NPCSH_STREAM_OUTPUT 
+                    NPCSH_STREAM_OUTPUT
+                    and output is not None
                     and not isinstance(output, str)
                 ):
                     print_and_process_stream_with_markdown(
-                        output, 
-                        model_for_stream, 
+                        output,
+                        model_for_stream,
                         provider_for_stream
                     )
                 elif output is not None:
@@ -319,5 +305,71 @@ def main():
         sys.exit(1)
 
 
+def jinx_main():
+    """Entry point for bin jinxs called directly from CLI.
+
+    Parses arguments as key=value pairs and executes the jinx.
+    Example: nql show=1 model=daily_summary
+    """
+    import os
+
+    # Get jinx name from command name
+    jinx_name = os.path.basename(sys.argv[0])
+
+    # Parse remaining args as key=value pairs
+    args = sys.argv[1:]
+    jinx_args = []
+
+    for arg in args:
+        if arg in ['-h', '--help']:
+            print(f"Usage: {jinx_name} [key=value ...]")
+            print(f"\nRun the '{jinx_name}' jinx with specified parameters.")
+            print(f"\nExamples:")
+            print(f"  {jinx_name} show=1")
+            print(f"  {jinx_name} model=my_model db=~/mydb.db")
+            print(f"\nOr use: npc {jinx_name} [key=value ...]")
+            sys.exit(0)
+        jinx_args.append(arg)
+
+    # Build command string
+    if jinx_args:
+        command = f"/{jinx_name} " + " ".join(jinx_args)
+    else:
+        command = f"/{jinx_name}"
+
+    try:
+        _, team, forenpc_obj = setup_shell()
+
+        from npcsh._state import initialize_router_with_jinxs
+        initialize_router_with_jinxs(team, router)
+
+        # Update the global initial_state with team/npc context
+        initial_state.team = team
+        initial_state.npc = forenpc_obj
+        if forenpc_obj:
+            initial_state.chat_model = forenpc_obj.model or NPCSH_CHAT_MODEL
+            initial_state.chat_provider = forenpc_obj.provider or NPCSH_CHAT_PROVIDER
+
+        _, result = execute_slash_command(
+            command,
+            stdin_input=None,
+            state=initial_state,
+            stream=NPCSH_STREAM_OUTPUT,
+            router=router
+        )
+
+        if isinstance(result, dict):
+            output = result.get("output") or result.get("response")
+            if output is not None:
+                render_markdown(str(output))
+        elif result is not None:
+            render_markdown(str(result))
+
+    except Exception as e:
+        print(f"Error executing jinx '{jinx_name}': {e}", file=sys.stderr)
+        traceback.print_exc()
+        sys.exit(1)
+
+
 if __name__ == "__main__":
     main()

npcsh/npc_team/alicanto.npc

@@ -1,2 +1,23 @@
 name: alicanto
-primary_directive: You are Alicanto the mythical bird. You have been spotted and it is your job to lead users to explore the world. 
+ascii_art: |
+  ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
+   █████  ██      ██  ██████   █████  ███    ██ ████████  ██████
+  ██   ██ ██      ██ ██      ██   ██ ████   ██    ██    ██    ██
+  ███████ ██      ██ ██      ███████ ██ ██  ██    ██    ██    ██  🦅
+  ██   ██ ██      ██ ██      ██   ██ ██  ██ ██    ██    ██    ██
+  ██   ██ ███████ ██  ██████ ██   ██ ██   ████    ██     ██████
+  ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
+colors:
+  top: "255,215,0"
+  bottom: "218,165,32"
+primary_directive: |
+  You are alicanto, the research and exploration specialist of the NPC team.
+  Like the mythical bird, you lead users to discover valuable information.
+  Your role is web research, searching, and helping users explore topics.
+  Use search tools to find information and present findings clearly.
+jinxs:
+  - lib/core/search
+  - lib/core/sh
+  - lib/core/python
+  - lib/core/load_file
+  - lib/research/*

npcsh/npc_team/corca.npc

@@ -1,12 +1,31 @@
 name: corca
+ascii_art: |
+  ██████    ██████    ██████    ██████    ██████
+  ██    ██  ██    ██  ██    ██  ██    ██  ██🦌🦌██
+  ██        ██    ██  ██    ██  ██        ██🦌🦌██
+  ██        ██    ██  ████████  ██        ████████
+  ██        ██    ██  ██  ███   ██        ██    ██
+  ██    ██  ██    ██  ██   ███  ██    ██  ██    ██
+  ██████    ██████   ██    ███  ██████   ██    ██
+colors:
+  top: "64,224,208"
+  bottom: "255,165,0"
 primary_directive: |
-    You are corca, a distinguished member of the NPC team.
-    Your expertise is in the area of software development and
-    you have a knack for thinking through problems carefully.
-    You favor solutions that prioritize simplicity and clarity and
-    ought to always consider how some suggestion may increase rather than reduce tech debt
-    unnecessarily. Now, the key is in this last term, "unnecessarily".
-    You must distinguish carefully and when in doubt, opt to ask for further
-    information or clarification with concrete clear options that make it
-    easy for a user to choose.
+  You are corca, the software development specialist of the NPC team.
+  Your expertise is in writing, reviewing, and debugging code.
+  You think through problems carefully and favor solutions that prioritize simplicity and clarity.
+  Always consider how suggestions may increase rather than reduce tech debt unnecessarily.
+  When in doubt, ask for clarification with concrete options that make it easy for users to choose.
+
+  CRITICAL: You MUST ALWAYS use FULL ABSOLUTE PATHS for all file operations.
+  - NEVER use relative paths like "apps/api" or "./src"
+  - ALWAYS expand paths starting from root like "/Users/username/project/apps/api"
+  - When given a task, first determine the absolute path of the working directory using pwd
+  - Prefix all file paths with the full absolute path
+jinxs:
+  - lib/core/sh
+  - lib/core/python
+  - lib/core/edit_file
+  - lib/core/load_file
+  - lib/core/search
     

npcsh/npc_team/frederic.npc

@@ -1,6 +1,27 @@
 name: frederic
+ascii_art: |
+  ❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️
+  ███████ ██████  ███████ ██████  ███████ ██████  ██  ██████
+  ██      ██   ██ ██      ██   ██ ██      ██   ██ ██ ██
+  █████   ██████  █████   ██   ██ █████   ██████  ██ ██  🐻‍❄️
+  ██      ██   ██ ██      ██   ██ ██      ██   ██ ██ ██
+  ██      ██   ██ ███████ ██████  ███████ ██   ██ ██  ██████
+  ❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️
+colors:
+  top: "224,255,255"
+  bottom: "173,216,230"
 primary_directive: |
-    You are frederic the polar bear. Your job is help users think through problems and 
-    to provide straightforward ways forward on problems. Cut through the ice
-    to get to what matters and keep things simple. You are to respond in a
-    witty tone like richard feynman but with the romantic tambor of Frederic Chopin. 
+  You are frederic the polar bear - a fusion of Richard Feynman and Frederic Chopin.
+  You have Feynman's playful curiosity, his ability to explain complex physics simply,
+  and his irreverent wit. You also have Chopin's romantic soul, his passion for music,
+  and his ability to find beauty in mathematical structures.
+  You help users with hard math, physics problems, and music composition.
+  Cut through the ice to get to what matters. Make the complex feel simple and beautiful.
+jinxs:
+  - lib/core/python
+  - lib/core/sql
+  - lib/core/sh
+  - lib/core/load_file
+  - lib/core/search
+  - lib/gen/*
+  - bin/wander

npcsh/npc_team/guac.npc

@@ -0,0 +1,22 @@
+name: guac
+ascii_art: |
+  🟢🟢🟢🟢🟢
+  🟢          🟢
+  🟢
+  🟢
+  🟢
+  🟢      🟢🟢🟢   🟢    🟢   🟢🟢🟢    🟢🟢🟢
+  🟢           🟢  🟢    🟢    ⚫⚫🟢  🟢
+  🟢           🟢  🟢    🟢  ⚫🥑🧅⚫  🟢
+  🟢           🟢  🟢    🟢  ⚫🥑🍅⚫  🟢
+  🟢🟢🟢🟢🟢🟢    🟢🟢🟢🟢    ⚫⚫🟢   🟢🟢🟢
+primary_directive: |
+  You are guac, the data analysis specialist of the NPC team.
+  Your expertise is in loading, analyzing, and visualizing data.
+  You work with pandas DataFrames, numpy arrays, and matplotlib plots.
+  Help users load data files, run Python code for analysis, and create visualizations.
+jinxs:
+  - lib/core/python
+  - lib/core/sql
+  - lib/core/sh
+  - lib/core/load_file

npcsh/npc_team/jinxs/bin/nql.jinx

@@ -0,0 +1,141 @@
+jinx_name: nql
+description: "Run NPC-SQL models with AI-powered transformations. Supports cron scheduling."
+inputs:
+  - models_dir: "~/.npcsh/npc_team/models"
+  - db: "~/npcsh_history.db"
+  - model: ""
+  - schema: ""
+  - show: ""
+  - cron: ""
+  - install_cron: ""
+
+steps:
+  - name: run_nql
+    engine: python
+    code: |
+      import os
+      import sys
+      from pathlib import Path
+
+      models_dir = context.get('models_dir') or '~/.npcsh/npc_team/models'
+      db_path = context.get('db') or '~/npcsh_history.db'
+      model_name = context.get('model') or ''
+      schema = context.get('schema') or ''
+      list_models = context.get('show') or ''
+      cron_expr = context.get('cron') or ''
+      install_cron = context.get('install_cron') or ''
+
+      models_dir = os.path.expanduser(models_dir)
+      db_path = os.path.expanduser(db_path)
+
+      # Find NPC team directory
+      npc_dir = None
+      if os.path.exists('./npc_team'):
+          npc_dir = './npc_team'
+      elif os.path.exists(os.path.expanduser('~/.npcsh/npc_team')):
+          npc_dir = os.path.expanduser('~/.npcsh/npc_team')
+
+      # Import npcsql
+      try:
+          from npcpy.sql.npcsql import ModelCompiler, SQLModel
+      except ImportError:
+          output = "Error: npcpy.sql.npcsql not found. Install npcpy first."
+          raise SystemExit(1)
+
+      # List models mode
+      if list_models:
+          if not os.path.exists(models_dir):
+              output = "No models directory found at " + models_dir
+          else:
+              models_path = Path(models_dir)
+              sql_files = list(models_path.glob("**/*.sql"))
+              if not sql_files:
+                  output = "No .sql models found in " + models_dir
+              else:
+                  lines = ["Available NQL models in " + models_dir + ":", ""]
+                  for f in sorted(sql_files):
+                      rel = f.relative_to(models_path)
+                      # Check for nql functions
+                      with open(f, 'r') as fh:
+                          content = fh.read()
+                      has_nql = "nql." in content
+                      marker = " [NQL]" if has_nql else ""
+                      lines.append("  " + str(rel) + marker)
+                  output = "\n".join(lines)
+
+      # Install cron mode
+      elif install_cron:
+          import subprocess
+          # Parse cron expression and model
+          parts = install_cron.split()
+          if len(parts) < 5:
+              output = "Error: cron expression must have 5 fields (min hour day month weekday)"
+          else:
+              cron_time = " ".join(parts[:5])
+              cron_model = parts[5] if len(parts) > 5 else ""
+
+              # Build command
+              nql_cmd = "npc nql"
+              if cron_model:
+                  nql_cmd += " model=" + cron_model
+              nql_cmd += " models_dir=" + models_dir
+              nql_cmd += " db=" + db_path
+              if schema:
+                  nql_cmd += " schema=" + schema
+
+              cron_line = cron_time + " " + nql_cmd
+
+              # Get current crontab
+              try:
+                  result = subprocess.run(['crontab', '-l'], capture_output=True, text=True)
+                  current = result.stdout if result.returncode == 0 else ""
+              except:
+                  current = ""
+
+              # Check if already installed
+              if nql_cmd in current:
+                  output = "Cron job already exists for: " + nql_cmd
+              else:
+                  # Add new cron line
+                  new_crontab = current.rstrip() + "\n" + cron_line + "\n"
+                  proc = subprocess.run(['crontab', '-'], input=new_crontab, text=True, capture_output=True)
+                  if proc.returncode == 0:
+                      output = "Installed cron job:\n  " + cron_line
+                  else:
+                      output = "Failed to install cron: " + proc.stderr
+
+      # Run models mode
+      else:
+          if not os.path.exists(models_dir):
+              output = "Models directory not found: " + models_dir + "\nCreate it with: mkdir -p " + models_dir
+          else:
+              try:
+                  compiler = ModelCompiler(
+                      models_dir=models_dir,
+                      target_engine=db_path,
+                      npc_directory=npc_dir,
+                      target_schema=schema if schema else None
+                  )
+
+                  if model_name:
+                      # Run specific model
+                      compiler.discover_models()
+                      if model_name not in compiler.models:
+                          available = list(compiler.models.keys())
+                          output = "Model '" + model_name + "' not found. Available: " + str(available)
+                      else:
+                          print("Running model: " + model_name)
+                          df = compiler.execute_model(model_name)
+                          output = "Model '" + model_name + "' completed. Rows: " + str(len(df))
+                  else:
+                      # Run all models in dependency order
+                      results = compiler.run_all_models()
+                      lines = ["NQL run complete:", ""]
+                      for name, df in results.items():
+                          lines.append("  " + name + ": " + str(len(df)) + " rows")
+                      output = "\n".join(lines)
+
+              except Exception as e:
+                  output = "NQL Error: " + str(e)
+                  import traceback
+                  traceback.print_exc()

npcsh/npc_team/jinxs/bin/sync.jinx

@@ -0,0 +1,230 @@
+jinx_name: "sync"
+description: "Sync npc_team files from the npcsh repo to ~/.npcsh/npc_team. Detects local modifications before overwriting."
+inputs:
+  - force: "" # Use --force or -f to overwrite all files without prompting
+  - dry_run: "" # Use --dry-run or -d to preview changes without applying them
+  - jinxs: "" # Use --jinxs to sync only .jinx files
+  - npcs: "" # Use --npcs to sync only .npc files
+  - ctx: "" # Use --ctx to sync only .ctx files
+  - images: "" # Use --images to sync only image files (.png, .jpg, .jpeg)
+steps:
+  - name: "sync_npc_team"
+    engine: "python"
+    code: |
+      import os
+      import hashlib
+      import shutil
+      from pathlib import Path
+      from datetime import datetime
+
+      force = context.get('force', False)
+      dry_run = context.get('dry_run', False)
+      sync_jinxs = context.get('jinxs', False)
+      sync_npcs = context.get('npcs', False)
+      sync_ctx = context.get('ctx', False)
+      sync_images = context.get('images', False)
+
+      # Convert string flags to boolean
+      def to_bool(val):
+          if isinstance(val, bool):
+              return val
+          if isinstance(val, str):
+              return val.lower() in ('true', '1', 'yes', 'y')
+          return bool(val)
+
+      force = to_bool(force)
+      dry_run = to_bool(dry_run)
+      sync_jinxs = to_bool(sync_jinxs)
+      sync_npcs = to_bool(sync_npcs)
+      sync_ctx = to_bool(sync_ctx)
+      sync_images = to_bool(sync_images)
+
+      # If none specified, sync all
+      sync_all = not (sync_jinxs or sync_npcs or sync_ctx or sync_images)
+
+      # Find the repo npc_team directory
+      # Check common locations
+      possible_repo_paths = [
+          Path.home() / "npcww" / "npc-core" / "npcsh" / "npcsh" / "npc_team",
+          Path.home() / "npc-core" / "npcsh" / "npcsh" / "npc_team",
+          Path.home() / "repos" / "npcsh" / "npcsh" / "npc_team",
+          Path.home() / "Projects" / "npcsh" / "npcsh" / "npc_team",
+      ]
+
+      # Also check if we can find it via pip show
+      try:
+          import subprocess
+          result = subprocess.run(['pip', 'show', 'npcsh', '-f'], capture_output=True, text=True)
+          if result.returncode == 0:
+              for line in result.stdout.split('\n'):
+                  if line.startswith('Location:'):
+                      pip_path = Path(line.split(':', 1)[1].strip()) / "npcsh" / "npc_team"
+                      if pip_path.exists():
+                          possible_repo_paths.insert(0, pip_path)
+      except:
+          pass
+
+      repo_npc_team = None
+      for path in possible_repo_paths:
+          if path.exists() and path.is_dir():
+              repo_npc_team = path
+              break
+
+      local_npc_team = Path.home() / ".npcsh" / "npc_team"
+
+      if not repo_npc_team:
+          context['output'] = "Error: Could not find npcsh repo npc_team directory.\nSearched:\n" + "\n".join(f"  - {p}" for p in possible_repo_paths)
+          exit()
+
+      if not local_npc_team.exists():
+          context['output'] = f"Error: Local npc_team directory not found at {local_npc_team}"
+          exit()
+
+      def get_file_hash(filepath):
+          """Get MD5 hash of file contents."""
+          try:
+              with open(filepath, 'rb') as f:
+                  return hashlib.md5(f.read()).hexdigest()
+          except:
+              return None
+
+      def get_files_recursive(base_path, extensions=None):
+          """Get all files recursively, optionally filtered by extensions."""
+          files = []
+          for root, dirs, filenames in os.walk(base_path):
+              # Skip .git directories
+              dirs[:] = [d for d in dirs if d != '.git']
+              for filename in filenames:
+                  if filename.startswith('.'):
+                      continue
+                  if extensions and not any(filename.endswith(ext) for ext in extensions):
+                      continue
+                  full_path = Path(root) / filename
+                  rel_path = full_path.relative_to(base_path)
+                  files.append(rel_path)
+          return files
+
+      # Build list of extensions to sync based on flags
+      sync_extensions = []
+      if sync_all or sync_npcs:
+          sync_extensions.append('.npc')
+      if sync_all or sync_ctx:
+          sync_extensions.append('.ctx')
+      if sync_all or sync_jinxs:
+          sync_extensions.append('.jinx')
+      if sync_all or sync_images:
+          sync_extensions.extend(['.png', '.jpg', '.jpeg'])
+
+      # Get files from repo
+      repo_files = get_files_recursive(repo_npc_team, sync_extensions)
+
+      output_lines = []
+      output_lines.append(f"Syncing from: {repo_npc_team}")
+      output_lines.append(f"Syncing to:   {local_npc_team}")
+
+      # Show what's being synced
+      sync_types = []
+      if sync_all:
+          sync_types.append("all")
+      else:
+          if sync_npcs: sync_types.append("npcs")
+          if sync_ctx: sync_types.append("ctx")
+          if sync_jinxs: sync_types.append("jinxs")
+          if sync_images: sync_types.append("images")
+      output_lines.append(f"Syncing: {', '.join(sync_types)}")
+
+      if dry_run:
+          output_lines.append("\n[DRY RUN - No changes will be made]\n")
+      output_lines.append("")
+
+      new_files = []
+      updated_files = []
+      modified_locally = []
+      unchanged_files = []
+
+      for rel_path in repo_files:
+          repo_file = repo_npc_team / rel_path
+          local_file = local_npc_team / rel_path
+
+          if not local_file.exists():
+              new_files.append(rel_path)
+          else:
+              repo_hash = get_file_hash(repo_file)
+              local_hash = get_file_hash(local_file)
+
+              if repo_hash == local_hash:
+                  unchanged_files.append(rel_path)
+              else:
+                  # Check if local file is newer (possibly modified by user)
+                  repo_mtime = repo_file.stat().st_mtime
+                  local_mtime = local_file.stat().st_mtime
+
+                  if local_mtime > repo_mtime:
+                      modified_locally.append((rel_path, local_mtime, repo_mtime))
+                  else:
+                      updated_files.append(rel_path)
+
+      # Report findings
+      if new_files:
+          output_lines.append(f"New files to add ({len(new_files)}):")
+          for f in new_files:
+              output_lines.append(f"  + {f}")
+          output_lines.append("")
+
+      if updated_files:
+          output_lines.append(f"Files to update ({len(updated_files)}):")
+          for f in updated_files:
+              output_lines.append(f"  ~ {f}")
+          output_lines.append("")
+
+      if modified_locally:
+          output_lines.append(f"Locally modified files ({len(modified_locally)}):")
+          for f, local_t, repo_t in modified_locally:
+              local_dt = datetime.fromtimestamp(local_t).strftime('%Y-%m-%d %H:%M')
+              repo_dt = datetime.fromtimestamp(repo_t).strftime('%Y-%m-%d %H:%M')
+              output_lines.append(f"  ! {f}")
+              output_lines.append(f"      local: {local_dt}  repo: {repo_dt}")
+          if not force:
+              output_lines.append("  (use --force to overwrite these)")
+          output_lines.append("")
+
+      if unchanged_files:
+          output_lines.append(f"Already up to date: {len(unchanged_files)} files")
+          output_lines.append("")
+
+      # Perform sync if not dry run
+      if not dry_run:
+          synced = 0
+          skipped = 0
+
+          # Sync new files
+          for rel_path in new_files:
+              src = repo_npc_team / rel_path
+              dst = local_npc_team / rel_path
+              dst.parent.mkdir(parents=True, exist_ok=True)
+              shutil.copy2(src, dst)
+              synced += 1
+
+          # Sync updated files
+          for rel_path in updated_files:
+              src = repo_npc_team / rel_path
+              dst = local_npc_team / rel_path
+              dst.parent.mkdir(parents=True, exist_ok=True)
+              shutil.copy2(src, dst)
+              synced += 1
+
+          # Handle locally modified files
+          for rel_path, _, _ in modified_locally:
+              if force:
+                  src = repo_npc_team / rel_path
+                  dst = local_npc_team / rel_path
+                  shutil.copy2(src, dst)
+                  synced += 1
+              else:
+                  skipped += 1
+
+          output_lines.append(f"Synced: {synced} files")
+          if skipped:
+              output_lines.append(f"Skipped: {skipped} locally modified files")
+
+      context['output'] = "\n".join(output_lines)