npcsh 0.1.2__py3-none-any.whl → 1.1.13__py3-none-any.whl

npcsh/modes.py

@@ -1,343 +0,0 @@
-# modes.py
-import os
-import subprocess
-from .llm_funcs import (
-    get_ollama_conversation,
-    get_llm_response,
-    execute_data_operations,
-)
-import sqlite3
-
-
-def enter_bash_mode():
-    print("Entering bash mode. Type '/bq' to exit bash mode.")
-    current_dir = os.getcwd()
-    bash_output = []
-    while True:
-        try:
-            bash_input = input(f"bash {current_dir}> ").strip()
-            if bash_input == "/bq":
-                print("Exiting bash mode.")
-                break
-            else:
-                try:
-                    if bash_input.startswith("cd "):
-                        new_dir = bash_input[3:].strip()
-                        try:
-                            os.chdir(os.path.expanduser(new_dir))
-                            current_dir = os.getcwd()
-                            bash_output.append(f"Changed directory to {current_dir}")
-                            print(f"Changed directory to {current_dir}")
-                        except FileNotFoundError:
-                            bash_output.append(
-                                f"bash: cd: {new_dir}: No such file or directory"
-                            )
-                    else:
-                        result = subprocess.run(
-                            bash_input,
-                            shell=True,
-                            text=True,
-                            capture_output=True,
-                            cwd=current_dir,
-                        )
-                        if result.stdout:
-                            print(result.stdout.strip())
-                            bash_output.append(result.stdout.strip())
-                        if result.stderr:
-                            bash_output.append(f"Error: {result.stderr.strip()}")
-                except Exception as e:
-                    bash_output.append(f"Error executing bash command: {e}")
-        except (KeyboardInterrupt, EOFError):
-            print("\nExiting bash mode.")
-            break
-    os.chdir(current_dir)
-    return "\n".join(bash_output)
-
-
-import whisper
-import pyaudio
-import wave
-import numpy as np
-import tempfile
-import os
-
-
-def record_audio(duration=5, sample_rate=16000):
-    p = pyaudio.PyAudio()
-    stream = p.open(
-        format=pyaudio.paInt16,
-        channels=1,
-        rate=sample_rate,
-        input=True,
-        frames_per_buffer=1024,
-    )
-
-    print("Recording...")
-    frames = []
-    for _ in range(0, int(sample_rate / 1024 * duration)):
-        data = stream.read(1024)
-        frames.append(data)
-    print("Recording finished.")
-
-    stream.stop_stream()
-    stream.close()
-    p.terminate()
-
-    return b"".join(frames)
-
-
-def is_silent(audio_data, threshold=500):
-    """Check if the audio chunk is silent."""
-    return np.max(np.abs(np.frombuffer(audio_data, dtype=np.int16))) < threshold
-
-
-def record_audio(sample_rate=16000):
-    p = pyaudio.PyAudio()
-    stream = p.open(
-        format=pyaudio.paInt16,
-        channels=1,
-        rate=sample_rate,
-        input=True,
-        frames_per_buffer=1024,
-    )
-
-    print("Listening... (speak now)")
-    frames = []
-    silent_chunks = 0
-    has_speech = False
-    max_silent_chunks = int(sample_rate * 1.5 / 1024)  # 1.5 seconds of silence
-
-    while True:
-        data = stream.read(1024)
-        frames.append(data)
-
-        if is_silent(data):
-            silent_chunks += 1
-            if has_speech and silent_chunks > max_silent_chunks:
-                break
-        else:
-            silent_chunks = 0
-            has_speech = True
-
-        if len(frames) % 10 == 0:  # Print a dot every ~0.5 seconds
-            print(".", end="", flush=True)
-
-    print("\nProcessing...")
-
-    stream.stop_stream()
-    stream.close()
-    p.terminate()
-
-    return b"".join(frames)
-
-
-def enter_whisper_mode(command_history):
-    model = whisper.load_model("base")
-    whisper_output = []
-
-    print(
-        "Entering whisper mode. Speak after seeing 'Listening...'. Say 'exit' or type '/wq' to quit."
-    )
-
-    while True:
-        try:
-            audio_data = record_audio()
-
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio:
-                wf = wave.open(temp_audio.name, "wb")
-                wf.setnchannels(1)
-                wf.setsampwidth(2)
-                wf.setframerate(16000)
-                wf.writeframes(audio_data)
-                wf.close()
-
-                result = model.transcribe(temp_audio.name)
-                text = result["text"].strip()
-
-            os.unlink(temp_audio.name)
-
-            print(f"You said: {text}")
-            whisper_output.append(f"User: {text}")
-
-            if text.lower() == "exit":
-                print("Exiting whisper mode.")
-                break
-
-            # Pass the recognized text to the LLM
-            llm_response = get_llm_response(text)
-            print(f"LLM response: {llm_response}")
-            whisper_output.append(f"LLM: {llm_response}")
-
-            # Add to command history
-            command_history.add(text, ["whisper"], llm_response, os.getcwd())
-
-            print("\nPress Enter to speak again, or type '/wq' to quit.")
-            user_input = input()
-            if user_input.lower() == "/wq":
-                print("Exiting whisper mode.")
-                break
-
-        except (KeyboardInterrupt, EOFError):
-            print("\nExiting whisper mode.")
-            break
-
-    return "\n".join(whisper_output)
-
-
-def enter_notes_mode(command_history):
-    print("Entering notes mode. Type '/nq' to exit.")
-
-    while True:
-        note = input("Enter your note (or '/nq' to quit): ").strip()
-
-        if note.lower() == "/nq":
-            break
-
-        save_note(note, command_history)
-
-    print("Exiting notes mode.")
-
-
-def save_note(note, command_history):
-    current_dir = os.getcwd()
-    readme_path = os.path.join(current_dir, "README.md")
-
-    with open(readme_path, "a") as f:
-        f.write(f"\n- {note}\n")
-
-    print("Note added to README.md")
-    command_history.add(f"/note {note}", ["note"], "", current_dir)
-
-
-# Usage in your main script:
-# enter_notes_mode()
-
-
-def initial_table_print(cursor):
-    cursor.execute(
-        "SELECT name FROM sqlite_master WHERE type='table' AND name != 'command_history'"
-    )
-    tables = cursor.fetchall()
-
-    print("\nAvailable tables:")
-    for i, table in enumerate(tables, 1):
-        print(f"{i}. {table[0]}")
-
-
-def enter_observation_mode(command_history):
-    conn = command_history.conn
-    cursor = command_history.cursor
-
-    print("Entering observation mode. Type '/dq' or to exit.")
-    n_times = 0
-    while True:
-        # Show available tables
-        if n_times == 0:
-            initial_table_print(cursor)
-
-            user_query = input(
-                """
-Enter a plain-text request or one using the dataframe manipulation framework of your choice. 
-    You can also have the data NPC ingest data into your database by pointing it to the right files.
-data>"""
-            )
-
-        else:
-            user_query = input(
-                """
-data>"""
-            )
-        print(user_query)
-
-        response = execute_data_operations(user_query, command_history)
-
-        answer_prompt = f"""
-
-        Here is an input from the user:
-        {user_query}
-        Here is some useful data relevant to the query:
-        {response}
-
-        Now write a query to write a final response to be delivered to the user.
-
-        Your answer must be in the format:
-        {{"response": "Your response here."}}
-
-        """
-        final_response = get_llm_response(answer_prompt, format="json")
-        print(final_response["response"])
-        n_times += 1
-
-    conn.close()
-    print("Exiting observation mode.")
-
-
-def enter_spool_mode(command_history, inherit_last=0, model="llama3.1"):
-    print("Entering spool mode. Type '/sq' to exit spool mode.")
-    spool_context = []
-
-    # Inherit last n messages if specified
-    if inherit_last > 0:
-        last_commands = command_history.get_all(limit=inherit_last)
-        for cmd in reversed(last_commands):
-            spool_context.append({"role": "user", "content": cmd[2]})  # command
-            spool_context.append({"role": "assistant", "content": cmd[4]})  # output
-
-    while True:
-        try:
-            user_input = input("spool> ").strip()
-            if user_input.lower() == "/sq":
-                print("Exiting spool mode.")
-                break
-
-            # Add user input to spool context
-            spool_context.append({"role": "user", "content": user_input})
-
-            # Process the spool context with LLM
-            spool_context = get_ollama_conversation(spool_context, model=model)
-
-            command_history.add(
-                user_input, ["spool"], spool_context[-1]["content"], os.getcwd()
-            )
-            print(spool_context[-1]["content"])
-        except (KeyboardInterrupt, EOFError):
-            print("\nExiting spool mode.")
-            break
-
-    return "\n".join(
-        [msg["content"] for msg in spool_context if msg["role"] == "assistant"]
-    )
-
-
-def create_new_table(cursor, conn):
-    table_name = input("Enter new table name: ").strip()
-    columns = input("Enter column names separated by commas: ").strip()
-
-    create_query = (
-        f"CREATE TABLE {table_name} (id INTEGER PRIMARY KEY AUTOINCREMENT, {columns})"
-    )
-    cursor.execute(create_query)
-    conn.commit()
-    print(f"Table '{table_name}' created successfully.")
-
-
-def delete_table(cursor, conn):
-    table_name = input("Enter table name to delete: ").strip()
-    cursor.execute(f"DROP TABLE IF EXISTS {table_name}")
-    conn.commit()
-    print(f"Table '{table_name}' deleted successfully.")
-
-
-def add_observation(cursor, conn, table_name):
-    cursor.execute(f"PRAGMA table_info({table_name})")
-    columns = [column[1] for column in cursor.fetchall() if column[1] != "id"]
-
-    values = []
-    for column in columns:
-        value = input(f"Enter value for {column}: ").strip()
-        values.append(value)
-
-    insert_query = f"INSERT INTO {table_name} ({','.join(columns)}) VALUES ({','.join(['?' for _ in columns])})"
-    cursor.execute(insert_query, values)
-    conn.commit()
-    print("Observation added successfully.")

npcsh/npc_compiler.py

@@ -1,124 +0,0 @@
-import os
-import subprocess
-import sqlite3
-import yaml
-from jinja2 import Environment, FileSystemLoader, Template
-
-import os
-import yaml
-from jinja2 import Environment, FileSystemLoader, TemplateError, Template, Undefined
-
-
-class SilentUndefined(Undefined):
-    def _fail_with_undefined_error(self, *args, **kwargs):
-        return ""
-
-
-class NPCCompiler:
-    def __init__(self, npc_directory):
-        self.npc_directory = npc_directory
-        self.jinja_env = Environment(
-            loader=FileSystemLoader(self.npc_directory), undefined=SilentUndefined
-        )
-        self.npc_cache = {}
-        self.resolved_npcs = {}
-
-    def compile(self, npc_file: str):
-        if not npc_file.endswith(".npc"):
-            raise ValueError("File must have .npc extension")
-
-        try:
-            # First pass: parse all NPC files without resolving Jinja templates
-            self.parse_all_npcs()
-
-            # Second pass: resolve Jinja templates and merge inherited properties
-            self.resolve_all_npcs()
-
-            # Final pass: resolve any remaining references
-            parsed_content = self.finalize_npc_profile(npc_file)
-            return parsed_content
-        except Exception as e:
-            raise
-
-    def parse_all_npcs(self):
-        for filename in os.listdir(self.npc_directory):
-            if filename.endswith(".npc"):
-                self.parse_npc_file(filename)
-
-    def parse_npc_file(self, npc_file: str):
-        if npc_file in self.npc_cache:
-            return self.npc_cache[npc_file]
-
-        try:
-            with open(os.path.join(self.npc_directory, npc_file), "r") as f:
-                npc_content = f.read()
-
-            # Parse YAML without resolving Jinja templates
-            profile = yaml.safe_load(npc_content)
-            self.npc_cache[npc_file] = profile
-
-            return profile
-        except yaml.YAMLError as e:
-            raise ValueError(f"Invalid YAML in NPC profile {npc_file}: {str(e)}")
-
-    def resolve_all_npcs(self):
-        for npc_file in self.npc_cache:
-            self.resolve_npc_profile(npc_file)
-
-    def resolve_npc_profile(self, npc_file: str):
-        if npc_file in self.resolved_npcs:
-            return self.resolved_npcs[npc_file]
-
-        profile = self.npc_cache[npc_file].copy()
-
-        # Resolve Jinja templates
-        for key, value in profile.items():
-            if isinstance(value, str):
-                template = self.jinja_env.from_string(value)
-                profile[key] = template.render(self.npc_cache)
-
-        # Handle inheritance
-        if "inherits_from" in profile:
-            parent_profile = self.resolve_npc_profile(profile["inherits_from"] + ".npc")
-            profile = self.merge_profiles(parent_profile, profile)
-
-        self.resolved_npcs[npc_file] = profile
-        return profile
-
-    def finalize_npc_profile(self, npc_file: str):
-        profile = self.resolved_npcs[npc_file].copy()
-
-        # Resolve any remaining references
-        for key, value in profile.items():
-            if isinstance(value, str):
-                template = self.jinja_env.from_string(value)
-                profile[key] = template.render(self.resolved_npcs)
-
-        required_keys = [
-            "name",
-            "primary_directive",
-            "suggested_tools_to_use",
-            "restrictions",
-            "model",
-        ]
-        for key in required_keys:
-            if key not in profile:
-                raise ValueError(f"Missing required key in NPC profile: {key}")
-
-        return profile
-
-    def merge_profiles(self, parent, child):
-        merged = parent.copy()
-        for key, value in child.items():
-            if isinstance(value, list) and key in merged:
-                merged[key] = merged[key] + value
-            elif isinstance(value, dict) and key in merged:
-                merged[key] = self.merge_profiles(merged[key], value)
-            else:
-                merged[key] = value
-        return merged
-
-
-# Usage:
-# compiler = NPCCompiler('/path/to/npc/directory')
-# compiled_script = compiler.compile('your_npc_file.npc')

npcsh-0.1.2.dist-info/METADATA

@@ -1,99 +0,0 @@
-Metadata-Version: 2.1
-Name: npcsh
-Version: 0.1.2
-Summary: A way to use npcsh
-Home-page: https://github.com/cagostino/npcsh
-Author: Christopher Agostino
-Author-email: cjp.agostino@example.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: jinja2
-Requires-Dist: pandas
-Requires-Dist: ollama
-Requires-Dist: requests
-Requires-Dist: PyYAML
-Requires-Dist: openai-whisper
-Requires-Dist: pyaudio
-
-# npcsh
-
-Welcome to npcsh, the shell for interacting with NPCs (LLM-powered AI agents). npcsh is meant to be a drop-in replacement shell for any kind of bash/zsh/powershell and allows the user to directly operate their machine through the use of the LLM-powered shell.
-
-Additionally, npcsh introduces a new paradigm of programming for LLMs: npcsh allows users to set up NPC profiles (a la npc_profile.npc) where a user sets the primary directive of the NPC, the tools they want the NPC to use, and other properties of the NPC. NPCs can interact with each other and their primary directives and properties make these relationships explicit through jinja references.
-
-## Dependencies
-- ollama
-- python >3.10
-
-The default model is currently phi3. The user can change the model by setting the environment variable `NPCSH_MODEL` to the desired model name and to change the provider by setting the environment variable `NPCSH_PROVIDER` to the desired provider name.
-
-The provider must be one of ['ollama', 'openai', 'anthropic'] and the model must be one available from those providers.
-
-
-## compilation
-
-Each NPC can be compiled to accomplish their primary directive and then any issues faced will be recorded and associated with the NPC so that it can reference it later through vector search. In any of the modes where a user requests input from an NPC, the NPC will include RAG search results before carrying out the request.
-
-
-## Base npcsh
-
-
-In the base npcsh shell, inputs are processed by an LLM. The LLM first determines what kind of a request the user is making and decides which of the available tools or modes will best enable it to accomplish the request. 
-
-
-### spool mode
-
-Spool mode allows the users to have threaded conversations in the shell, i.e. conversations where context is retained over the course of several turns.
-Users can speak with specific NPCs in spool mode by doing ```/spool <npc_name>``` and can exit spool mode by doing ```/exit```.
-
-## Built-in NPCs
-Built-in NPCs are NPCs that should offer broad utility to the user and allow them to create more complicated NPCs. These built-in NPCs facilitate the carrying out of many common data processing tasks as well as the ability to run commands and to execute and test programs.
-
-### Bash NPC
-The bash NPC is an NPC focused on running bash commands and scripts. The bash NPC can be used to run bash commands and the user can converse with the bash NPC by doing ```/spool bash``` to interrogate it about the commands it has run and the output it has produced.
-A user can enter bash mode by typing ```/bash``` and can exit bash mode by typing ```/bq```.
-Use the Bash NPC in the profiles of other NPCs by referencing it like ```{{bash}}```.
-
-### Command NPC
-
-The LLM or specific NPC will take the user's request and try to write a command or a script to accomplish the task and then attempt to run it and to tweak it until it works or it's exceeded the number of retries (default=5).
-
-Use the Command NPC by typing ```/cmd <command>```. Chat with the Command NPC in spool mode by typing ```/spool cmd```.
-Use the Command NPC in the profiles of other NPCs by referencing it  like ```{{cmd}}```.
-
-### Data NPC
-
-Users can create schemas for recording observations and for exploring and analyzing data.
-
-The Data NPC will asily facilitate the recording of data for individuals in essentially any realm (e.g. recipe testing, one's own blood pressure or  weight, books read, movies watched, daily mood, etc.) without needing to use a tangled web of applications to do so. Observations can be referenced by the generic npcsh LLM shell or by specific NPCs.
-Use the Observation NPC by typing ```/data <observation>```.
-Chat with the Observation NPC in spool mode by typing ```/spool obs```.
-Use the Observation NPC in the profiles of other NPCs by referencing it like ```{{obs}}```. Exit by typing ```/dq```.
-
-
-### Question NPC
-
-The user can submit a 1-shot question to a general LLM or to a specific NPC.
-Use it like
-```/question <question> <npc_name>```
-or
-```/question <question>```
-
-You can also chat with the Question NPC in spool mode by typing ```/spool question```.
-
-
-
-### thought mode
-
-This will be like a way to write out some general thoughts to get some 1-shot feedback from a general LLM or a specific NPC.
-
-Use it like
-```/thought <thought> <npc_name>```
-or
-```/thought <thought>```
-
- 
-You can also chat with the Thought NPC in spool mode by typing ```/spool thought```.

npcsh-0.1.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-npcsh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-npcsh/command_history.py,sha256=HG5uAyigKu4lmBAxdk32GQXVpK_Y9mEMykYJGpKskFw,2309
-npcsh/helpers.py,sha256=jeQKzyq_YXE0wzkxY8QOby-3yUd_FTT-7q3OHTWbA-I,781
-npcsh/llm_funcs.py,sha256=NeOD39cHjGun0mW-OJWWIRSO3jzK9uXWH6NiIhpkNv0,10023
-npcsh/main.py,sha256=rpf_2ysx3cR3eHsrvZApprJ-3D3-OrWcJ15bM1bc97I,81
-npcsh/modes.py,sha256=9flrHoZnFQlREYA71hs4ByjRf4z5zoc1FCPWZzPbWvM,10198
-npcsh/npc_compiler.py,sha256=uD0mAtSDuZN4D-x9jjGi5ULBLYdiaarLdzE35PcS8lg,4076
-npcsh/npcsh.py,sha256=irgQxTA-T1E5ZvDZ8fgV-f6kchYxJtQ2-TARtbTHSUU,4137
-npcsh-0.1.2.dist-info/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
-npcsh-0.1.2.dist-info/METADATA,sha256=oQsuoR99HEvfjlybAkCzhqInprd-cdrCLbMBeOkkFCQ,4989
-npcsh-0.1.2.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-npcsh-0.1.2.dist-info/entry_points.txt,sha256=_n86Qhl0Dl5RFsV4XJcRv3GZoW8TbPF46UZq-SZavEY,43
-npcsh-0.1.2.dist-info/top_level.txt,sha256=kHSNgKMCkfjV95-DH0YSp1LLBi0HXdF3w57j7MQON3E,6
-npcsh-0.1.2.dist-info/RECORD,,

npcsh-0.1.2.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-npcsh = npcsh.npcsh:main