npcsh 1.1.17__py3-none-any.whl → 1.1.19__py3-none-any.whl

npcsh/npc_team/jinxs/lib/core/search/web_search.jinx

@@ -1,17 +1,26 @@
 jinx_name: web_search
-description: Search the web for information
+description: Search the web with interactive TUI
 inputs:
 - query: ""
 - provider: ""
 - num_results: "10"
+- text: "false"
 
 steps:
   - name: search_web
     engine: python
     code: |
+      import os
+      import sys
+      import tty
+      import termios
+      import webbrowser
+      import subprocess
       from npcpy.data.web import search_web
 
       query = context.get('query', '').strip()
+      text_mode = context.get('text', '').lower() in ('true', '1', 'yes')
+
       if not query:
           lines = [
               "Usage: /web_search <query>",
@@ -19,6 +28,15 @@ steps:
               "Options:",
               "  provider    - Search provider (default uses state.search_provider)",
               "  num_results - Number of results (default 10)",
+              "  text        - Text-only output, no TUI (true/false)",
+              "",
+              "TUI Controls:",
+              "  j/k or arrows - Navigate",
+              "  p             - Preview page content",
+              "  o             - Open in browser",
+              "  i             - Open in incognide",
+              "  c             - Copy URL to clipboard",
+              "  q/ESC         - Quit",
               "",
               "Examples:",
               "  /web_search python asyncio tutorial",
@@ -32,20 +50,234 @@ steps:
           except:
               pass
           num_results = int(context.get('num_results') or 10)
+
           try:
-              results = search_web(query, provider=provider, num_results=num_results)
-              if results:
-                  lines = []
-                  for res in results:
+              raw_results = search_web(query, provider=provider, num_results=num_results)
+
+              # Normalize results
+              results = []
+              if raw_results:
+                  for res in raw_results:
                       if isinstance(res, dict):
-                          title = res.get('title', '')
-                          url = res.get('url', res.get('link', ''))
-                          lines.append("- " + title + " " + url)
+                          results.append({
+                              'title': res.get('title', 'No title'),
+                              'url': res.get('url', res.get('link', '')),
+                              'snippet': res.get('snippet', res.get('description', ''))
+                          })
                       else:
-                          lines.append("- " + str(res))
+                          results.append({'title': str(res)[:50], 'url': str(res), 'snippet': ''})
+
+              if not results:
+                  context['output'] = "No web results found."
+              elif text_mode:
+                  # Text-only output
+                  lines = []
+                  for res in results:
+                      lines.append(f"- {res['title']}")
+                      lines.append(f"  {res['url']}")
+                      if res.get('snippet'):
+                          lines.append(f"  {res['snippet'][:100]}...")
+                      lines.append("")
                   context['output'] = "\n".join(lines)
               else:
-                  context['output'] = "No web results found."
+                  # Interactive TUI mode
+                  def get_terminal_size():
+                      try:
+                          size = os.get_terminal_size()
+                          return size.columns, size.lines
+                      except:
+                          return 80, 24
+
+                  def get_domain(url):
+                      try:
+                          from urllib.parse import urlparse
+                          return urlparse(url).netloc[:25]
+                      except:
+                          return url[:25]
+
+                  width, height = get_terminal_size()
+                  selected = 0
+                  scroll = 0
+                  list_height = height - 5
+                  mode = 'list'
+                  preview_scroll = 0
+                  preview_content = []
+
+                  fd = sys.stdin.fileno()
+                  old_settings = termios.tcgetattr(fd)
+
+                  try:
+                      tty.setcbreak(fd)
+                      sys.stdout.write('\033[?25l')
+                      sys.stdout.write('\033[2J\033[H')
+
+                      while True:
+                          width, height = get_terminal_size()
+                          list_height = height - 5
+
+                          if mode == 'list':
+                              if selected < scroll:
+                                  scroll = selected
+                              elif selected >= scroll + list_height:
+                                  scroll = selected - list_height + 1
+
+                          sys.stdout.write('\033[H')
+
+                          # Header
+                          if mode == 'list':
+                              header = f" WEB SEARCH ({len(results)} results): '{query}' "
+                          else:
+                              header = f" PREVIEW: {results[selected]['title'][:width-12]} "
+                          sys.stdout.write(f'\033[44;37;1m{header.ljust(width)}\033[0m\n')
+
+                          # Column headers
+                          if mode == 'list':
+                              col_header = f' {"#":<3} {"DOMAIN":<25} {"TITLE":<50}'
+                              sys.stdout.write(f'\033[90m{col_header[:width]}\033[0m\n')
+                          else:
+                              sys.stdout.write(f'\033[90m{"─" * width}\033[0m\n')
+
+                          if mode == 'list':
+                              for i in range(list_height):
+                                  idx = scroll + i
+                                  sys.stdout.write(f'\033[{3+i};1H\033[K')
+                                  if idx >= len(results):
+                                      continue
+
+                                  r = results[idx]
+                                  num = str(idx + 1)
+                                  domain = get_domain(r['url'])
+                                  title = r['title'][:55].replace('\n', ' ')
+
+                                  line = f" {num:<3} {domain:<25} {title}"
+                                  line = line[:width-1]
+
+                                  if idx == selected:
+                                      sys.stdout.write(f'\033[47;30;1m>{line}\033[0m')
+                                  else:
+                                      sys.stdout.write(f' {line}')
+
+                              # Status bar
+                              sys.stdout.write(f'\033[{height-2};1H\033[K\033[90m{"─" * width}\033[0m')
+                              sel = results[selected] if results else {}
+                              snippet = (sel.get('snippet') or '')[:width-2]
+                              sys.stdout.write(f'\033[{height-1};1H\033[K {snippet}'.ljust(width))
+                              sys.stdout.write(f'\033[{height};1H\033[K\033[44;37m j/k:Nav p:Preview o:Open i:Incog c:Copy q:Quit [{selected+1}/{len(results)}] \033[0m')
+
+                          else:  # preview mode
+                              for i in range(list_height):
+                                  idx = preview_scroll + i
+                                  sys.stdout.write(f'\033[{3+i};1H\033[K')
+                                  if idx < len(preview_content):
+                                      sys.stdout.write(preview_content[idx][:width-1])
+
+                              sys.stdout.write(f'\033[{height-2};1H\033[K\033[90m{"─" * width}\033[0m')
+                              sys.stdout.write(f'\033[{height-1};1H\033[K [{preview_scroll+1}/{len(preview_content)} lines]')
+                              sys.stdout.write(f'\033[{height};1H\033[K\033[44;37m j/k:Scroll b:Back o:Open c:Copy q:Quit \033[0m')
+
+                          sys.stdout.flush()
+
+                          c = sys.stdin.read(1)
+
+                          if c == '\x1b':
+                              c2 = sys.stdin.read(1)
+                              if c2 == '[':
+                                  c3 = sys.stdin.read(1)
+                                  if c3 == 'A':
+                                      if mode == 'list' and selected > 0:
+                                          selected -= 1
+                                      elif mode == 'preview' and preview_scroll > 0:
+                                          preview_scroll -= 1
+                                  elif c3 == 'B':
+                                      if mode == 'list' and selected < len(results) - 1:
+                                          selected += 1
+                                      elif mode == 'preview' and preview_scroll < max(0, len(preview_content) - list_height):
+                                          preview_scroll += 1
+                              else:
+                                  if mode == 'preview':
+                                      mode = 'list'
+                                      sys.stdout.write('\033[2J\033[H')
+                                  else:
+                                      context['output'] = "Cancelled."
+                                      break
+                              continue
+
+                          if c == 'q' or c == '\x03':
+                              context['output'] = "Cancelled."
+                              break
+                          elif c == 'k':
+                              if mode == 'list' and selected > 0:
+                                  selected -= 1
+                              elif mode == 'preview' and preview_scroll > 0:
+                                  preview_scroll -= 1
+                          elif c == 'j':
+                              if mode == 'list' and selected < len(results) - 1:
+                                  selected += 1
+                              elif mode == 'preview' and preview_scroll < max(0, len(preview_content) - list_height):
+                                  preview_scroll += 1
+                          elif c == 'p' and mode == 'list' and results:
+                              # Build preview from available info
+                              sel = results[selected]
+                              preview_content = [
+                                  f"Title: {sel['title']}",
+                                  "",
+                                  f"URL: {sel['url']}",
+                                  f"Domain: {get_domain(sel['url'])}",
+                                  "",
+                              ]
+                              if sel.get('snippet'):
+                                  preview_content.append("Snippet:")
+                                  # Word wrap snippet
+                                  words = sel['snippet'].split()
+                                  line = ""
+                                  for w in words:
+                                      if len(line) + len(w) + 1 > width - 4:
+                                          preview_content.append(f"  {line}")
+                                          line = w
+                                      else:
+                                          line = f"{line} {w}" if line else w
+                                  if line:
+                                      preview_content.append(f"  {line}")
+
+                              mode = 'preview'
+                              preview_scroll = 0
+                              sys.stdout.write('\033[2J\033[H')
+                          elif c == 'b' and mode == 'preview':
+                              mode = 'list'
+                              sys.stdout.write('\033[2J\033[H')
+                          elif c == 'o' and results:
+                              url = results[selected].get('url', '')
+                              if url:
+                                  webbrowser.open(url)
+                          elif c == 'i' and results:
+                              url = results[selected].get('url', '')
+                              if url:
+                                  try:
+                                      subprocess.run(['npcsh', '-c', f'/navigate url={url}'], check=False, capture_output=True)
+                                  except:
+                                      webbrowser.open(url)
+                          elif c == 'c' and results:
+                              url = results[selected].get('url', '')
+                              if url:
+                                  try:
+                                      # Try xclip or xsel
+                                      subprocess.run(['xclip', '-selection', 'clipboard'], input=url.encode(), check=True)
+                                  except:
+                                      try:
+                                          subprocess.run(['xsel', '--clipboard', '--input'], input=url.encode(), check=True)
+                                      except:
+                                          pass
+                          elif c in ('\r', '\n') and results:
+                              sel = results[selected]
+                              context['output'] = f"Selected: {sel['title']}\nURL: {sel['url']}"
+                              break
+
+                  finally:
+                      termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+                      sys.stdout.write('\033[?25h')
+                      sys.stdout.write('\033[2J\033[H')
+                      sys.stdout.flush()
+
           except Exception as e:
               import traceback
               context['output'] = "Web search error: " + str(e) + "\n" + traceback.format_exc()

npcsh/npc_team/jinxs/lib/core/sleep.jinx

@@ -1,7 +1,8 @@
 jinx_name: "sleep"
-description: "Evolve knowledge graph. Use --dream to also run creative synthesis."
+description: "Evolve knowledge graph. Use --dream for creative synthesis, --backfill to import approved memories."
 inputs:
 - dream: False
+- backfill: False
 - ops: ""
 - model: ""
 - provider: ""
@@ -12,10 +13,10 @@ steps:
       import os
       import traceback
       from npcpy.memory.command_history import CommandHistory, load_kg_from_db, save_kg_to_db
-      from npcpy.memory.knowledge_graph import kg_sleep_process, kg_dream_process
-      # Assuming render_markdown is available if needed for logging progress
+      from npcpy.memory.knowledge_graph import kg_sleep_process, kg_dream_process, kg_backfill_from_memories
 
       is_dreaming = context.get('dream')
+      do_backfill = context.get('backfill')
       operations_str = context.get('ops')
       llm_model = context.get('model')
       llm_provider = context.get('provider')
@@ -26,25 +27,22 @@ steps:
       operations_config = None
       if operations_str and isinstance(operations_str, str):
           operations_config = [op.strip() for op in operations_str.split(',')]
-      
+
       # Fallback for model/provider if not explicitly set in Jinx inputs
       if not llm_model and current_npc and current_npc.model:
           llm_model = current_npc.model
       if not llm_provider and current_npc and current_npc.provider:
           llm_provider = current_npc.provider
-      
+
       # Final fallbacks from state
       if not llm_model: llm_model = state.chat_model if state else "llama3.2"
       if not llm_provider: llm_provider = state.chat_provider if state else "ollama"
 
       team_name = current_team.name if current_team else "__none__"
-      npc_name = current_npc.name if isinstance(current_npc, type(None).__class__) else "__none__"
+      npc_name = current_npc.name if current_npc else "__none__"
       current_path = os.getcwd()
       scope_str = f"Team: '{team_name}', NPC: '{npc_name}', Path: '{current_path}'"
 
-      # Assume render_markdown exists
-      # render_markdown(f"- Checking knowledge graph for scope: {scope_str}")
-
       command_history = None
       try:
           db_path = os.getenv("NPCSH_DB_PATH", os.path.expanduser("~/npcsh_history.db"))
@@ -57,13 +55,26 @@ steps:
 
       output_result = ""
       try:
+          # Run backfill first if requested
+          if do_backfill:
+              print("Running backfill from approved memories...")
+              stats = kg_backfill_from_memories(
+                  engine,
+                  model=llm_model,
+                  provider=llm_provider,
+                  npc=current_npc,
+                  get_concepts=True,
+                  dry_run=False
+              )
+              output_result += f"Backfill: +{stats['facts_after'] - stats['facts_before']} facts, +{stats['concepts_after'] - stats['concepts_before']} concepts\n"
+
           current_kg = load_kg_from_db(engine, team_name, npc_name, current_path)
 
           if not current_kg or not current_kg.get('facts'):
               output_msg = f"Knowledge graph for the current scope is empty. Nothing to process.\n"
               output_msg += f"  - Scope Checked: {scope_str}\n\n"
-              output_msg += "**Hint:** Have a conversation or run some commands first to build up knowledge in this specific context. The KG is unique to each combination of Team, NPC, and directory."
-              context['output'] = output_msg
+              output_msg += "**Hint:** Run `/sleep backfill=true` to import approved memories, or have conversations first."
+              context['output'] = output_result + output_msg if output_result else output_msg
               context['messages'] = output_messages
               exit()
 

npcsh/npc_team/jinxs/lib/core/sql.jinx

@@ -8,9 +8,13 @@ steps:
     engine: python
     code: |
       import pandas as pd
-      query = {{ sql_query | tojson }}
-      try:
-          df = pd.read_sql_query(query, npc.db_conn)
-      except Exception as e:
-          df = pd.DataFrame({'Error': [str(e)]})
-      output = df.to_string()
+
+      query = context.get('sql_query', '').strip()
+      if not query:
+          context['output'] = "Usage: /sql <query>"
+      else:
+          try:
+              df = pd.read_sql_query(query, npc.db_conn)
+              context['output'] = df.to_string()
+          except Exception as e:
+              context['output'] = "SQL Error: " + str(e)