npcsh 1.1.16__py3-none-any.whl → 1.1.18__py3-none-any.whl

npcsh/npc_team/jinxs/lib/research/arxiv.jinx

@@ -1,76 +0,0 @@
-jinx_name: arxiv
-description: Search arXiv for preprints and papers
-inputs:
-  - query: ""
-  - limit: 10
-steps:
-  - name: search_arxiv
-    engine: python
-    code: |
-      import urllib.request
-      import urllib.parse
-      import xml.etree.ElementTree as ET
-
-      query = context.get('query', '')
-      limit = int(context.get('limit', 10))
-
-      if not query:
-          context['output'] = "Usage: /arxiv <query> [--limit N]"
-          exit()
-
-      base_url = "http://export.arxiv.org/api/query"
-      params = {
-          "search_query": f"all:{query}",
-          "start": 0,
-          "max_results": limit,
-          "sortBy": "relevance",
-          "sortOrder": "descending"
-      }
-
-      url = f"{base_url}?{urllib.parse.urlencode(params)}"
-
-      try:
-          with urllib.request.urlopen(url, timeout=30) as response:
-              data = response.read().decode('utf-8')
-
-          root = ET.fromstring(data)
-          ns = {'atom': 'http://www.w3.org/2005/Atom'}
-
-          entries = root.findall('atom:entry', ns)
-
-          if not entries:
-              context['output'] = f"No papers found for: {query}"
-              exit()
-
-          results = []
-          papers = []
-          for i, entry in enumerate(entries, 1):
-              title = entry.find('atom:title', ns).text.strip().replace('\n', ' ')
-              summary = entry.find('atom:summary', ns).text.strip()[:300] + '...'
-              published = entry.find('atom:published', ns).text[:10]
-              authors = [a.find('atom:name', ns).text for a in entry.findall('atom:author', ns)]
-              author_str = ', '.join(authors[:3])
-              if len(authors) > 3:
-                  author_str += ' et al.'
-              link = entry.find('atom:id', ns).text
-
-              results.append(f"{i}. {title}")
-              results.append(f"   Authors: {author_str}")
-              results.append(f"   Published: {published}")
-              results.append(f"   Abstract: {summary}")
-              results.append(f"   URL: {link}")
-              results.append("")
-
-              papers.append({
-                  'title': title,
-                  'authors': authors,
-                  'abstract': entry.find('atom:summary', ns).text.strip(),
-                  'published': published,
-                  'url': link
-              })
-
-          context['output'] = f"Found {len(entries)} papers on arXiv:\n\n" + "\n".join(results)
-          context['papers'] = papers
-
-      except Exception as e:
-          context['output'] = f"arXiv search error: {e}"

npcsh-1.1.16.data/data/npcsh/npc_team/arxiv.jinx

@@ -1,76 +0,0 @@
-jinx_name: arxiv
-description: Search arXiv for preprints and papers
-inputs:
-  - query: ""
-  - limit: 10
-steps:
-  - name: search_arxiv
-    engine: python
-    code: |
-      import urllib.request
-      import urllib.parse
-      import xml.etree.ElementTree as ET
-
-      query = context.get('query', '')
-      limit = int(context.get('limit', 10))
-
-      if not query:
-          context['output'] = "Usage: /arxiv <query> [--limit N]"
-          exit()
-
-      base_url = "http://export.arxiv.org/api/query"
-      params = {
-          "search_query": f"all:{query}",
-          "start": 0,
-          "max_results": limit,
-          "sortBy": "relevance",
-          "sortOrder": "descending"
-      }
-
-      url = f"{base_url}?{urllib.parse.urlencode(params)}"
-
-      try:
-          with urllib.request.urlopen(url, timeout=30) as response:
-              data = response.read().decode('utf-8')
-
-          root = ET.fromstring(data)
-          ns = {'atom': 'http://www.w3.org/2005/Atom'}
-
-          entries = root.findall('atom:entry', ns)
-
-          if not entries:
-              context['output'] = f"No papers found for: {query}"
-              exit()
-
-          results = []
-          papers = []
-          for i, entry in enumerate(entries, 1):
-              title = entry.find('atom:title', ns).text.strip().replace('\n', ' ')
-              summary = entry.find('atom:summary', ns).text.strip()[:300] + '...'
-              published = entry.find('atom:published', ns).text[:10]
-              authors = [a.find('atom:name', ns).text for a in entry.findall('atom:author', ns)]
-              author_str = ', '.join(authors[:3])
-              if len(authors) > 3:
-                  author_str += ' et al.'
-              link = entry.find('atom:id', ns).text
-
-              results.append(f"{i}. {title}")
-              results.append(f"   Authors: {author_str}")
-              results.append(f"   Published: {published}")
-              results.append(f"   Abstract: {summary}")
-              results.append(f"   URL: {link}")
-              results.append("")
-
-              papers.append({
-                  'title': title,
-                  'authors': authors,
-                  'abstract': entry.find('atom:summary', ns).text.strip(),
-                  'published': published,
-                  'url': link
-              })
-
-          context['output'] = f"Found {len(entries)} papers on arXiv:\n\n" + "\n".join(results)
-          context['papers'] = papers
-
-      except Exception as e:
-          context['output'] = f"arXiv search error: {e}"

npcsh-1.1.16.data/data/npcsh/npc_team/jinxs.jinx

@@ -1,176 +0,0 @@
-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.16.data/data/npcsh/npc_team/paper_search.jinx

@@ -1,101 +0,0 @@
-jinx_name: paper_search
-description: Search for academic papers across multiple sources (Semantic Scholar, arXiv, local datasets)
-inputs:
-  - query: ""
-  - limit: 10
-  - source: "all"
-steps:
-  - name: search_papers
-    engine: python
-    code: |
-      import os
-      import time
-      import requests
-      import urllib.request
-      import urllib.parse
-      import xml.etree.ElementTree as ET
-
-      query = context.get('query', '')
-      limit = int(context.get('limit', 10))
-      source = context.get('source', 'all').lower()
-
-      if not query:
-          context['output'] = """Usage: /paper_search <query> [--limit N] [--source SOURCE]
-
-      Sources:
-        all    - Search all available sources (default)
-        s2     - Semantic Scholar only (requires S2_API_KEY)
-        arxiv  - arXiv only
-      """
-          exit()
-
-      all_results = []
-
-      # Semantic Scholar
-      if source in ['all', 's2']:
-          api_key = os.environ.get('S2_API_KEY')
-          if api_key:
-              try:
-                  url = "https://api.semanticscholar.org/graph/v1/paper/search"
-                  headers = {"x-api-key": api_key}
-                  params = {"query": query, "limit": limit, "fields": "title,abstract,authors,year,citationCount,url"}
-                  response = requests.get(url, headers=headers, params=params, timeout=30)
-                  response.raise_for_status()
-                  for paper in response.json().get('data', []):
-                      all_results.append({
-                          'source': 'Semantic Scholar',
-                          'title': paper.get('title', ''),
-                          'year': paper.get('year'),
-                          'citations': paper.get('citationCount', 0),
-                          'authors': [a.get('name', '') for a in paper.get('authors', [])],
-                          'abstract': paper.get('abstract', '')[:300] if paper.get('abstract') else '',
-                          'url': paper.get('url', '')
-                      })
-              except Exception as e:
-                  print(f"S2 error: {e}")
-
-      # arXiv
-      if source in ['all', 'arxiv']:
-          try:
-              base_url = "http://export.arxiv.org/api/query"
-              params = {"search_query": f"all:{query}", "max_results": limit}
-              url = f"{base_url}?{urllib.parse.urlencode(params)}"
-              with urllib.request.urlopen(url, timeout=30) as response:
-                  data = response.read().decode('utf-8')
-              root = ET.fromstring(data)
-              ns = {'atom': 'http://www.w3.org/2005/Atom'}
-              for entry in root.findall('atom:entry', ns):
-                  all_results.append({
-                      'source': 'arXiv',
-                      'title': entry.find('atom:title', ns).text.strip().replace('\n', ' '),
-                      'year': entry.find('atom:published', ns).text[:4],
-                      'citations': None,
-                      'authors': [a.find('atom:name', ns).text for a in entry.findall('atom:author', ns)],
-                      'abstract': entry.find('atom:summary', ns).text.strip()[:300],
-                      'url': entry.find('atom:id', ns).text
-                  })
-          except Exception as e:
-              print(f"arXiv error: {e}")
-
-      if not all_results:
-          context['output'] = f"No papers found for: {query}"
-          exit()
-
-      # Format output
-      results = []
-      for i, paper in enumerate(all_results[:limit], 1):
-          authors = ', '.join(paper['authors'][:3])
-          if len(paper['authors']) > 3:
-              authors += ' et al.'
-          year = paper.get('year', '?')
-          citations = f", {paper['citations']} citations" if paper.get('citations') else ""
-
-          results.append(f"{i}. [{paper['source']}] {paper['title']} ({year}{citations})")
-          results.append(f"   Authors: {authors}")
-          if paper['abstract']:
-              results.append(f"   Abstract: {paper['abstract']}...")
-          results.append(f"   URL: {paper['url']}")
-          results.append("")
-
-      context['output'] = f"Found {len(all_results)} papers:\n\n" + "\n".join(results)
-      context['papers'] = all_results

npcsh-1.1.16.data/data/npcsh/npc_team/search.jinx

@@ -1,131 +0,0 @@
-jinx_name: "search"
-description: >
-  Executes a search across various sources.
-  Usage:
-    /search <query>                         (Default: Web Search)
-    /search --memory <query>                (Search approved memories)
-    /search --kg <query>                    (Search the knowledge graph)
-    /search --rag [-f <paths>] <query>      (Execute a RAG search)
-    /search --brainblast <query>            (Advanced history search)
-inputs:
-  - query: ""
-  - sprovider: ""
-  - memory: false
-  - kg: false
-  - rag: false
-  - brainblast: false
-  - file_paths: ""
-  - history_db_path: "~/npcsh_history.db"
-  - vector_db_path: "~/npcsh_chroma.db"
-  - emodel: ""
-  - eprovider: ""
-steps:
-  - name: "execute_unified_search"
-    engine: "python"
-    code: |
-      import os
-      import traceback
-      from npcpy.data.web import search_web
-
-      # Access query from context
-      query = context.get('query')
-      if not query or not query.strip():
-          context['output'] = "Usage: /search [--memory|--kg|--rag|--brainblast] <query>"
-      else:
-          # state is available as a GLOBAL variable (from extra_globals)
-          # Access it directly, not from context
-          try:
-              current_state = state  # This should work now
-          except NameError:
-              context['output'] = "Error: Shell state not available in jinx context"
-              raise
-          
-          current_npc = current_state.npc
-          current_team = current_state.team
-
-          npc_name = getattr(current_npc, 'name', '__none__') if current_npc else '__none__'
-          team_name = getattr(current_team, 'name', '__none__') if current_team else '__none__'
-          current_path = os.getcwd()
-          db_path = os.path.expanduser(context.get("history_db_path") or "~/.npcsh/npcsh_history.db")
-          
-          try:
-              cmd_history = CommandHistory(db_path)
-              
-              if context.get('memory'):
-                  memories = get_relevant_memories(
-                      command_history=cmd_history, 
-                      npc_name=npc_name, 
-                      team_name=team_name,
-                      path=current_path, 
-                      query=query, 
-                      max_memories=10, 
-                      state=current_state  # Pass the state object
-                  )
-                  print(memories)
-                  
-                  if not memories:
-                      output = f"No memories found for query: '{query}'"
-                  else:
-                      output = f"Found {len(memories)} memories:\n\n" + "\n".join(
-                          f"{i}. [{mem.get('timestamp', 'unknown')}] {mem.get('final_memory') or mem.get('initial_memory')}" 
-                          for i, mem in enumerate(memories, 1)
-                      )
-              
-              elif context.get('kg'):
-                  facts = search_kg_facts(
-                      cmd_history, 
-                      npc_name, 
-                      team_name, 
-                      current_path, 
-                      query
-                  )
-                  print(facts)
-                  
-                  if not facts:
-                      output = f"No KG facts found for query: '{query}'"
-                  else:
-                      output = f"Found {len(facts)} KG facts:\n\n" + "\n".join(
-                          f"{i}. {fact.get('statement')}" for i, fact in enumerate(facts, 1)
-                      )
-
-              elif context.get('rag'):
-                  file_paths_str = context.get('file_paths', '')
-                  file_paths = [os.path.abspath(os.path.expanduser(p.strip())) for p in file_paths_str.split(',') if p.strip()]
-                  emodel = context.get('emodel') or current_state.embedding_model
-                  eprovider = context.get('eprovider') or current_state.embedding_provider
-                  
-                  file_contents = []
-                  for path in file_paths:
-                      chunks = load_file_contents(path)
-                      basename = os.path.basename(path)
-                      file_contents.extend([f"{basename}: {chunk}" for chunk in chunks])
-
-                  result = execute_rag_command(
-                      command=query,
-                      vector_db_path=os.path.expanduser(context.get('vector_db_path') or "~/.npcsh/npcsh_chroma.db"),
-                      embedding_model=emodel,
-                      embedding_provider=eprovider,
-                      file_contents=file_contents or None
-                  )
-                  print(result)
-                  output = result.get('response', 'No response from RAG.')
-
-              elif context.get('brainblast'):
-                  result = execute_brainblast_command(
-                      command=query, 
-                      command_history=cmd_history, 
-                      **context
-                  )
-                  print(result)
-                  output = result.get('output', 'Brainblast search executed.')
-
-              else:
-                  # Default to web search
-                  provider = context.get('sprovider') or current_state.search_provider
-                  results = search_web(query, provider=provider)
-                  output = "\n".join([f"- {res}" for res in results]) if results else "No web results found."
-
-          except Exception as e:
-              output = f"An error occurred in the search jinx: {e}\n{traceback.format_exc()}"
-
-          context['output'] = output

npcsh-1.1.16.data/data/npcsh/npc_team/semantic_scholar.jinx

@@ -1,69 +0,0 @@
-jinx_name: semantic_scholar
-description: Search Semantic Scholar for academic papers. Requires S2_API_KEY env var.
-inputs:
-  - query: ""
-  - limit: 10
-steps:
-  - name: search_s2
-    engine: python
-    code: |
-      import os
-      import time
-      import requests
-
-      query = context.get('query', '')
-      limit = int(context.get('limit', 10))
-
-      if not query:
-          context['output'] = "Usage: /semantic_scholar <query> [--limit N]"
-          exit()
-
-      api_key = os.environ.get('S2_API_KEY')
-      if not api_key:
-          context['output'] = "Error: S2_API_KEY environment variable not set. Get one at https://www.semanticscholar.org/product/api"
-          exit()
-
-      url = "https://api.semanticscholar.org/graph/v1/paper/search"
-      headers = {"x-api-key": api_key}
-      params = {
-          "query": query,
-          "limit": limit,
-          "fields": "title,abstract,authors,year,citationCount,url,tldr"
-      }
-
-      try:
-          response = requests.get(url, headers=headers, params=params, timeout=30)
-          response.raise_for_status()
-          data = response.json().get('data', [])
-
-          if not data:
-              context['output'] = f"No papers found for: {query}"
-              exit()
-
-          results = []
-          for i, paper in enumerate(data, 1):
-              title = paper.get('title', 'No title')
-              year = paper.get('year', '?')
-              citations = paper.get('citationCount', 0)
-              authors = ', '.join([a.get('name', '') for a in paper.get('authors', [])[:3]])
-              if len(paper.get('authors', [])) > 3:
-                  authors += ' et al.'
-              abstract = paper.get('abstract', '')[:200] + '...' if paper.get('abstract') else 'No abstract'
-              tldr = paper.get('tldr', {}).get('text', '') if paper.get('tldr') else ''
-              url = paper.get('url', '')
-
-              results.append(f"{i}. {title} ({year})")
-              results.append(f"   Authors: {authors}")
-              results.append(f"   Citations: {citations}")
-              if tldr:
-                  results.append(f"   TL;DR: {tldr}")
-              else:
-                  results.append(f"   Abstract: {abstract}")
-              results.append(f"   URL: {url}")
-              results.append("")
-
-          context['output'] = f"Found {len(data)} papers:\n\n" + "\n".join(results)
-          context['papers'] = data
-
-      except requests.exceptions.RequestException as e:
-          context['output'] = f"Semantic Scholar API error: {e}"