npcsh 1.1.18__tar.gz → 1.1.20__tar.gz

{npcsh-1.1.18/npcsh.egg-info → npcsh-1.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcsh
-Version: 1.1.18
+Version: 1.1.20
 Summary: npcsh is a command-line toolkit for using AI agents in novel ways.
 Home-page: https://github.com/NPC-Worldwide/npcsh
 Author: Christopher Agostino
@@ -106,31 +106,38 @@ Dynamic: summary
   <img src="https://raw.githubusercontent.com/NPC-Worldwide/npcsh/main/npcsh/npcsh.png" alt="npcsh logo" width=600></a>
 </p> 
 
-# NPC Shell
+# npcsh
 
-`npcsh` - a new standard in human-agent interaction. Co-create with agents to build organizations that refine themselves and evolve to your needs.
-
-The NPC shell is a suite of programs to make use of multi-modal LLMs and agents in novel interactive modes. Based in the command line, use it wherever you work. 
-
-- It is developed to work reliably with small models and performs excellently with the state-of-the-art models from major model providers. 
-- Fundamentally, the core program of npcsh extends the familiar bash environment with an intelligent layer that lets users seamlessly ask agents questions, run pre-built or custom macros or agents, all without breaking the flow of command-line work.
-- Switching between agents is a breeze in `npcsh`, letting you quickly and easily take advantage of a variety of agents (e.g. coding agents versus tool-calling agents versus prompt-based ReACT Flow agents) and personas (e.g. Data scientist, mapmaker with ennui, etc.).
-- Project variables and context can be stored in team `.ctx` files. Personas (`.npc`) and Jinja execution templates (`.jinx`) are likewise stored in `yaml` within the global `npcsh` team or your project-specific one, letting you focus on adjusting and engineering context and system prompts iteratively so you can constantly improve your agent team's performance.
+The NPC shell (`npcsh`) makes the most of multi-modal LLMs and agents through a powerful set of simple slash  commands and novel interactive modes, all from the comfort of the command line. Build teams of agents and schedule them on jobs, engineer context, and design custom interaction modes and Jinja Execution templates (Jinxs for you and your agents to invoke, all managed scalably for organizations of any size through the NPC data layer.
 
 To get started:
+For users who want to mainly use models through APIs (`ollama`, `gemini`, `kimi`, `grok`, `deepseek`, `anthropic`, `openai`, `mistral`, or any others provided by litellm )
 ```bash
-# for users who want to mainly use models through APIs (e.g. , gemini, grok, deepseek, anthropic, openai, mistral, , any others provided by litellm ):
 pip install 'npcsh[lite]' 
-# for users who want to use local models (these install diffusers/transformers/torch stack so it is big.):
+```
+For users who want to use and fine-tune local models (this installs `diffusers`/`transformers`/`torch` stack so it is big):
+
+```bash
 pip install 'npcsh[local]'
-# for users who want to use the voice mode `yap`, see also the OS-specific installation instructions for installing needed system audio  libraries
+```
+
+
+For users who want to use the voice mode `yap` (see also the OS-specific installation instructions for installing needed system audio  libraries)
+```bash
 pip install 'npcsh[yap]'
 ```
+
 Once installed: run
 ```bash
 npcsh
 ```
-and you will enter the NPC shell. Additionally, the pip installation includes the following CLI tools available in bash: `npc` cli, `wander`, `spool`, `yap`, and `nql`. Bin jinxs in `npc_team/jinxs/bin/` are automatically registered as CLI commands. 
+and you will enter the NPC shell. 
+
+If you do not have any local models
+
+
+
+Additionally, the pip installation includes the following CLI tools available in bash: `npc` cli, `wander`, `spool`, `yap`, and `nql`. Bin jinxs in `npc_team/jinxs/bin/` are automatically registered as CLI commands. 
 
 
 # Usage

{npcsh-1.1.18 → npcsh-1.1.20}/README.md

@@ -3,31 +3,38 @@
   <img src="https://raw.githubusercontent.com/NPC-Worldwide/npcsh/main/npcsh/npcsh.png" alt="npcsh logo" width=600></a>
 </p> 
 
-# NPC Shell
+# npcsh
 
-`npcsh` - a new standard in human-agent interaction. Co-create with agents to build organizations that refine themselves and evolve to your needs.
-
-The NPC shell is a suite of programs to make use of multi-modal LLMs and agents in novel interactive modes. Based in the command line, use it wherever you work. 
-
-- It is developed to work reliably with small models and performs excellently with the state-of-the-art models from major model providers. 
-- Fundamentally, the core program of npcsh extends the familiar bash environment with an intelligent layer that lets users seamlessly ask agents questions, run pre-built or custom macros or agents, all without breaking the flow of command-line work.
-- Switching between agents is a breeze in `npcsh`, letting you quickly and easily take advantage of a variety of agents (e.g. coding agents versus tool-calling agents versus prompt-based ReACT Flow agents) and personas (e.g. Data scientist, mapmaker with ennui, etc.).
-- Project variables and context can be stored in team `.ctx` files. Personas (`.npc`) and Jinja execution templates (`.jinx`) are likewise stored in `yaml` within the global `npcsh` team or your project-specific one, letting you focus on adjusting and engineering context and system prompts iteratively so you can constantly improve your agent team's performance.
+The NPC shell (`npcsh`) makes the most of multi-modal LLMs and agents through a powerful set of simple slash  commands and novel interactive modes, all from the comfort of the command line. Build teams of agents and schedule them on jobs, engineer context, and design custom interaction modes and Jinja Execution templates (Jinxs for you and your agents to invoke, all managed scalably for organizations of any size through the NPC data layer.
 
 To get started:
+For users who want to mainly use models through APIs (`ollama`, `gemini`, `kimi`, `grok`, `deepseek`, `anthropic`, `openai`, `mistral`, or any others provided by litellm )
 ```bash
-# for users who want to mainly use models through APIs (e.g. , gemini, grok, deepseek, anthropic, openai, mistral, , any others provided by litellm ):
 pip install 'npcsh[lite]' 
-# for users who want to use local models (these install diffusers/transformers/torch stack so it is big.):
+```
+For users who want to use and fine-tune local models (this installs `diffusers`/`transformers`/`torch` stack so it is big):
+
+```bash
 pip install 'npcsh[local]'
-# for users who want to use the voice mode `yap`, see also the OS-specific installation instructions for installing needed system audio  libraries
+```
+
+
+For users who want to use the voice mode `yap` (see also the OS-specific installation instructions for installing needed system audio  libraries)
+```bash
 pip install 'npcsh[yap]'
 ```
+
 Once installed: run
 ```bash
 npcsh
 ```
-and you will enter the NPC shell. Additionally, the pip installation includes the following CLI tools available in bash: `npc` cli, `wander`, `spool`, `yap`, and `nql`. Bin jinxs in `npc_team/jinxs/bin/` are automatically registered as CLI commands. 
+and you will enter the NPC shell. 
+
+If you do not have any local models
+
+
+
+Additionally, the pip installation includes the following CLI tools available in bash: `npc` cli, `wander`, `spool`, `yap`, and `nql`. Bin jinxs in `npc_team/jinxs/bin/` are automatically registered as CLI commands. 
 
 
 # Usage

{npcsh-1.1.18 → npcsh-1.1.20}/npcsh/_state.py

@@ -125,6 +125,7 @@ from .config import (
     NPCSH_API_URL,
     NPCSH_SEARCH_PROVIDER,
     NPCSH_BUILD_KG,
+    NPCSH_EDIT_APPROVAL,
     setup_npcsh_config,
     is_npcsh_initialized,
     set_npcsh_initialized,
@@ -185,6 +186,10 @@ class ShellState:
     session_start_time: float = field(default_factory=lambda: __import__('time').time())
     # Logging level: "silent", "normal", "verbose"
     log_level: str = "normal"
+    # Edit approval mode: "off", "interactive", "auto"
+    edit_approval: str = NPCSH_EDIT_APPROVAL
+    # Pending file edits for approval
+    pending_edits: Dict[str, Dict[str, str]] = field(default_factory=dict)
 
     def get_model_for_command(self, model_type: str = "chat"):
         if model_type == "chat":
@@ -271,6 +276,8 @@ CONFIG_KEY_MAP = {
     "stream": "NPCSH_STREAM_OUTPUT",
     "apiurl": "NPCSH_API_URL",
     "buildkg": "NPCSH_BUILD_KG",
+    "editapproval": "NPCSH_EDIT_APPROVAL",
+    "approval": "NPCSH_EDIT_APPROVAL",
 }
 
 
@@ -315,6 +322,7 @@ def set_npcsh_config_value(key: str, value: str):
         "NPCSH_BUILD_KG": "build_kg",
         "NPCSH_API_URL": "api_url",
         "NPCSH_STREAM_OUTPUT": "stream_output",
+        "NPCSH_EDIT_APPROVAL": "edit_approval",
     }
     if env_key in field_map:
         setattr(ShellState, field_map[env_key], parsed_val)
@@ -2752,15 +2760,19 @@ def process_pipeline_command(
     if cmd_to_process.startswith("/"):
         command_name = cmd_to_process.split()[0].lstrip('/')
         
-        # Check if this is an interactive mode by looking for the jinx file in modes/
+        # Check if this is an interactive mode
         is_interactive_mode = False
-        
-        # Check global modes
-        global_modes_jinx = os.path.expanduser(f'~/.npcsh/npc_team/jinxs/modes/{command_name}.jinx')
-        if os.path.exists(global_modes_jinx):
+
+        # Check if the jinx declares interactive: true
+        if router.is_interactive(command_name):
             is_interactive_mode = True
-        
-        # Check team modes
+
+        # Also check modes/ directory (legacy)
+        if not is_interactive_mode:
+            global_modes_jinx = os.path.expanduser(f'~/.npcsh/npc_team/jinxs/modes/{command_name}.jinx')
+            if os.path.exists(global_modes_jinx):
+                is_interactive_mode = True
+
         if not is_interactive_mode and state.team and state.team.team_path:
             team_modes_jinx = os.path.join(state.team.team_path, 'jinxs', 'modes', f'{command_name}.jinx')
             if os.path.exists(team_modes_jinx):

{npcsh-1.1.18 → npcsh-1.1.20}/npcsh/benchmark/npcsh_agent.py

@@ -53,14 +53,26 @@ class NpcshAgent(BaseInstalledAgent):
         Returns:
             List of ExecInput commands to execute
         """
-        # Wrap the instruction with explicit jinx usage directions
+        # Wrap the instruction with explicit jinx usage directions and retry logic
         tool_instruction = f"""You have access to jinxs including edit_file (for writing/creating files), sh (for running shell commands), and python (for running Python code).
 
-IMPORTANT: You MUST use these jinxs to complete the task. Do NOT just output code as text - use the edit_file jinx to actually write files to disk.
+IMPORTANT RULES:
+1. You MUST use these jinxs to complete the task. Do NOT just output code as text - use the edit_file jinx to actually write files to disk.
+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}
 
-Remember: Use edit_file to write any code files. Use sh to run shell commands like gcc, make, etc."""
+WORKFLOW:
+1. Implement your solution using edit_file and sh
+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
+
+Remember: Use edit_file to write code files. Use sh to run commands. VERIFY your solution works before concluding."""
 
         escaped_instruction = shlex.quote(tool_instruction)
         model_name = self.model_name
@@ -90,18 +102,25 @@ Remember: Use edit_file to write any code files. Use sh to run shell commands li
         # Build environment variables for API keys
         env_vars = []
         api_key_map = {
-            "anthropic": "ANTHROPIC_API_KEY",
-            "openai": "OPENAI_API_KEY",
-            "gemini": "GOOGLE_API_KEY",
-            "google": "GOOGLE_API_KEY",
-            "deepseek": "DEEPSEEK_API_KEY",
-            "groq": "GROQ_API_KEY",
-            "openrouter": "OPENROUTER_API_KEY",
+            "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"],
         }
 
-        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]}"')
+        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 ""
 
@@ -215,14 +234,26 @@ class NpcshAgentWithNpc(NpcshAgent):
 
     def create_run_agent_commands(self, instruction: str) -> list:
         """Create commands using a specific NPC."""
-        # Wrap the instruction with explicit jinx usage directions
+        # Wrap the instruction with explicit jinx usage directions and retry logic
         tool_instruction = f"""You have access to jinxs including edit_file (for writing/creating files), sh (for running shell commands), and python (for running Python code).
 
-IMPORTANT: You MUST use these jinxs to complete the task. Do NOT just output code as text - use the edit_file jinx to actually write files to disk.
+IMPORTANT RULES:
+1. You MUST use these jinxs to complete the task. Do NOT just output code as text - use the edit_file jinx to actually write files to disk.
+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}
 
-Remember: Use edit_file to write any code files. Use sh to run shell commands like gcc, make, etc."""
+WORKFLOW:
+1. Implement your solution using edit_file and sh
+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
+
+Remember: Use edit_file to write code files. Use sh to run commands. VERIFY your solution works before concluding."""
 
         escaped_instruction = shlex.quote(tool_instruction)
         model_name = self.model_name

{npcsh-1.1.18 → npcsh-1.1.20}/npcsh/config.py

@@ -43,6 +43,7 @@ NPCSH_STREAM_OUTPUT = os.environ.get("NPCSH_STREAM_OUTPUT", "0") == "1"
 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
 
 
 def get_shell_config_file() -> str: