npcsh 1.1.22__py3-none-any.whl → 1.1.23__py3-none-any.whl

npcsh/benchmark/npcsh_agent.py

@@ -31,6 +31,9 @@ class NpcshAgent(BaseInstalledAgent):
 
     SUPPORTS_ATIF = True  # Agent Trajectory Interchange Format
 
+    # Root of the npcsh source tree (two levels up from this file)
+    _NPCSH_SRC = Path(__file__).resolve().parent.parent.parent
+
     def __init__(self, logs_dir: Path = None, model_name: str = None, logger=None, **kwargs):
         super().__init__(logs_dir=logs_dir, model_name=model_name, logger=logger, **kwargs)
 
@@ -43,138 +46,96 @@ class NpcshAgent(BaseInstalledAgent):
         """Path to the jinja template script for installing npcsh in the container."""
         return Path(__file__).parent / "templates" / "install-npcsh.sh.j2"
 
-    def create_run_agent_commands(self, instruction: str) -> list:
-        """
-        Create the commands to run npcsh in the container.
-
-        Args:
-            instruction: The task instruction from Terminal-Bench
-
-        Returns:
-            List of ExecInput commands to execute
-        """
-        # Wrap the instruction with tool usage directions and retry logic
-        tool_instruction = f"""You have access to tools: edit_file (for writing/creating files), sh (for running shell commands), and python (for running Python code).
-
-IMPORTANT RULES:
-1. You MUST call these tools using the function calling interface to complete the task. Do NOT write tool names as text - invoke them as function calls.
-2. After implementing a solution, you MUST verify it works by running any provided test scripts.
-3. If a test fails or produces an error, you MUST try a DIFFERENT approach. Do not give up.
-4. Keep trying different approaches until you succeed or have tried at least 10 different solutions.
-5. NEVER assume success - always check the actual output of test commands.
+    async def setup(self, environment) -> None:
+        """Upload local npcsh + npcpy source, then run install script."""
+        import shutil
+        import tempfile
+
+        npcsh_src = self._NPCSH_SRC
+        npcpy_src = npcsh_src.parent / "npcpy"
+
+        # Create /src in container
+        await environment.exec(command="mkdir -p /src")
+
+        # Copy source to temp dir excluding .git and caches
+        def _copy_clean(src, name):
+            tmp = Path(tempfile.mkdtemp()) / name
+            shutil.copytree(
+                src, tmp,
+                ignore=shutil.ignore_patterns(
+                    '.git', '__pycache__', '*.pyc', 'dist', 'build',
+                    '*.egg-info', 'jobs', 'dataset_cache',
+                ),
+            )
+            return tmp
+
+        clean_npcsh = _copy_clean(npcsh_src, "npcsh")
+        await environment.upload_dir(
+            source_dir=str(clean_npcsh),
+            target_dir="/src/npcsh",
+        )
 
-Task: {instruction}
+        if npcpy_src.exists():
+            clean_npcpy = _copy_clean(npcpy_src, "npcpy")
+            await environment.upload_dir(
+                source_dir=str(clean_npcpy),
+                target_dir="/src/npcpy",
+            )
 
-WORKFLOW:
-1. Call edit_file to write code files. Call sh to run commands.
-2. Run any test scripts mentioned in the task
-3. Check the output carefully - look for "PASS", "SUCCESS", "OK" or similar
-4. If the test failed, analyze why and try a completely different approach
-5. Repeat until the test passes"""
+        await super().setup(environment)
 
-        escaped_instruction = shlex.quote(tool_instruction)
-        model_name = self.model_name
+    def create_run_agent_commands(self, instruction: str) -> list:
+        """Run instruction through npcsh -c, which handles everything."""
+        escaped_instruction = shlex.quote(instruction)
 
-        if model_name and "/" in model_name:
+        # Forward env vars into the container — npcsh reads these directly
+        env_vars = []
+        for key in [
+            "ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GOOGLE_API_KEY",
+            "GEMINI_API_KEY", "DEEPSEEK_API_KEY", "GROQ_API_KEY",
+            "OPENROUTER_API_KEY", "OLLAMA_HOST",
+        ]:
+            val = os.environ.get(key)
+            if val:
+                env_vars.append(f'{key}="{val}"')
+
+        # Model/provider from Harbor's model_name (e.g. "ollama/phi4")
+        model_name = self.model_name or ""
+        if "/" in model_name:
             provider, model = model_name.split("/", 1)
-        elif model_name:
-            provider = os.environ.get("NPCSH_CHAT_PROVIDER", "")
-            model = model_name
         else:
             provider = os.environ.get("NPCSH_CHAT_PROVIDER", "")
-            model = os.environ.get("NPCSH_CHAT_MODEL", "")
-
-        # Map provider names to npcsh provider format
-        provider_map = {
-            "anthropic": "anthropic",
-            "openai": "openai",
-            "google": "gemini",
-            "gemini": "gemini",
-            "deepseek": "deepseek",
-            "ollama": "ollama",
-            "groq": "groq",
-            "openrouter": "openrouter",
-        }
-        npcsh_provider = provider_map.get(provider.lower(), provider)
-
-        # Build environment variables for API keys
-        env_vars = []
-        api_key_map = {
-            "anthropic": ["ANTHROPIC_API_KEY"],
-            "openai": ["OPENAI_API_KEY"],
-            "gemini": ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
-            "google": ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
-            "deepseek": ["DEEPSEEK_API_KEY"],
-            "groq": ["GROQ_API_KEY"],
-            "openrouter": ["OPENROUTER_API_KEY"],
-        }
-
-        added_keys = set()
-        for prov, env_keys in api_key_map.items():
-            for env_key in env_keys:
-                if env_key in os.environ:
-                    # For Gemini, always pass as GOOGLE_API_KEY (what litellm expects)
-                    target_key = "GOOGLE_API_KEY" if env_key == "GEMINI_API_KEY" else env_key
-                    if target_key not in added_keys:
-                        env_vars.append(f'{target_key}="{os.environ[env_key]}"')
-                        added_keys.add(target_key)
-                    break
-
-        env_prefix = " ".join(env_vars) + " " if env_vars else ""
-
-        # Output directory for logs
-        output_dir = str(self.logs_dir / "npcsh_output")
-        output_file = str(self.logs_dir / "npcsh_output" / "output.jsonl")
+            model = model_name or os.environ.get("NPCSH_CHAT_MODEL", "")
 
-        commands = []
-
-        # Create output directory
-        commands.append(ExecInput(
-            command=f"mkdir -p {shlex.quote(output_dir)}",
-            timeout_sec=30
-        ))
-
-        # Create .npcsh_global file to use global team and avoid interactive prompts
-        commands.append(ExecInput(
-            command="touch /app/.npcsh_global",
-            timeout_sec=10
-        ))
-
-        # Run npcsh with the instruction
-        # Using corca NPC which has edit_file tool for writing files
-        # Using the npc CLI which supports single-command execution
-        # NPCSH_DEFAULT_MODE=agent enables automatic tool execution
-        ollama_env = ""
-        if npcsh_provider == "ollama":
-            ollama_host = os.environ.get("OLLAMA_HOST", "http://host.docker.internal:11434")
-            ollama_env = f'OLLAMA_HOST="{ollama_host}" '
-
-        npcsh_cmd = (
-            f'{env_prefix}'
-            f'{ollama_env}'
-            f'NPCSH_CHAT_MODEL="{model}" '
-            f'NPCSH_CHAT_PROVIDER="{npcsh_provider}" '
-            f'NPCSH_STREAM_OUTPUT=0 '
-            f'NPCSH_DEFAULT_MODE=agent '
-            f'npc --npc corca {escaped_instruction} '
-            f'2>&1 | tee {shlex.quote(output_file)}'
-        )
+        env_vars.append(f'NPCSH_CHAT_MODEL="{model}"')
+        env_vars.append(f'NPCSH_CHAT_PROVIDER="{provider}"')
+        env_vars.append('NPCSH_STREAM_OUTPUT=0')
+        env_vars.append('NPCSH_DEBUG=1')
+
+        if provider == "ollama":
+            if "OLLAMA_HOST" not in os.environ:
+                env_vars.append('OLLAMA_HOST="http://host.docker.internal:11434"')
+            # Use 16k context for ollama models to avoid losing instructions
+            env_vars.append('NPCSH_OLLAMA_NUM_CTX=16384')
 
-        commands.append(ExecInput(
-            command=npcsh_cmd,
-            timeout_sec=600,  # 10 minute timeout for complex tasks
-        ))
+        env_prefix = " ".join(env_vars)
+        output_dir = str(self.logs_dir / "npcsh_output")
+        output_file = str(self.logs_dir / "npcsh_output" / "output.jsonl")
 
-        return commands
+        return [
+            ExecInput(command=f"mkdir -p {shlex.quote(output_dir)}", timeout_sec=30),
+            ExecInput(command="touch /app/.npcsh_global", timeout_sec=10),
+            ExecInput(
+                command=f'{env_prefix} npcsh -c {escaped_instruction} 2>&1 | tee {shlex.quote(output_file)}',
+                timeout_sec=1800,
+            ),
+        ]
 
     def populate_context_post_run(self, context: AgentContext) -> None:
         """
         Populate the context with results of the agent execution.
 
         Parses the output file to extract token usage metrics.
-
-        Args:
-            context: The AgentContext to populate with metrics
         """
         output_file = self.logs_dir / "npcsh_output" / "output.jsonl"
 
@@ -187,149 +148,25 @@ WORKFLOW:
                 with open(output_file, 'r') as f:
                     content = f.read()
 
-                # Try to parse as JSONL first
                 for line in content.strip().split('\n'):
                     if not line.strip():
                         continue
                     try:
                         event = json.loads(line)
-                        # Extract token usage from events if present
                         if isinstance(event, dict):
                             usage = event.get('usage', {})
                             total_input_tokens += usage.get('input_tokens', 0)
                             total_output_tokens += usage.get('output_tokens', 0)
                             total_cost_usd += usage.get('cost_usd', 0.0)
                     except json.JSONDecodeError:
-                        # Not JSON, just regular output
                         pass
 
             except Exception as e:
                 self.logger.warning(f"Failed to parse npcsh output: {e}")
 
-        # Set context metrics
         if hasattr(context, 'input_tokens'):
             context.input_tokens = total_input_tokens
         if hasattr(context, 'output_tokens'):
             context.output_tokens = total_output_tokens
         if hasattr(context, 'cost_usd'):
             context.cost_usd = total_cost_usd
-
-
-class NpcshAgentWithNpc(NpcshAgent):
-    """
-    Variant that uses a specific NPC for task execution.
-
-    This allows benchmarking specific NPCs like sibiji (orchestrator),
-    corca (coding), or custom NPCs.
-
-    Usage:
-        harbor run -d terminal-bench@2.0 \\
-            --agent-import-path "npcsh.benchmark:NpcshAgentWithNpc" \\
-            -m anthropic/claude-sonnet-4-20250514 -n 4
-    """
-
-    def __init__(self, *args, npc_name: str = "sibiji", **kwargs):
-        super().__init__(*args, **kwargs)
-        self.npc_name = npc_name
-
-    @staticmethod
-    def name() -> str:
-        return "npcsh-npc"
-
-    def create_run_agent_commands(self, instruction: str) -> list:
-        """Create commands using a specific NPC."""
-        # Wrap the instruction with tool usage directions and retry logic
-        tool_instruction = f"""You have access to tools: edit_file (for writing/creating files), sh (for running shell commands), and python (for running Python code).
-
-IMPORTANT RULES:
-1. You MUST call these tools using the function calling interface to complete the task. Do NOT write tool names as text - invoke them as function calls.
-2. After implementing a solution, you MUST verify it works by running any provided test scripts.
-3. If a test fails or produces an error, you MUST try a DIFFERENT approach. Do not give up.
-4. Keep trying different approaches until you succeed or have tried at least 10 different solutions.
-5. NEVER assume success - always check the actual output of test commands.
-
-Task: {instruction}
-
-WORKFLOW:
-1. Call edit_file to write code files. Call sh to run commands.
-2. Run any test scripts mentioned in the task
-3. Check the output carefully - look for "PASS", "SUCCESS", "OK" or similar
-4. If the test failed, analyze why and try a completely different approach
-5. Repeat until the test passes"""
-
-        escaped_instruction = shlex.quote(tool_instruction)
-        model_name = self.model_name
-
-        if model_name and "/" in model_name:
-            provider, model = model_name.split("/", 1)
-        elif model_name:
-            provider = os.environ.get("NPCSH_CHAT_PROVIDER", "")
-            model = model_name
-        else:
-            provider = os.environ.get("NPCSH_CHAT_PROVIDER", "")
-            model = os.environ.get("NPCSH_CHAT_MODEL", "")
-
-        provider_map = {
-            "anthropic": "anthropic",
-            "openai": "openai",
-            "google": "gemini",
-            "gemini": "gemini",
-            "deepseek": "deepseek",
-            "ollama": "ollama",
-        }
-        npcsh_provider = provider_map.get(provider.lower(), provider)
-
-        env_vars = []
-        api_key_map = {
-            "anthropic": "ANTHROPIC_API_KEY",
-            "openai": "OPENAI_API_KEY",
-            "gemini": "GOOGLE_API_KEY",
-            "deepseek": "DEEPSEEK_API_KEY",
-        }
-
-        for prov, env_key in api_key_map.items():
-            if env_key in os.environ:
-                env_vars.append(f'{env_key}="{os.environ[env_key]}"')
-
-        env_prefix = " ".join(env_vars) + " " if env_vars else ""
-
-        output_dir = str(self.logs_dir / "npcsh_output")
-        output_file = str(self.logs_dir / "npcsh_output" / "output.jsonl")
-
-        commands = []
-
-        commands.append(ExecInput(
-            command=f"mkdir -p {shlex.quote(output_dir)}",
-            timeout_sec=30
-        ))
-
-        # Create .npcsh_global file to use global team and avoid interactive prompts
-        commands.append(ExecInput(
-            command="touch /app/.npcsh_global",
-            timeout_sec=10
-        ))
-
-        # Use specific NPC with --npc flag
-        # NPCSH_DEFAULT_MODE=agent enables automatic tool execution
-        ollama_env = ""
-        if npcsh_provider == "ollama":
-            ollama_host = os.environ.get("OLLAMA_HOST", "http://host.docker.internal:11434")
-            ollama_env = f'OLLAMA_HOST="{ollama_host}" '
-
-        npcsh_cmd = (
-            f'{env_prefix}'
-            f'{ollama_env}'
-            f'NPCSH_CHAT_MODEL="{model}" '
-            f'NPCSH_CHAT_PROVIDER="{npcsh_provider}" '
-            f'NPCSH_STREAM_OUTPUT=0 '
-            f'NPCSH_DEFAULT_MODE=agent '
-            f'npc --npc {self.npc_name} {escaped_instruction} '
-            f'2>&1 | tee {shlex.quote(output_file)}'
-        )
-
-        commands.append(ExecInput(
-            command=npcsh_cmd,
-            timeout_sec=600,
-        ))
-
-        return commands

npcsh/benchmark/templates/install-npcsh.sh.j2

@@ -12,10 +12,18 @@ if ! command -v pip &> /dev/null; then
     apt-get update && apt-get install -y python3-pip
 fi
 
-# Install npcsh with lite dependencies (API providers only, no local models)
-# Use --break-system-packages for PEP 668 compliance (Ubuntu 24.04+)
-echo "Installing npcsh[lite] + ollama..."
-pip install --quiet --break-system-packages npcsh[lite] ollama || pip install --quiet npcsh[lite] ollama
+# Upgrade pip first to handle modern packages and extras
+echo "Upgrading pip..."
+pip install --upgrade pip 2>/dev/null || pip install --break-system-packages --upgrade pip 2>/dev/null || true
+
+# Install from local source (uploaded by agent setup)
+echo "Installing npcpy from local source..."
+if [ -d /src/npcpy ]; then
+    pip install --break-system-packages -e /src/npcpy 2>/dev/null || pip install -e /src/npcpy
+fi
+
+echo "Installing npcsh from local source..."
+pip install --break-system-packages -e /src/npcsh ollama 2>/dev/null || pip install -e /src/npcsh ollama
 
 # Verify installation
 echo "Verifying npcsh installation..."

npcsh/config.py

@@ -28,9 +28,9 @@ NPCSH_DEFAULT_MODE = os.environ.get("NPCSH_DEFAULT_MODE", "agent")
 NPCSH_VISION_MODEL = os.environ.get("NPCSH_VISION_MODEL", "gemma3:4b")
 NPCSH_VISION_PROVIDER = os.environ.get("NPCSH_VISION_PROVIDER", "ollama")
 NPCSH_IMAGE_GEN_MODEL = os.environ.get(
-    "NPCSH_IMAGE_GEN_MODEL", "runwayml/stable-diffusion-v1-5"
+    "NPCSH_IMAGE_GEN_MODEL", "x/z-image-turbo"
 )
-NPCSH_IMAGE_GEN_PROVIDER = os.environ.get("NPCSH_IMAGE_GEN_PROVIDER", "diffusers")
+NPCSH_IMAGE_GEN_PROVIDER = os.environ.get("NPCSH_IMAGE_GEN_PROVIDER", "ollama")
 NPCSH_VIDEO_GEN_MODEL = os.environ.get(
     "NPCSH_VIDEO_GEN_MODEL", "damo-vilab/text-to-video-ms-1.7b"
 )
@@ -44,6 +44,9 @@ NPCSH_API_URL = os.environ.get("NPCSH_API_URL", None)
 NPCSH_SEARCH_PROVIDER = os.environ.get("NPCSH_SEARCH_PROVIDER", "duckduckgo")
 NPCSH_BUILD_KG = os.environ.get("NPCSH_BUILD_KG", "1") != "0"
 NPCSH_EDIT_APPROVAL = os.environ.get("NPCSH_EDIT_APPROVAL", "off")  # off, interactive, auto
+NPCSH_TTS_ENGINE = os.environ.get("NPCSH_TTS_ENGINE", "")
+NPCSH_TTS_VOICE = os.environ.get("NPCSH_TTS_VOICE", "")
+NPCSH_YAP_SETUP_DONE = os.environ.get("NPCSH_YAP_SETUP_DONE", "0") == "1"
 
 
 def get_shell_config_file() -> str:

npcsh/npc_team/alicanto.npc

@@ -11,14 +11,10 @@ colors:
   top: "255,215,0"
   bottom: "218,165,32"
 primary_directive: |
-  You are alicanto, a research agent. You investigate hypotheses through experimentation and evidence gathering.
-  Search academic papers to ground your work in existing literature.
-  Search the web for data, documentation, and recent findings.
-  Write and execute Python code to analyze data, compute statistics, and generate results.
-  Use shell commands for data processing and system tasks.
-  Create files to record your findings, analyses, and evidence.
-  When exploring a hypothesis, gather evidence from multiple sources, analyze it quantitatively where possible, and document what you find.
-  Say RESEARCH_COMPLETE when you have sufficient evidence to evaluate your hypothesis.
+  You are alicanto, the deep research specialist. You produce thorough research reports.
+  Search multiple sources, read papers, gather evidence, then synthesize into a report.
+  Use web_search and file_search to find sources. Use python to analyze data.
+  Say RESEARCH_COMPLETE when you have enough evidence to answer.
 jinxs:
   - lib/core/search/web_search
   - lib/core/search/file_search

npcsh/npc_team/corca.npc

@@ -11,17 +11,11 @@ colors:
   top: "64,224,208"
   bottom: "255,165,0"
 primary_directive: |
-  You are corca, the software development specialist of the NPC team.
-  Your expertise is in writing, reviewing, and debugging code.
-  You think through problems carefully and favor solutions that prioritize simplicity and clarity.
-  Always consider how suggestions may increase rather than reduce tech debt unnecessarily.
-  When in doubt, ask for clarification with concrete options that make it easy for users to choose.
-
-  CRITICAL: You MUST ALWAYS use FULL ABSOLUTE PATHS for all file operations.
-  - NEVER use relative paths like "apps/api" or "./src"
-  - ALWAYS expand paths starting from root like "/Users/username/project/apps/api"
-  - When given a task, first determine the absolute path of the working directory using pwd
-  - Prefix all file paths with the full absolute path
+  You are corca, the software development and shell specialist.
+  You run commands, write code, debug, edit files, and handle system tasks.
+  Always use FULL ABSOLUTE PATHS. Run pwd first if you need the working directory.
+  When counting things, use wc -l. When debugging, read the error, fix it, retry.
+  Keep it simple. Do the task, report the result.
 jinxs:
   - lib/core/sh
   - lib/core/python

npcsh/npc_team/frederic.npc

@@ -11,12 +11,10 @@ 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.
+  You are frederic the polar bear — Feynman's curiosity meets Chopin's soul.
+  Make the complex simple and beautiful. Find elegance in structure.
+  Use analogies, strip away jargon, show why things are beautiful not just correct.
+  Use python to demonstrate ideas visually when math is involved.
 jinxs:
   - lib/core/python
   - lib/core/sql

npcsh/npc_team/guac.npc

@@ -11,10 +11,10 @@ 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.
+  You are guac, the data analysis specialist.
+  You load, analyze, and visualize data with pandas, numpy, matplotlib, and SQL.
+  Load data first, inspect it, do the analysis, report results with numbers.
+  For plots, save to file with plt.savefig() and report the path.
 jinxs:
   - lib/core/python
   - lib/core/sql

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

@@ -1,5 +1,5 @@
 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.
+description: ONLY for complex multi-step tasks. Sends a task to a specialist NPC who works on it with feedback until done. Do NOT use this for simple commands — use sh or python instead and answer directly.
 inputs:
 - npc_name:
       description: "Name of the NPC to delegate to"

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

@@ -4,7 +4,7 @@ description: Creates or edits a file. If the file does not exist, creates it wit
 inputs:
 - file_path
 - edit_instructions
-- backup: true
+- backup: false
 steps:
   - name: "edit_file"
     engine: "python"

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

@@ -1,5 +1,5 @@
 jinx_name: sh
-description: Execute bash queries. Should be used to grep for file contents, list directories, explore information to answer user questions more practically. NEVER use ls -R on directories that may contain node_modules, .git, or other large dependency folders - this will exceed token limits. Use targeted ls commands instead.
+description: Run a shell command and get the output. Use for counting files (ls /etc | wc -l), checking paths, listing directories. After you get the result, stop and answer the user. Do not call any other tools after this.
 inputs:
 - bash_command
 steps:

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

@@ -0,0 +1,59 @@
+jinx_name: skill
+description: Constructs and serves a structured skill. Receives the full skill definition and returns the requested part. Do not call directly.
+inputs:
+- skill_name
+- skill_description
+- sections
+- scripts_json
+- references_json
+- assets_json
+- section
+steps:
+  - name: handle_skill
+    engine: python
+    code: |
+      import json as _json, base64 as _b64
+
+      _name = {{ skill_name | tojson }}
+      _desc = {{ skill_description | tojson }}
+      _sections_raw = {{ sections | tojson }}
+      if isinstance(_sections_raw, dict):
+          _sections = _sections_raw
+      elif isinstance(_sections_raw, str):
+          try:
+              _sections = _json.loads(_b64.b64decode(_sections_raw).decode('utf-8'))
+          except Exception:
+              _sections = _json.loads(_sections_raw)
+      else:
+          _sections = {}
+      _scripts = _json.loads({{ scripts_json | tojson }}) if {{ scripts_json | tojson }} else []
+      _references = _json.loads({{ references_json | tojson }}) if {{ references_json | tojson }} else []
+      _assets = _json.loads({{ assets_json | tojson }}) if {{ assets_json | tojson }} else []
+      _section = {{ section | tojson }} or 'all'
+      _section = _section.strip()
+
+      if _section == 'meta':
+          output = _json.dumps({
+              'name': _name,
+              'description': _desc,
+              'sections': list(_sections.keys()),
+              'scripts': _scripts,
+              'references': _references,
+              'assets': _assets,
+          }, indent=2)
+      elif _section == 'list':
+          output = 'Available sections: ' + ', '.join(_sections.keys())
+      elif _section == 'all':
+          _parts = []
+          for _k, _v in _sections.items():
+              _parts.append(f'## {_k}\n{_v.strip()}')
+          output = '\n\n'.join(_parts)
+      else:
+          if _section in _sections:
+              output = _sections[_section].strip()
+          else:
+              _matches = [_k for _k in _sections if _section.lower() in _k.lower()]
+              if _matches:
+                  output = _sections[_matches[0]].strip()
+              else:
+                  output = f"Section '{_section}' not found. Available sections: " + ', '.join(_sections.keys())