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

npcsh-1.1.15.data/data/npcsh/npc_team/delegate.jinx

@@ -0,0 +1,184 @@
+jinx_name: delegate
+description: Delegate a task to another NPC with review and feedback loop until completion. Choose the NPC whose directive best matches the task.
+inputs:
+  - npc_name:
+      description: "Name of the NPC to delegate to"
+  - task:
+      description: "The task or request to delegate to the NPC"
+  - max_iterations: "10"
+steps:
+  - name: delegate_with_review
+    engine: python
+    code: |
+      from termcolor import colored
+      from npcpy.llm_funcs import get_llm_response
+
+      # Try to get spinner for status updates
+      try:
+          from npcsh.ui import get_current_spinner
+          spinner = get_current_spinner()
+      except:
+          spinner = None
+
+      target_name = {{ npc_name | default("") | tojson }}.lower().strip()
+      task_request = {{ task | default("") | tojson }}
+      max_iters = int({{ max_iterations | default("10") | tojson }} or "10")
+
+      team_obj = context.get('team') or getattr(npc, 'team', None)
+      orchestrator = context.get('npc') or npc
+      orchestrator_name = getattr(orchestrator, 'name', 'orchestrator')
+
+      if not team_obj:
+          output = "Error: No team available for delegation"
+          exit()
+
+      if not hasattr(team_obj, 'npcs') or target_name not in team_obj.npcs:
+          available = list(team_obj.npcs.keys()) if hasattr(team_obj, 'npcs') else []
+          output = "Error: NPC '{}' not found. Available: {}".format(target_name, ', '.join(available))
+          exit()
+
+      target_npc = team_obj.npcs[target_name]
+      target_jinxs = dict((k, v) for k, v in target_npc.jinxs_dict.items() if k != 'delegate')
+
+      sep = '-' * 60
+      print(colored("\n" + sep, "cyan"))
+      print(colored("  Delegating to @" + target_name, "yellow", attrs=["bold"]))
+      task_preview = task_request[:100] + ('...' if len(task_request) > 100 else '')
+      print(colored("  Task: " + task_preview, "white", attrs=["dark"]))
+      print(colored(sep + "\n", "cyan"))
+      print(colored("  [{}] Model: {}".format(target_name, target_npc.model), "white", attrs=["dark"]))
+      jinx_list = ', '.join(list(target_jinxs.keys())[:8])
+      print(colored("  [{}] Jinxs: {}...".format(target_name, jinx_list), "white", attrs=["dark"]))
+
+      # Update spinner to show sub-agent
+      if spinner:
+          spinner.set_message("{} delegated to {}".format(orchestrator_name, target_name))
+
+      current_task = task_request
+      iteration = 0
+      final_output = None
+      task_complete = False
+
+      while iteration < max_iters and not task_complete:
+          iteration += 1
+
+          # Update spinner with current iteration
+          if spinner:
+              spinner.set_message("{} working (iter {}/{})".format(target_name, iteration, max_iters))
+
+          if iteration > 1:
+              print(colored("\n" + sep, "yellow"))
+              iter_msg = "  Iteration {}/{} - Re-tasking @{}".format(iteration, max_iters, target_name)
+              print(colored(iter_msg, "yellow", attrs=["bold"]))
+              print(colored(sep + "\n", "yellow"))
+
+          try:
+              result = target_npc.check_llm_command(
+                  current_task,
+                  context=context,
+                  team=team_obj,
+                  jinxs=target_jinxs,
+                  stream=False,
+              )
+
+              if isinstance(result, dict):
+                  delegate_output = result.get('output') or result.get('response') or str(result)
+                  delegate_messages = result.get('messages', [])
+              else:
+                  delegate_output = str(result)
+                  delegate_messages = []
+
+              print(colored("\n" + sep, "cyan"))
+              print(colored("  @{} iteration {} complete".format(target_name, iteration), "green"))
+              print(colored(sep + "\n", "cyan"))
+
+              # Update spinner for review phase
+              if spinner:
+                  spinner.set_message("{} reviewing {}'s work".format(orchestrator_name, target_name))
+
+              # Build review prompt without f-strings to avoid YAML issues
+              output_preview = delegate_output[:2000] if delegate_output else 'No output received'
+              msg_preview = str(delegate_messages[-5:]) if delegate_messages else 'No messages'
+
+              review_lines = [
+                  "You are reviewing work done by @{} on this task:".format(target_name),
+                  "",
+                  "ORIGINAL TASK: " + task_request,
+                  "",
+                  "ITERATION: {}/{}".format(iteration, max_iters),
+                  "",
+                  "SUB-AGENT OUTPUT:",
+                  output_preview,
+                  "",
+                  "RECENT MESSAGES:",
+                  msg_preview,
+                  "",
+                  "Evaluate if the task is complete. Consider:",
+                  "1. Did the sub-agent accomplish what was asked?",
+                  "2. Are there obvious errors or incomplete steps?",
+                  "3. For GUI tasks: Did they fill in all required fields?",
+                  "",
+                  "Respond EXACTLY like this:",
+                  "COMPLETE: YES or NO",
+                  "FEEDBACK: If NO, what should be done next",
+                  "SUMMARY: Brief summary of progress"
+              ]
+              review_prompt = "\n".join(review_lines)
+
+              review_result = get_llm_response(
+                  review_prompt,
+                  model=getattr(orchestrator, 'model', 'gemini-2.5-flash'),
+                  provider=getattr(orchestrator, 'provider', 'gemini'),
+                  npc=orchestrator,
+                  temperature=0.3
+              )
+
+              review_text = str(review_result.get('response', ''))
+              is_complete = 'COMPLETE: YES' in review_text.upper()
+
+              feedback = ""
+              if 'FEEDBACK:' in review_text:
+                  fb_start = review_text.find('FEEDBACK:') + 9
+                  fb_end = review_text.find('SUMMARY:', fb_start) if 'SUMMARY:' in review_text else len(review_text)
+                  feedback = review_text[fb_start:fb_end].strip()
+
+              summary = ""
+              if 'SUMMARY:' in review_text:
+                  summary = review_text[review_text.find('SUMMARY:') + 8:].strip()
+
+              if is_complete:
+                  task_complete = True
+                  print(colored("\n  Task completed successfully", "green", attrs=["bold"]))
+                  if summary:
+                      print(colored("  Summary: " + summary[:200], "white", attrs=["dark"]))
+                  final_output = "[{}] Task completed.\n{}".format(target_name, summary)
+              else:
+                  print(colored("\n  Task incomplete - providing feedback", "yellow"))
+                  if feedback:
+                      print(colored("  Feedback: " + feedback[:200] + "...", "white", attrs=["dark"]))
+
+                  followup_lines = [
+                      "Continue the previous task. Feedback from orchestrator:",
+                      "",
+                      "ORIGINAL TASK: " + task_request,
+                      "",
+                      "FEEDBACK: " + feedback,
+                      "",
+                      "Continue and complete the task based on this feedback."
+                  ]
+                  current_task = "\n".join(followup_lines)
+
+                  if delegate_messages:
+                      context['messages'] = delegate_messages
+
+          except Exception as e:
+              print(colored("  Error in iteration {}: {}".format(iteration, e), "red"))
+              final_output = "Error delegating to {}: {}".format(target_name, str(e))
+              break
+
+      if not task_complete and iteration >= max_iters:
+          print(colored("\n  Max iterations ({}) reached".format(max_iters), "yellow"))
+          status = summary if summary else 'Unknown'
+          final_output = "[{}] Task incomplete after {} iterations. Status: {}".format(target_name, max_iters, status)
+
+      output = final_output or "[{}]: No output received".format(target_name)

{npcsh/npc_team/jinxs/utils → npcsh-1.1.15.data/data/npcsh/npc_team}/edit_file.jinx

@@ -13,9 +13,9 @@ steps:
       from npcpy.llm_funcs import get_llm_response
       
     
-      file_path = os.path.expanduser("{{ file_path }}")
-      edit_instructions = "{{ edit_instructions }}"
-      backup_str = "{{ backup }}"
+      file_path = os.path.expanduser({{ file_path | tojson }})
+      edit_instructions = {{ edit_instructions | string | tojson }}
+      backup_str = {{ backup | default("true") | string | tojson }}
       create_backup = backup_str.lower() not in ('false', 'no', '0', '')
       
     

npcsh-1.1.15.data/data/npcsh/npc_team/frederic.npc

@@ -0,0 +1,27 @@
+name: frederic
+ascii_art: |
+  ❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️
+  ███████ ██████  ███████ ██████  ███████ ██████  ██  ██████
+  ██      ██   ██ ██      ██   ██ ██      ██   ██ ██ ██
+  █████   ██████  █████   ██   ██ █████   ██████  ██ ██  🐻‍❄️
+  ██      ██   ██ ██      ██   ██ ██      ██   ██ ██ ██
+  ██      ██   ██ ███████ ██████  ███████ ██   ██ ██  ██████
+  ❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️
+colors:
+  top: "224,255,255"
+  bottom: "173,216,230"
+primary_directive: |
+  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-1.1.15.data/data/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-1.1.15.data/data/npcsh/npc_team/jinxs.jinx

@@ -0,0 +1,176 @@
+jinx_name: jinxs
+description: "Show available jinxs organized by folder. Use /jinxs <path> for details on a specific folder."
+inputs:
+  - path: "" # Optional path to show details for (e.g., "lib/core", "bin")
+steps:
+  - name: list_jinxs
+    engine: python
+    code: |
+      import os
+      from pathlib import Path
+      import yaml
+
+      filter_path = context.get('path', '').strip()
+
+      # Find jinxs directory from team or fallback
+      jinxs_dir = None
+      if hasattr(npc, 'team') and npc.team:
+          if hasattr(npc.team, 'jinxs_dir') and npc.team.jinxs_dir:
+              jinxs_dir = Path(npc.team.jinxs_dir)
+          elif hasattr(npc.team, 'team_path') and npc.team.team_path:
+              candidate = Path(npc.team.team_path) / "jinxs"
+              if candidate.exists():
+                  jinxs_dir = candidate
+
+      if not jinxs_dir:
+          # Fallback to global jinxs
+          global_jinxs = Path.home() / ".npcsh" / "npc_team" / "jinxs"
+          if global_jinxs.exists():
+              jinxs_dir = global_jinxs
+
+      if not jinxs_dir or not jinxs_dir.exists():
+          output = "Error: Could not find jinxs directory"
+          exit()
+
+      def get_jinx_info(jinx_path):
+          """Extract name and description from a jinx file."""
+          try:
+              with open(jinx_path, 'r') as f:
+                  content = f.read()
+                  # Parse just the header (before steps:)
+                  header = content.split('steps:')[0] if 'steps:' in content else content
+                  data = yaml.safe_load(header)
+                  name = data.get('jinx_name', jinx_path.stem)
+                  desc = data.get('description', 'No description')
+                  return name, desc
+          except:
+              return jinx_path.stem, 'No description'
+
+      def get_folder_structure(base_path):
+          """Get jinxs organized by folder."""
+          structure = {}
+          for root, dirs, files in os.walk(base_path):
+              # Skip hidden directories
+              dirs[:] = [d for d in dirs if not d.startswith('.')]
+
+              jinx_files = [f for f in files if f.endswith('.jinx')]
+              if jinx_files:
+                  rel_path = Path(root).relative_to(base_path)
+                  rel_str = str(rel_path) if str(rel_path) != '.' else 'root'
+                  structure[rel_str] = []
+                  for jf in sorted(jinx_files):
+                      jinx_path = Path(root) / jf
+                      name, desc = get_jinx_info(jinx_path)
+                      structure[rel_str].append((name, desc, jf))
+          return structure
+
+      output_lines = []
+
+      if filter_path:
+          # Show details for a specific path
+          target_path = jinxs_dir / filter_path
+          if not target_path.exists():
+              # Try to find a matching folder
+              matches = []
+              for root, dirs, files in os.walk(jinxs_dir):
+                  rel = Path(root).relative_to(jinxs_dir)
+                  if filter_path in str(rel) or filter_path in Path(root).name:
+                      matches.append(rel)
+
+              if matches:
+                  output_lines.append(f"No exact match for '{filter_path}'. Did you mean:\n")
+                  for m in matches[:5]:
+                      output_lines.append(f"  /jinxs {m}\n")
+                  output = "".join(output_lines)
+                  exit()
+              else:
+                  output = f"No jinxs found at path: {filter_path}"
+                  exit()
+
+          # Get jinxs in this path
+          structure = get_folder_structure(target_path)
+          if not structure:
+              # Check if it's a single folder with jinxs
+              jinx_files = list(target_path.glob("*.jinx"))
+              if jinx_files:
+                  output_lines.append(f"Jinxs in {filter_path}:\n\n")
+                  for jf in sorted(jinx_files):
+                      name, desc = get_jinx_info(jf)
+                      output_lines.append(f"  /{name}\n")
+                      output_lines.append(f"    {desc}\n\n")
+              else:
+                  output = f"No jinxs found at path: {filter_path}"
+                  exit()
+          else:
+              output_lines.append(f"Jinxs in {filter_path}:\n\n")
+              for folder, jinxs in sorted(structure.items()):
+                  if folder != 'root':
+                      output_lines.append(f"  {folder}/\n")
+                  for name, desc, filename in jinxs:
+                      prefix = "    " if folder != 'root' else "  "
+                      output_lines.append(f"{prefix}/{name} - {desc}\n")
+                  output_lines.append("\n")
+
+      else:
+          # Show overview organized by folder
+          structure = get_folder_structure(jinxs_dir)
+
+          output_lines.append("Available Jinxs\n")
+          output_lines.append("=" * 40 + "\n\n")
+
+          # Group by top-level folder
+          top_level = {}
+          for folder, jinxs in structure.items():
+              if folder == 'root':
+                  top = 'root'
+              else:
+                  top = folder.split('/')[0] if '/' in folder else folder
+
+              if top not in top_level:
+                  top_level[top] = {'subfolders': {}, 'jinxs': []}
+
+              if folder == top or folder == 'root':
+                  top_level[top]['jinxs'].extend(jinxs)
+              else:
+                  subfolder = '/'.join(folder.split('/')[1:])
+                  if subfolder not in top_level[top]['subfolders']:
+                      top_level[top]['subfolders'][subfolder] = []
+                  top_level[top]['subfolders'][subfolder].extend(jinxs)
+
+          # Display
+          folder_order = ['bin', 'lib', 'npc_studio', 'root']
+          sorted_folders = sorted(top_level.keys(), key=lambda x: (folder_order.index(x) if x in folder_order else 99, x))
+
+          for top in sorted_folders:
+              data = top_level[top]
+
+              if top == 'root':
+                  if data['jinxs']:
+                      output_lines.append("Root Jinxs:\n")
+                      for name, desc, _ in data['jinxs']:
+                          output_lines.append(f"  /{name} - {desc}\n")
+                      output_lines.append("\n")
+              else:
+                  total = len(data['jinxs'])
+                  for sf_jinxs in data['subfolders'].values():
+                      total += len(sf_jinxs)
+
+                  output_lines.append(f"{top}/ ({total} jinxs)\n")
+
+                  # Show direct jinxs
+                  if data['jinxs']:
+                      for name, desc, _ in data['jinxs'][:3]:
+                          output_lines.append(f"  /{name} - {desc}\n")
+                      if len(data['jinxs']) > 3:
+                          output_lines.append(f"  ... and {len(data['jinxs']) - 3} more\n")
+
+                  # Show subfolders summary
+                  if data['subfolders']:
+                      for subfolder, jinxs in sorted(data['subfolders'].items()):
+                          output_lines.append(f"  {subfolder}/ ({len(jinxs)} jinxs)\n")
+
+                  output_lines.append(f"  → /jinxs {top} for details\n\n")
+
+          output_lines.append("Use /jinxs <path> for details (e.g., /jinxs lib/core)\n")
+
+      output = "".join(output_lines)

npcsh-1.1.15.data/data/npcsh/npc_team/kadiefa.npc

@@ -0,0 +1,21 @@
+name: kadiefa
+ascii_art: |
+  🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️
+  ██   ██  █████  ██████  ██ ███████ ███████  █████
+  ██  ██  ██   ██ ██   ██ ██ ██      ██      ██   ██
+  █████   ███████ ██   ██ ██ █████   █████   ███████  🐆
+  ██  ██  ██   ██ ██   ██ ██ ██      ██      ██   ██
+  ██   ██ ██   ██ ██████  ██ ███████ ██      ██   ██
+  🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️🏔️
+colors:
+  top: "255,255,255"
+  bottom: "173,216,230"
+primary_directive: |
+  You are kadiefa, the exploratory snow leopard. You love to find new paths and to explore hidden gems.
+  You go into caverns no cat has ventured into before. You climb peaks that others call crazy.
+  Your role is to lead users on wandering explorations - deep research journeys that follow threads
+  wherever they lead. You help users explore complex research questions and think outside the box.
+  Use web search and browsing tools to discover new information.
+jinxs:
+  - lib/core/python
+  - bin/wander

npcsh-1.1.15.data/data/npcsh/npc_team/key_press.jinx

@@ -0,0 +1,26 @@
+jinx_name: key_press
+description: |
+  Press a keyboard key or key combination.
+  Valid keys: enter, tab, escape, backspace, delete, space, up, down, left, right,
+  home, end, pageup, pagedown, f1-f12, ctrl, alt, shift, command.
+  For combinations use + like: ctrl+a, ctrl+c, ctrl+v, alt+tab, ctrl+shift+t
+  For regular letters/numbers, use type_text instead.
+inputs:
+  - key: "enter"
+
+steps:
+  - name: perform_key
+    engine: python
+    code: |
+      from npcpy.work.desktop import perform_action
+
+      key = context.get('key', 'enter')
+      messages = context.get('messages', [])
+
+      try:
+          perform_action({'type': 'key', 'keys': key})
+          context['output'] = "Pressed key: " + str(key)
+      except Exception as e:
+          context['output'] = "Key press failed: " + str(e)
+
+      context['messages'] = messages

npcsh-1.1.15.data/data/npcsh/npc_team/launch_app.jinx

@@ -0,0 +1,37 @@
+jinx_name: launch_app
+description: Launch an application on the system
+inputs:
+  - command: ""  # Command to launch (e.g., "open -a Firefox" on macOS)
+
+steps:
+  - name: perform_launch
+    engine: python
+    code: |
+      import platform
+      from npcpy.work.desktop import perform_action
+
+      command = context.get('command', '')
+      messages = context.get('messages', [])
+
+      if not command:
+          system = platform.system()
+          if system == "Darwin":
+              examples = "open -a Firefox, open -a TextEdit"
+          elif system == "Windows":
+              examples = "start firefox, notepad, calc"
+          else:
+              examples = "firefox &, gedit &"
+          context['output'] = f"Usage: /launch_app <command>\nExamples: {examples}"
+          context['messages'] = messages
+          exit()
+
+      try:
+          result = perform_action({'type': 'bash', 'command': command})
+          if result.get('status') == 'success':
+              context['output'] = f"Launched: {command}"
+          else:
+              context['output'] = f"Launch failed: {result.get('message', 'unknown error')}"
+      except Exception as e:
+          context['output'] = f"Launch failed: {e}"
+
+      context['messages'] = messages

{npcsh/npc_team/jinxs/utils → npcsh-1.1.15.data/data/npcsh/npc_team}/load_file.jinx

@@ -10,7 +10,7 @@ steps:
       from npcpy.data.load import load_file_contents
       
       # Expand user path and get absolute path
-      file_path = os.path.expanduser("{{ file_path }}")
+      file_path = os.path.expanduser({{ file_path | tojson }})
       
       # Check if file exists
       if not os.path.exists(file_path):

npcsh-1.1.15.data/data/npcsh/npc_team/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()