npcsh 0.1.0__tar.gz

npcsh-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 NPC WORLDWIDE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

npcsh-0.1.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.1
+Name: npcsh
+Version: 0.1.0
+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
+
+# 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.
+
+## 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}}```.
+
+### observation mode
+
+Users can create schemas for recording observations. The idea here is to more easily 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 ```/obs <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}}```.
+
+
+### question mode
+
+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.0/README.md

@@ -0,0 +1,68 @@
+# 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.
+
+## 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}}```.
+
+### observation mode
+
+Users can create schemas for recording observations. The idea here is to more easily 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 ```/obs <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}}```.
+
+
+### question mode
+
+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.0/npcsh/command_history.py

@@ -0,0 +1,81 @@
+import os
+import sqlite3
+import json
+from datetime import datetime
+
+
+def show_history(command_history, args):
+    if args:
+        search_results = command_history.search(args[0])
+        if search_results:
+            return "\n".join(
+                [f"{item[0]}. [{item[1]}] {item[2]}" for item in search_results]
+            )
+        else:
+            return f"No commands found matching '{args[0]}'"
+    else:
+        all_history = command_history.get_all()
+        return "\n".join([f"{item[0]}. [{item[1]}] {item[2]}" for item in all_history])
+
+
+def query_history_for_llm(command_history, query):
+    results = command_history.search(query)
+    formatted_results = [
+        f"Command: {r[2]}\nOutput: {r[4]}\nLocation: {r[5]}" for r in results
+    ]
+    return "\n\n".join(formatted_results)
+
+
+class CommandHistory:
+    def __init__(self, path="~/npcsh_history.db"):
+        self.db_path = os.path.expanduser(path)
+        self.conn = sqlite3.connect(self.db_path)
+        self.cursor = self.conn.cursor()
+        self.create_table()
+
+    def create_table(self):
+        self.cursor.execute(
+            """
+        CREATE TABLE IF NOT EXISTS command_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT,
+            command TEXT,
+            subcommands TEXT,
+            output TEXT,
+            location TEXT
+        )
+        """
+        )
+        self.conn.commit()
+
+    def add(self, command, subcommands, output, location):
+        timestamp = datetime.now().isoformat()
+        self.cursor.execute(
+            """
+        INSERT INTO command_history (timestamp, command, subcommands, output, location)
+        VALUES (?, ?, ?, ?, ?)
+        """,
+            (timestamp, command, json.dumps(subcommands), output, location),
+        )
+        self.conn.commit()
+
+    def search(self, term):
+        self.cursor.execute(
+            """
+        SELECT * FROM command_history WHERE command LIKE ?
+        """,
+            (f"%{term}%",),
+        )
+        return self.cursor.fetchall()
+
+    def get_all(self, limit=100):
+        self.cursor.execute(
+            """
+        SELECT * FROM command_history ORDER BY id DESC LIMIT ?
+        """,
+            (limit,),
+        )
+        return self.cursor.fetchall()
+
+    def close(self):
+        self.conn.close()

npcsh-0.1.0/npcsh/helpers.py

@@ -0,0 +1,36 @@
+# helpers.py
+import logging
+
+logging.basicConfig(
+    filename=".npcsh.log",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+import os
+
+
+def list_directory(args):
+    directory = args[0] if args else "."
+    try:
+        files = os.listdir(directory)
+        for f in files:
+            print(f)
+    except Exception as e:
+        print(f"Error listing directory: {e}")
+
+
+def read_file(args):
+    if not args:
+        print("Usage: /read <filename>")
+        return
+    filename = args[0]
+    try:
+        with open(filename, "r") as file:
+            content = file.read()
+            print(content)
+    except Exception as e:
+        print(f"Error reading file: {e}")
+
+
+def log_action(action, detail=""):
+    logging.info(f"{action}: {detail}")

npcsh-0.1.0/npcsh/llm_funcs.py

@@ -0,0 +1,218 @@
+import subprocess
+import requests
+import os
+import json
+import ollama
+
+def get_ollama_conversion(messages, model):
+    # print(messages)
+
+    response = ollama.chat(model=model, messages=messages)
+    messages.append(response["message"])
+    # print(response["message"])
+    return messages
+
+
+"""
+test_messages = [
+{"role": "user", "content": "hows it going"}]
+model = "llama3.1"
+ea =   get_ollama_conversion(ea, model)
+
+ea.append({"role": "user", "content": "then can you help me design something really spectacular?"})
+
+
+"""
+
+
+def get_ollama_response(prompt, model, format=None, **kwargs):
+    try:
+        url = "http://localhost:11434/api/generate"
+        data = {
+            "model": model,
+            "prompt": prompt,
+            "stream": False,
+        }
+        if format is not None:
+            data["format"] = format
+
+        # print(f"Requesting LLM response for prompt: {prompt}")
+        response = requests.post(url, json=data)
+        response.raise_for_status()
+        llm_response = json.loads(response.text)["response"]
+
+        # If format is JSON, try to parse the response as JSON
+        if format == "json":
+            try:
+                return json.loads(llm_response)
+            except json.JSONDecodeError:
+                print(f"Warning: Expected JSON response, but received: {llm_response}")
+                return {"error": "Invalid JSON response"}
+        else:
+            return llm_response
+    except Exception as e:
+        return f"Error interacting with LLM: {e}"
+
+
+def get_openai_response(prompt, model, functional_requirements=None):
+    pass
+
+
+def get_claude_response(prompt, model, format=None):
+    pass
+
+
+def get_llm_response(prompt, provider="ollama", model="phi3", **kwargs):
+    if provider == "ollama":
+        return get_ollama_response(prompt, model, **kwargs)
+    elif provider == "openai":
+        return get_openai_response(prompt, model, **kwargs)
+    elif provider == "claude":
+        return get_claude_response(prompt, model, **kwargs)
+    else:
+        return "Error: Invalid provider specified."
+
+
+def execute_llm_command(command, command_history):
+    max_attempts = 5
+    attempt = 0
+    subcommands = []
+
+    location = os.getcwd()
+    while attempt < max_attempts:
+        prompt = f"""
+        A user submitted this query: {command}.
+        You need to generate a bash command that will accomplish the user's intent.
+        Respond ONLY with the command that should be executed.
+        in the json key "bash_command".
+        You must reply with valid json and nothing else.
+        """
+
+        response = get_llm_response(prompt, format="json")
+        print(f"LLM suggests: {response}")
+
+        if isinstance(response, dict) and "bash_command" in response:
+            bash_command = response["bash_command"]
+        else:
+            print("Error: Invalid response format from LLM")
+            attempt += 1
+            continue
+
+        try:
+            subcommands.append(bash_command)
+            result = subprocess.run(
+                bash_command, shell=True, text=True, capture_output=True
+            )
+            if result.returncode == 0:
+                # simplify the output
+                prompt = f"""
+                    Here was the output of the result for the {command} inquiry  
+                    which ran this bash command {bash_command}:
+
+                    {result.stdout}
+
+                    Provide a simple short description that provides the most
+                    useful information about the command's result.
+
+                        """
+                response = get_llm_response(prompt)
+                print(response)
+                output = response
+                command_history.add(command, subcommands, output, location)
+
+                return response
+            else:
+                print(f"Command failed with error:")
+                print(result.stderr)
+
+            error_prompt = f"""
+            The command '{bash_command}' failed with the following error:
+            {result.stderr}
+            Please suggest a fix or an alternative command.
+            Respond with a JSON object containing the key "bash_command" with the suggested command.
+            """
+            fix_suggestion = get_llm_response(error_prompt, format="json")
+            if isinstance(fix_suggestion, dict) and "bash_command" in fix_suggestion:
+                print(f"LLM suggests fix: {fix_suggestion['bash_command']}")
+                command = fix_suggestion["bash_command"]
+            else:
+                print("Error: Invalid response format from LLM for fix suggestion")
+        except Exception as e:
+            print(f"Error executing command: {e}")
+
+        attempt += 1
+    command_history.add(command, subcommands, "Execution failed", location)
+
+    print("Max attempts reached. Unable to execute the command successfully.")
+    return "Max attempts reached. Unable to execute the command successfully."
+
+
+def execute_llm_question(command, command_history):
+    location = os.getcwd()
+
+    prompt = f"""
+    A user submitted this query: {command}
+    You need to generate a response to the user's inquiry.
+    Respond ONLY with the response that should be given.
+    in the json key "response".
+    You must reply with valid json and nothing else.
+    """
+    response = get_llm_response(prompt, format="json")
+    print(f"LLM suggests: {response}")
+    output = response["response"]
+    command_history.add(command, [], output, location)
+    return response["response"]
+
+
+def execute_llm_thought(command, command_history):
+    location = os.getcwd()
+    prompt = f"""
+    A user submitted this query: {command} . 
+    Please generate a response to the user's inquiry.
+    Respond ONLY with the response that should be given.
+    in the json key "response".
+    You must reply with valid json and nothing else.
+    """
+    response = get_llm_response(prompt, format="json")
+    print(f"LLM suggests: {response}")
+    output = response["response"]
+    command_history.add(command, [], output, location)
+    return response["response"]
+
+
+def check_llm_command(command, command_history):
+    # check what kind of request the command is
+    prompt = f"""
+    A user submitted this query: {command}
+    What kind of request is this? 
+    [Command, Thought]
+    Thoughts are simply musings or ideas.
+    Commands are requests for a specific action to be performed.
+    
+    Most requests are likely to be commands so only use the other options if
+    the request is clearly not a command.
+
+
+    Return your response in valid json key "request_type". 
+    
+    Provide an explanation in key "explanation".
+    Your answer must be like
+    
+    {{"request_type": "Command", 
+        "explanation": "This is a command because..."}}
+    or
+    {{"request_type": "Thought", 
+        "explanation": "This is a thought because..."}}
+    """
+
+    response = get_llm_response(prompt, format="json")
+    correct_request_type = response["request_type"]
+    print(f"LLM initially suggests: {response}")
+    # does the user agree with the request type? y/n
+
+    if correct_request_type == "Command":
+        return execute_llm_command(command, command_history)
+    elif correct_request_type == "Question":
+        return execute_llm_question(command, command_history)
+    elif correct_request_type == "Thought":
+        return execute_llm_thought(command, command_history)

npcsh-0.1.0/npcsh/main.py

@@ -0,0 +1,5 @@
+def main():
+    print("Hello from npcsh!")
+
+if __name__ == "__main__":
+    main()

npcsh-0.1.0/npcsh/modes.py

@@ -0,0 +1,189 @@
+# modes.py
+import os
+import subprocess
+from .llm_funcs import get_ollama_conversion
+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)
+
+
+def enter_whisper_mode():
+    pass
+
+
+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 enter_observation_mode(command_history):
+    conn = command_history.conn
+    cursor = command_history.cursor
+
+    print("Entering observation mode. Type '/obsq' or '/oq' to exit.")
+
+    while True:
+        # Show available tables
+        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]}")
+        print("n. Create new table")
+        print("d. Delete a table")
+        print("q. Exit observation mode")
+
+        choice = input("Choose an option: ").strip().lower()
+
+        if choice == "q" or choice == "/obsq" or choice == "/oq":
+            break
+        elif choice == "n":
+            create_new_table(cursor, conn)
+        elif choice == "d":
+            delete_table(cursor, conn)
+        elif choice.isdigit() and 1 <= int(choice) <= len(tables):
+            add_observation(cursor, conn, tables[int(choice) - 1][0])
+
+    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_conversion(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-0.1.0/npcsh/npc_compiler.py

@@ -0,0 +1,124 @@
+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.0/npcsh/npcsh.py

@@ -0,0 +1,132 @@
+# npcsh.py
+import os
+
+import readline
+import atexit
+from datetime import datetime
+import pandas as pd
+
+# Configure logging
+
+
+from .command_history import CommandHistory
+from .llm_funcs import (
+    get_llm_response,
+    execute_llm_command,
+    check_llm_command,
+    execute_llm_question,
+    execute_llm_thought,
+)
+from .modes import (
+    enter_bash_mode,
+    enter_whisper_mode,
+    enter_notes_mode,
+    enter_observation_mode,
+    enter_spool_mode,
+)
+from .helpers import log_action, list_directory, read_file
+from .npc_compiler import NPCCompiler
+
+
+def execute_command(command, command_history, db_path, npc_compiler):
+    subcommands = []
+    output = ""
+    location = os.getcwd()
+
+    if command.startswith("/"):
+        command = command[1:]
+        log_action("Command Executed", command)
+
+        command_parts = command.split()
+        command_name = command_parts[0]
+        args = command_parts[1:]
+
+        if (
+            command_name == "b"
+            or command_name == "bash"
+            or command_name == "zsh"
+            or command_name == "sh"
+        ):
+            output = enter_bash_mode()
+        if command_name == "compile" or command_name == "com":
+            try:
+                compiled_script = npc_compiler.compile(args[0])
+                output = f"Compiled NPC profile: {compiled_script}"
+                print(output)
+            except Exception as e:
+                output = f"Error compiling NPC profile: {str(e)}"
+                print(output)
+
+        elif command_name == "whisper":
+            output = enter_whisper_mode()
+        elif command_name == "notes":
+            output = enter_notes_mode(command_history)
+        elif command_name == "obs":
+            print(db_path)
+            output = enter_observation_mode(command_history)
+        elif command_name == "cmd" or command_name == "command":
+            output = execute_llm_command(command, command_history)
+        elif command_name == "?":
+            output = execute_llm_question(command, command_history)
+        elif command_name == "th" or command_name == "thought":
+            output = execute_llm_thought(command, command_history)
+        elif command_name == "spool" or command_name == "sp":
+            inherit_last = int(args[0]) if args else 0
+
+            output = enter_spool_mode(command_history, inherit_last)
+        else:
+            output = f"Unknown command: {command_name}"
+
+        subcommands = [f"/{command}"]
+    else:
+        output = check_llm_command(command, command_history)
+
+    command_history.add(command, subcommands, output, location)
+
+
+def setup_readline():
+    readline.set_history_length(1000)
+    readline.parse_and_bind("set editing-mode vi")
+    readline.parse_and_bind('"\C-r": reverse-search-history')
+
+
+def save_readline_history():
+    readline.write_history_file(os.path.expanduser("~/.npcsh_readline_history"))
+
+
+def main():
+    # check if theres a set path to a local db in the os env
+    if "NPCSH_DB_PATH" in os.environ:
+        db_path = os.environ["NPCSH_DB_PATH"]
+        command_history = CommandHistory(db_path)
+
+    else:
+        db_path = "~/npcsh_history.db"
+        command_history = CommandHistory()
+    # Initialize NPCCompiler
+    os.makedirs("./npc_profiles", exist_ok=True)
+    npc_directory = os.path.expanduser(
+        "./npc_profiles"
+    )  # You can change this to your preferred directory
+    npc_compiler = NPCCompiler(npc_directory)
+
+    setup_readline()
+    atexit.register(save_readline_history)
+    atexit.register(command_history.close)
+
+    print("Welcome to npcsh!")
+    while True:
+        try:
+            user_input = input("npcsh> ").strip()
+            if user_input.lower() in ["exit", "quit"]:
+                print("Goodbye!")
+                break
+            else:
+                execute_command(user_input, command_history, db_path, npc_compiler)
+        except (KeyboardInterrupt, EOFError):
+            print("\nGoodbye!")
+            break
+
+
+if __name__ == "__main__":
+    main()

npcsh-0.1.0/npcsh.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.1
+Name: npcsh
+Version: 0.1.0
+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
+
+# 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.
+
+## 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}}```.
+
+### observation mode
+
+Users can create schemas for recording observations. The idea here is to more easily 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 ```/obs <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}}```.
+
+
+### question mode
+
+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.0/npcsh.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+setup.py
+npcsh/__init__.py
+npcsh/command_history.py
+npcsh/helpers.py
+npcsh/llm_funcs.py
+npcsh/main.py
+npcsh/modes.py
+npcsh/npc_compiler.py
+npcsh/npcsh.py
+npcsh.egg-info/PKG-INFO
+npcsh.egg-info/SOURCES.txt
+npcsh.egg-info/dependency_links.txt
+npcsh.egg-info/entry_points.txt
+npcsh.egg-info/requires.txt
+npcsh.egg-info/top_level.txt

npcsh-0.1.0/npcsh.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

npcsh-0.1.0/npcsh.egg-info/entry_points.txt

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

npcsh-0.1.0/npcsh.egg-info/requires.txt

@@ -0,0 +1,5 @@
+jinja2
+pandas
+ollama
+requests
+PyYAML

npcsh-0.1.0/npcsh.egg-info/top_level.txt

@@ -0,0 +1 @@
+npcsh

npcsh-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

npcsh-0.1.0/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="npcsh",
+    version="0.1.0",
+    packages=find_packages(exclude=["tests*"]),
+    install_requires=[
+        'jinja2',
+        'pandas', 
+        'ollama',
+        'requests',
+        'PyYAML'
+    ],
+    entry_points={
+        'console_scripts': [
+            'npcsh=npcsh.npcsh:main',
+        ],
+    },    
+    author="Christopher Agostino",
+    author_email="cjp.agostino@example.com",
+    description="A way to use npcsh",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/cagostino/npcsh",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+    ],
+    python_requires=">=3.10",
+)