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

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

@@ -0,0 +1,76 @@
+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/npc_team/jinxs/lib/research/paper_search.jinx

@@ -0,0 +1,101 @@
+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/npc_team/jinxs/lib/research/semantic_scholar.jinx

@@ -0,0 +1,69 @@
+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}"

npcsh/npc_team/jinxs/{utils/core → lib/utils}/build.jinx

@@ -2,7 +2,7 @@ jinx_name: "build"
 description: "Build deployment artifacts for NPC team"
 inputs:
   - target: "flask" # The type of deployment target (e.g., flask, docker, cli, static).
-  - output: "./build" # The output directory for built artifacts.
+  - outdir: "./build" # The output directory for built artifacts.
   - team: "./npc_team" # The path to the NPC team directory.
   - port: 5337 # The port for flask server builds.
   - cors: "" # Comma-separated CORS origins for flask server builds.
@@ -28,13 +28,13 @@ steps:
           def build_cli_executable(config, **kwargs): return {"output": f"Mock build cli: {config}", "messages": []}
           def build_static_site(config, **kwargs): return {"output": f"Mock build static: {config}", "messages": []}
 
-      target = context.get('target')
-      output_dir = context.get('output')
-      team_path = context.get('team')
-      port = context.get('port')
-      cors_origins_str = context.get('cors')
-      
-      cors_origins = [origin.strip() for origin in cors_origins_str.split(',')] if cors_origins_str.strip() else None
+      target = context.get('target') or 'flask'
+      output_dir = context.get('outdir') or './build'
+      team_path = context.get('team') or './npc_team'
+      port = context.get('port') or 5337
+      cors_origins_str = context.get('cors') or ''
+
+      cors_origins = [origin.strip() for origin in cors_origins_str.split(',') if origin.strip()] or None
 
       build_config = {
           'team_path': os.path.abspath(os.path.expanduser(team_path)),

npcsh/npc_team/jinxs/lib/utils/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/npc_team/jinxs/lib/utils/shh.jinx

@@ -0,0 +1,17 @@
+jinx_name: "shh"
+description: "Enable silent mode - only shows warnings and errors"
+inputs: []
+steps:
+  - name: "set_silent"
+    engine: "python"
+    code: |
+      state = context.get('state')
+      output_messages = context.get('messages', [])
+
+      if state:
+          result = state.set_log_level("silent")
+          context['output'] = result
+      else:
+          context['output'] = "Error: state not available"
+
+      context['messages'] = output_messages

npcsh/npc_team/jinxs/lib/utils/switch.jinx

@@ -0,0 +1,62 @@
+jinx_name: switch
+description: Get or set a switch in the .ctx file
+inputs:
+  - name: ""  # Switch name
+  - value: null  # Value to set (omit to get current value)
+  - scope: "workspace"  # "workspace" or "global"
+
+steps:
+  - name: manage_switch
+    engine: python
+    code: |
+      import os
+      import yaml
+      from pathlib import Path
+
+      switch_name = context.get('name', '')
+      switch_value = context.get('value')
+      scope = context.get('scope', 'workspace')
+      messages = context.get('messages', [])
+
+      if not switch_name:
+          context['output'] = "Usage: /switch <name> [value] [--scope workspace|global]"
+          context['messages'] = messages
+          exit()
+
+      # Determine .ctx path based on scope
+      if scope == "global":
+          ctx_path = Path.home() / ".npcsh" / "npc_team" / "npcsh.ctx"
+      else:
+          cwd = os.getcwd()
+          # Look for npc_team/*.ctx in workspace
+          npc_team_dir = Path(cwd) / "npc_team"
+          ctx_files = list(npc_team_dir.glob("*.ctx")) if npc_team_dir.exists() else []
+          ctx_path = ctx_files[0] if ctx_files else npc_team_dir / "team.ctx"
+
+      # Load existing ctx
+      ctx_data = {}
+      if ctx_path.exists():
+          try:
+              with open(ctx_path) as f:
+                  ctx_data = yaml.safe_load(f) or {}
+          except:
+              ctx_data = {}
+
+      # Ensure switches dict exists
+      if 'switches' not in ctx_data:
+          ctx_data['switches'] = {}
+
+      if switch_value is None:
+          # Get mode
+          current = ctx_data['switches'].get(switch_name, "not set")
+          context['output'] = f"{switch_name} ({scope}): {current}"
+      else:
+          # Set mode
+          ctx_path.parent.mkdir(parents=True, exist_ok=True)
+          ctx_data['switches'][switch_name] = switch_value
+          with open(ctx_path, 'w') as f:
+              yaml.dump(ctx_data, f, default_flow_style=False)
+          context['output'] = f"Set {switch_name} = {switch_value} ({scope})"
+
+      context['messages'] = messages
+      context['switch_value'] = ctx_data['switches'].get(switch_name)

npcsh/npc_team/jinxs/lib/utils/switches.jinx

@@ -0,0 +1,61 @@
+jinx_name: switches
+description: List all switches from .ctx files
+inputs:
+  - scope: "all"  # "workspace", "global", or "all"
+
+steps:
+  - name: list_switches
+    engine: python
+    code: |
+      import os
+      import yaml
+      from pathlib import Path
+
+      scope = context.get('scope', 'all')
+      messages = context.get('messages', [])
+
+      output_lines = []
+
+      # Global switches
+      if scope in ["global", "all"]:
+          global_ctx = Path.home() / ".npcsh" / "npc_team" / "npcsh.ctx"
+          if global_ctx.exists():
+              try:
+                  with open(global_ctx) as f:
+                      data = yaml.safe_load(f) or {}
+                  switches = data.get('switches', {})
+                  if switches:
+                      output_lines.append("Global switches:")
+                      for k, v in switches.items():
+                          output_lines.append(f"  {k}: {v}")
+                  else:
+                      output_lines.append("Global switches: (none)")
+              except:
+                  output_lines.append("Global switches: (none)")
+          else:
+              output_lines.append("Global switches: (none)")
+
+      # Workspace switches
+      if scope in ["workspace", "all"]:
+          cwd = os.getcwd()
+          npc_team_dir = Path(cwd) / "npc_team"
+          ctx_files = list(npc_team_dir.glob("*.ctx")) if npc_team_dir.exists() else []
+
+          if ctx_files:
+              try:
+                  with open(ctx_files[0]) as f:
+                      data = yaml.safe_load(f) or {}
+                  switches = data.get('switches', {})
+                  if switches:
+                      output_lines.append(f"Workspace switches:")
+                      for k, v in switches.items():
+                          output_lines.append(f"  {k}: {v}")
+                  else:
+                      output_lines.append("Workspace switches: (none)")
+              except:
+                  output_lines.append("Workspace switches: (none)")
+          else:
+              output_lines.append("Workspace switches: (none)")
+
+      context['output'] = "\n".join(output_lines) if output_lines else "No switches configured."
+      context['messages'] = messages