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

npcsh-1.1.17.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: ""
-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.17.data/data/npcsh/npc_team/kg_search.jinx

@@ -1,96 +0,0 @@
-jinx_name: kg_search
-description: Search the knowledge graph for facts and concepts
-inputs:
-- query: ""
-- type: "facts"
-- concept: ""
-- npc_name: ""
-- team_name: ""
-- db_path: ""
-
-steps:
-  - name: search_kg
-    engine: python
-    code: |
-      import os
-      from npcpy.memory.knowledge_graph import kg_search_facts, kg_list_concepts, kg_get_facts_for_concept, kg_get_all_facts
-
-      query = context.get('query', '').strip()
-      search_type = context.get('type', 'facts').lower()
-      concept = context.get('concept', '').strip()
-
-      if not query and search_type == 'facts' and not concept:
-          lines = [
-              "Usage: /kg_search <query> [type=facts|concepts|all]",
-              "",
-              "Options:",
-              "  type      - Search type (facts, concepts, all). Default is facts",
-              "  concept   - Get facts for a specific concept",
-              "  npc_name  - Filter by NPC name",
-              "  team_name - Filter by team name",
-              "  db_path   - Path to history database",
-              "",
-              "Examples:",
-              "  /kg_search python",
-              "  /kg_search type=concepts",
-              "  /kg_search concept=coding",
-              "  /kg_search type=all",
-          ]
-          context['output'] = "\n".join(lines)
-      else:
-          db_path = context.get('db_path') or os.path.expanduser("~/.npcsh/npcsh_history.db")
-
-          try:
-              cmd_history = CommandHistory(db_path)
-              engine = cmd_history.engine
-
-              team_obj = None
-              try:
-                  team_obj = state.team if 'state' in dir() and state else None
-              except:
-                  pass
-              npc_obj = npc if 'npc' in dir() else None
-
-              if concept:
-                  facts = kg_get_facts_for_concept(engine, concept, npc=npc_obj, team=team_obj)
-                  if not facts:
-                      context['output'] = "No facts found for concept '" + concept + "'"
-                  else:
-                      lines = ["Facts for concept '" + concept + "':", ""]
-                      for i, fact in enumerate(facts, 1):
-                          lines.append(str(i) + ". " + str(fact))
-                      context['output'] = "\n".join(lines)
-
-              elif search_type == 'concepts':
-                  concepts = kg_list_concepts(engine, npc=npc_obj, team=team_obj)
-                  if not concepts:
-                      context['output'] = "No concepts found in knowledge graph."
-                  else:
-                      lines = ["Found " + str(len(concepts)) + " concepts:", ""]
-                      for i, c in enumerate(concepts, 1):
-                          lines.append(str(i) + ". " + str(c))
-                      context['output'] = "\n".join(lines)
-
-              elif search_type == 'all':
-                  facts = kg_get_all_facts(engine, npc=npc_obj, team=team_obj)
-                  if not facts:
-                      context['output'] = "No facts in knowledge graph."
-                  else:
-                      lines = ["All facts (" + str(len(facts)) + " total):", ""]
-                      for i, fact in enumerate(facts, 1):
-                          lines.append(str(i) + ". " + str(fact))
-                      context['output'] = "\n".join(lines)
-
-              else:
-                  facts = kg_search_facts(engine, query, npc=npc_obj, team=team_obj)
-                  if not facts:
-                      context['output'] = "No KG facts found for '" + query + "'"
-                  else:
-                      lines = ["Found " + str(len(facts)) + " facts:", ""]
-                      for i, fact in enumerate(facts, 1):
-                          lines.append(str(i) + ". " + str(fact))
-                      context['output'] = "\n".join(lines)
-
-          except Exception as e:
-              import traceback
-              context['output'] = "KG search error: " + str(e) + "\n" + traceback.format_exc()

npcsh-1.1.17.data/data/npcsh/npc_team/mem_search.jinx

@@ -1,80 +0,0 @@
-jinx_name: mem_search
-description: Search memories (approved, pending, or all)
-inputs:
-- query: ""
-- status: "all"
-- npc_name: ""
-- team_name: ""
-- max_results: "10"
-- db_path: ""
-
-steps:
-  - name: search_memories
-    engine: python
-    code: |
-      import os
-
-      query = context.get('query', '').strip()
-      if not query:
-          lines = [
-              "Usage: /mem_search <query> [status=all|approved|pending]",
-              "",
-              "Options:",
-              "  status      - Filter by status (all, approved, pending). Default is all",
-              "  npc_name    - Filter by NPC name",
-              "  team_name   - Filter by team name",
-              "  max_results - Max results to return (default 10)",
-              "  db_path     - Path to history database",
-          ]
-          context['output'] = "\n".join(lines)
-      else:
-          status_filter = context.get('status', 'all').lower()
-          npc_name = context.get('npc_name') or (npc.name if npc else None)
-          team_name = context.get('team_name') or None
-          try:
-              team_name = team_name or (state.team.name if 'state' in dir() and state and state.team else None)
-          except:
-              pass
-          max_results = int(context.get('max_results') or 10)
-          db_path = context.get('db_path') or os.path.expanduser("~/.npcsh/npcsh_history.db")
-          current_path = os.getcwd()
-
-          try:
-              cmd_history = CommandHistory(db_path)
-
-              if status_filter == 'approved':
-                  state_obj = state if 'state' in dir() else None
-                  memories = get_relevant_memories(
-                      command_history=cmd_history,
-                      npc_name=npc_name or '__none__',
-                      team_name=team_name or '__none__',
-                      path=current_path,
-                      query=query,
-                      max_memories=max_results,
-                      state=state_obj
-                  )
-              else:
-                  memories = cmd_history.search_memories(
-                      query=query,
-                      npc_name=npc_name,
-                      team_name=team_name,
-                      status=status_filter if status_filter != 'all' else None,
-                      limit=max_results
-                  )
-
-              if not memories:
-                  context['output'] = "No memories found for '" + query + "' (status=" + status_filter + ")"
-              else:
-                  lines = ["Found " + str(len(memories)) + " memories (status=" + status_filter + "):", ""]
-                  for i, mem in enumerate(memories, 1):
-                      if isinstance(mem, dict):
-                          ts = mem.get('timestamp', 'unknown')
-                          content = mem.get('final_memory') or mem.get('initial_memory') or mem.get('content', '')
-                          status = mem.get('status', '')
-                          lines.append(str(i) + ". [" + str(ts) + "] (" + status + ") " + str(content))
-                      else:
-                          lines.append(str(i) + ". " + str(mem))
-                  context['output'] = "\n".join(lines)
-          except Exception as e:
-              import traceback
-              context['output'] = "Memory search error: " + str(e) + "\n" + traceback.format_exc()

npcsh-1.1.17.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.17.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}"