symbolicai 0.20.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

symai/shellsv.py

@@ -1,5 +1,4 @@
 import argparse
-import glob
 import json
 import logging
 import os
@@ -10,8 +9,9 @@ import subprocess
 import sys
 import time
 import traceback
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Iterable, Tuple
+from types import SimpleNamespace
 
 #@TODO: refactor to use rich instead of prompt_toolkit
 from prompt_toolkit import HTML, PromptSession, print_formatted_text
@@ -19,23 +19,27 @@ from prompt_toolkit.completion import Completer, Completion, WordCompleter
 from prompt_toolkit.history import History
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.keys import Keys
-from prompt_toolkit.lexers import PygmentsLexer
 from prompt_toolkit.patch_stdout import patch_stdout
 from prompt_toolkit.shortcuts import CompleteStyle, ProgressBar
 from prompt_toolkit.styles import Style
-from pygments.lexers.shell import BashLexer
 
 from .backend.settings import HOME_PATH, SYMSH_CONFIG
 from .components import FileReader, Function, Indexer
-from .extended import (ArxivPdfParser, Conversation, DocumentRetriever,
-                       FileMerger, RepositoryCloner,
-                       RetrievalAugmentedConversation)
+from .extended import (
+    ArxivPdfParser,
+    Conversation,
+    DocumentRetriever,
+    FileMerger,
+    RepositoryCloner,
+    RetrievalAugmentedConversation,
+)
 from .imports import Import
 from .interfaces import Interface
 from .menu.screen import show_intro_menu
 from .misc.console import ConsoleStyle
 from .misc.loader import Loader
 from .symbol import Symbol
+from .utils import UserMessage
 
 logging.getLogger("prompt_toolkit").setLevel(logging.ERROR)
 logging.getLogger("asyncio").setLevel(logging.ERROR)
@@ -43,14 +47,14 @@ logging.getLogger("subprocess").setLevel(logging.ERROR)
 
 # load json config from home directory root
 home_path = HOME_PATH
-config_path = os.path.join(home_path, 'symsh.config.json')
+config_path = home_path / 'symsh.config.json'
 # migrate config from old path
 if 'colors' not in SYMSH_CONFIG:
     __new_config__ = {"colors": SYMSH_CONFIG}
     # add command in config
     SYMSH_CONFIG = __new_config__
     # save config
-    with open(config_path, 'w') as f:
+    with config_path.open('w') as f:
         json.dump(__new_config__, f, indent=4)
 
 # make sure map-nt-cmd is in config
@@ -58,15 +62,22 @@ if 'map-nt-cmd' not in SYMSH_CONFIG:
     # add command in config
     SYMSH_CONFIG['map-nt-cmd'] = True
     # save config
-    with open(config_path, 'w') as f:
+    with config_path.open('w') as f:
         json.dump(SYMSH_CONFIG, f, indent=4)
 
-print                     = print_formatted_text
-FunctionType              = Function
-ConversationType          = Conversation
-RetrievalConversationType = RetrievalAugmentedConversation
-use_styles                = False
-map_nt_cmd_enabled        = SYMSH_CONFIG['map-nt-cmd']
+print = print_formatted_text # noqa
+map_nt_cmd_enabled = SYMSH_CONFIG['map-nt-cmd']
+
+_shell_state = SimpleNamespace(
+    function_type=Function,
+    conversation_type=Conversation,
+    retrieval_conversation_type=RetrievalAugmentedConversation,
+    use_styles=False,
+    stateful_conversation=None,
+    previous_kwargs=None,
+    previous_prefix=None,
+    exec_prefix="default",
+)
 
 SHELL_CONTEXT = """[Description]
 This shell program is the command interpreter on the Linux systems, MacOS and Windows PowerShell.
@@ -80,9 +91,6 @@ If additional instructions are provided the follow the user query to produce the
 A well related and helpful answer with suggested improvements is preferred over "I don't know" or "I don't understand" answers or stating the obvious.
 """
 
-stateful_conversation = None
-previous_kwargs       = None
-
 def supports_ansi_escape():
     try:
         os.get_terminal_size(0)
@@ -91,14 +99,22 @@ def supports_ansi_escape():
         return False
 
 class PathCompleter(Completer):
-    def get_completions(self, document, complete_event):
+    def get_completions(self, document, _complete_event):
         complete_word = document.get_word_before_cursor(WORD=True)
         sep = os.path.sep
         if complete_word.startswith(f'~{sep}'):
             complete_word = FileReader.expand_user_path(complete_word)
 
         # list all files and directories in current directory
-        files = list(glob.glob(complete_word + '*'))
+        complete_path = Path(complete_word)
+        if complete_word.endswith(sep):
+            parent = complete_path
+            pattern = '*'
+        else:
+            baseline = Path()
+            parent = complete_path.parent if complete_path.parent != baseline else baseline
+            pattern = f"{complete_path.name}*" if complete_path.name else '*'
+        files = [str(path) for path in parent.glob(pattern)]
         if len(files) == 0:
             return None
 
@@ -106,6 +122,7 @@ class PathCompleter(Completer):
         files_ = []
 
         for file in files:
+            path_obj = Path(file)
             # split the command into words by space (ignore escaped spaces)
             command_words = document.text.split(' ')
             if len(command_words) > 1:
@@ -115,28 +132,27 @@ class PathCompleter(Completer):
             else:
                 start_position = len(document.text)
             # if there is a space in the file name, then escape it
-            if ' ' in file:
-                file = file.replace(' ', '\\ ')
-            if (document.text.startswith('cd') or document.text.startswith('mkdir')) and os.path.isfile(file):
+            display_name = file.replace(' ', '\\ ') if ' ' in file else file
+            if (document.text.startswith('cd') or document.text.startswith('mkdir')) and path_obj.is_file():
                 continue
-            if os.path.isdir(file):
-                dirs_.append(file)
+            if path_obj.is_dir():
+                dirs_.append(display_name)
             else:
-                files_.append(file)
+                files_.append(display_name)
 
         for d in dirs_:
             # if starts with home directory, then replace it with ~
-            d = FileReader.expand_user_path(d)
-            yield Completion(d, start_position=-start_position,
-                             style='class:path-completion',
-                             selected_style='class:path-completion-selected')
+            directory_completion = FileReader.expand_user_path(d)
+            yield Completion(directory_completion, start_position=-start_position,
+                                 style='class:path-completion',
+                                 selected_style='class:path-completion-selected')
 
         for f in files_:
             # if starts with home directory, then replace it with ~
-            f = FileReader.expand_user_path(f)
-            yield Completion(f, start_position=-start_position,
-                             style='class:file-completion',
-                             selected_style='class:file-completion-selected')
+            file_completion = FileReader.expand_user_path(f)
+            yield Completion(file_completion, start_position=-start_position,
+                                 style='class:file-completion',
+                                 selected_style='class:file-completion-selected')
 
 class HistoryCompleter(WordCompleter):
     def get_completions(self, document, complete_event):
@@ -182,25 +198,23 @@ class MergedCompleter(Completer):
 
 # Create custom keybindings
 bindings = KeyBindings()
-previous_prefix = None
-exec_prefix = 'default'
 # Get a copy of the current environment
 default_env = os.environ.copy()
 
 def get_exec_prefix():
+    exec_prefix = _shell_state.exec_prefix
     return sys.exec_prefix if exec_prefix == 'default' else exec_prefix
 
 def get_conda_env():
     # what conda env am I in (e.g., where is my Python process from)?
     ENVBIN = get_exec_prefix()
-    env_name = os.path.basename(ENVBIN)
-    return env_name
+    return Path(ENVBIN).name
 
 # bind to 'Ctrl' + 'Space'
 @bindings.add(Keys.ControlSpace)
 def _(event):
     current_user_input = event.current_buffer.document.text
-    func = FunctionType(SHELL_CONTEXT)
+    func = _shell_state.function_type(SHELL_CONTEXT)
 
     bottom_toolbar = HTML(' <b>[f]</b> Print "f" <b>[x]</b> Abort.')
 
@@ -209,30 +223,29 @@ def _(event):
 
     cancel = [False]
     @kb.add('f')
-    def _(event):
-        print('You pressed `f`.')
+    def _(_event):
+        UserMessage('You pressed `f`.', style="alert")
 
     @kb.add('x')
-    def _(event):
+    def _(_event):
         " Send Abort (control-c) signal. "
         cancel[0] = True
         os.kill(os.getpid(), signal.SIGINT)
 
     # Use `patch_stdout`, to make sure that prints go above the
     # application.
-    with patch_stdout():
-        with ProgressBar(key_bindings=kb, bottom_toolbar=bottom_toolbar) as pb:
-            # TODO: hack to simulate progress bar of indeterminate length of an synchronous function
-            for i in pb(range(100)):
-                if i > 50 and i < 70:
-                    time.sleep(.01)
+    with patch_stdout(), ProgressBar(key_bindings=kb, bottom_toolbar=bottom_toolbar) as pb:
+        # TODO: hack to simulate progress bar of indeterminate length of an synchronous function
+        for i in pb(range(100)):
+            if i > 50 and i < 70:
+                time.sleep(.01)
 
-                if i == 60:
-                    res = func(current_user_input) # hack to see progress bar
+            if i == 60:
+                res = func(current_user_input) # hack to see progress bar
 
-                # Stop when the cancel flag has been set.
-                if cancel[0]:
-                    break
+            # Stop when the cancel flag has been set.
+            if cancel[0]:
+                break
 
     with ConsoleStyle('code') as console:
         console.print(res)
@@ -255,14 +268,14 @@ class FileHistory(History):
     '''
 
     def __init__(self, filename: str) -> None:
-        self.filename = filename
+        self.filename = Path(filename)
         super().__init__()
 
     def load_history_strings(self) -> Iterable[str]:
         lines: list[str] = []
 
-        if os.path.exists(self.filename):
-            with open(self.filename, "r") as f:
+        if self.filename.exists():
+            with self.filename.open() as f:
                 lines = f.readlines()
                 # Remove comments and empty lines.
                 lines = [line for line in lines if line.strip() and not line.startswith("#")]
@@ -276,17 +289,17 @@ class FileHistory(History):
 
     def store_string(self, string: str) -> None:
         # Save to file.
-        with open(self.filename, "ab") as f:
+        with self.filename.open("ab") as f:
 
             def write(t: str) -> None:
                 f.write(t.encode("utf-8"))
 
             for line in string.split("\n"):
-                write("%s\n" % line)
+                write(f"{line}\n")
 
 # Defining commands history
 def load_history(home_path=HOME_PATH, history_file='.bash_history'):
-    history_file_path = os.path.join(home_path, history_file)
+    history_file_path = home_path / history_file
     history = FileHistory(history_file_path)
     return history, list(history.load_history_strings())
 
@@ -294,14 +307,14 @@ def load_history(home_path=HOME_PATH, history_file='.bash_history'):
 def get_git_branch():
     try:
         git_process = subprocess.Popen(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        stdout, stderr = git_process.communicate()
+        stdout, _stderr = git_process.communicate()
         if git_process.returncode == 0:
             return stdout.strip().decode('utf-8')
     except FileNotFoundError:
         pass
     return None
 
-def disambiguate(cmds: str) -> Tuple[str, int]:
+def disambiguate(cmds: str) -> tuple[str, int]:
     '''
     Ok, so, possible options for now:
         1. query | cmd
@@ -311,140 +324,199 @@ def disambiguate(cmds: str) -> Tuple[str, int]:
         4. query | cmd cmd ...
         5. query | file | cmd
     '''
-    has_at_least_one_cmd = any([shutil.which(cmd) is not None for cmd in cmds.split(' ')])
+    has_at_least_one_cmd = any(shutil.which(cmd) is not None for cmd in cmds.split(' '))
     maybe_cmd   = cmds.split(' ')[0].strip() # get first command
     maybe_files = FileReader.extract_files(cmds)
     # if cmd follows file(s) or file(s) follows cmd throw error as not supported
     if maybe_files is not None and has_at_least_one_cmd:
-        raise ValueError('Cannot disambiguate commands that have both files and commands or multiple commands. Please provide correct order of commands. '
-                         'Supported are: '
-                         'query | file [file ...] (e.g. "what do these files have in common?" | file1 [file2 ...]) '
-                         'and '
-                         'query | cmd (e.g. "what flags can I use with rg?" | rg --help)')
+        msg = (
+            'Cannot disambiguate commands that have both files and commands or multiple commands. Please provide '
+            'correct order of commands. Supported are: query | file [file ...] (e.g. "what do these files have in '
+            'common?" | file1 [file2 ...]) and query | cmd (e.g. "what flags can I use with rg?" | rg --help)'
+        )
+        UserMessage(msg, raise_with=ValueError)
     # now check order of commands and keep correct order
     if shutil.which(maybe_cmd) is not None:
-        cmd_out = subprocess.run(cmds, capture_output=True, text=True, shell=True)
+        cmd_out = subprocess.run(cmds, check=False, capture_output=True, text=True, shell=True)
         if not cmd_out.stdout:
-            raise ValueError(f'Command not found or failed. Error: {cmd_out.stderr}')
+            msg = f'Command not found or failed. Error: {cmd_out.stderr}'
+            UserMessage(msg, raise_with=ValueError)
         return cmd_out.stdout, 1
     if maybe_files is not None:
         return maybe_files, 2
+    return None
 
 # query language model
+def _starts_with_prefix(query: str, prefix: str) -> bool:
+    return (
+        query.startswith(f'{prefix}"')
+        or query.startswith(f"{prefix}'")
+        or query.startswith(f'{prefix}`')
+    )
+
+
+def _is_new_conversation_query(query: str) -> bool:
+    return _starts_with_prefix(query, '!')
+
+
+def _is_followup_conversation_query(query: str) -> bool:
+    return _starts_with_prefix(query, '.')
+
+
+def _is_stateful_query(query: str) -> bool:
+    return any(_starts_with_prefix(query, prefix) for prefix in ['.', '!'])
+
+
+def _extract_query_kwargs(query: str, previous_kwargs, existing_kwargs):
+    if '--kwargs' not in query and '-kw' not in query:
+        return query, existing_kwargs, previous_kwargs
+
+    splitter = '--kwargs' if '--kwargs' in query else '-kw'
+    splits = query.split(splitter)
+    suffix = splits[-1]
+    if previous_kwargs is None and '=' not in suffix and ',' not in suffix:
+        msg = 'Kwargs format must be last in query.'
+        UserMessage(msg, raise_with=ValueError)
+    if previous_kwargs is not None and '=' not in suffix and ',' not in suffix:
+        cmd_kwargs = previous_kwargs
+    else:
+        query = splits[0].strip()
+        kwargs_str = suffix.strip()
+        cmd_kwargs = dict([kw.split('=') for kw in kwargs_str.split(',')])
+        cmd_kwargs = {k.strip(): Symbol(v.strip()).ast() for k, v in cmd_kwargs.items()}
+
+    previous_kwargs = cmd_kwargs
+    merged_kwargs = {**existing_kwargs, **cmd_kwargs}
+    return query, merged_kwargs, previous_kwargs
+
+
+def _process_new_conversation(query, conversation_cls, symai_path, plugin, previous_kwargs, state):
+    symai_path.parent.mkdir(parents=True, exist_ok=True)
+    conversation = conversation_cls(auto_print=False)
+    conversation_cls.save_conversation_state(conversation, symai_path)
+    state.stateful_conversation = conversation
+    if plugin is None:
+        return conversation, previous_kwargs, None, False
+    with Loader(desc="Inference ...", end=""):
+        cmd = query[1:].strip('\'"')
+        cmd = f"symrun {plugin} '{cmd}' --disable-pbar"
+        cmd_out = run_shell_command(cmd, auto_query_on_error=True)
+        conversation.store(cmd_out)
+        conversation_cls.save_conversation_state(conversation, symai_path)
+        state.stateful_conversation = conversation
+        state.previous_kwargs = previous_kwargs
+        return conversation, previous_kwargs, cmd_out, True
+
+
+def _process_followup_conversation(query, conversation, conversation_cls, symai_path, plugin, previous_kwargs, state):
+    try:
+        conversation = conversation.load_conversation_state(symai_path)
+        state.stateful_conversation = conversation
+    except Exception:
+        with ConsoleStyle('error') as console:
+            console.print('No conversation state found. Please start a new conversation.')
+        return conversation, previous_kwargs, None, True
+    if plugin is None:
+        return conversation, previous_kwargs, None, False
+    with Loader(desc="Inference ...", end=""):
+        trimmed_query = query[1:].strip('\'"')
+        answer = conversation(trimmed_query).value
+        cmd = f"symrun {plugin} '{answer}' --disable-pbar"
+        cmd_out = run_shell_command(cmd, auto_query_on_error=True)
+        conversation.store(cmd_out)
+        conversation_cls.save_conversation_state(conversation, symai_path)
+        state.stateful_conversation = conversation
+        state.previous_kwargs = previous_kwargs
+        return conversation, previous_kwargs, cmd_out, True
+
+
+def _handle_piped_query(query, conversation, state):
+    cmds = query.split('|')
+    if len(cmds) > 2:
+        msg = (
+            'Cannot disambiguate commands that have more than 1 pipes. Please provide correct order of commands. '
+            'Supported are: query | file [file ...] (e.g. "what do these files have in common?" | file1 [file2 ...]) '
+            'and query | cmd (e.g. "what flags can I use with rg?" | rg --help)'
+        )
+        UserMessage(msg, raise_with=ValueError)
+    base_query = cmds[0]
+    payload, order = disambiguate(cmds[1].strip())
+    is_stateful = _is_stateful_query(base_query)
+    if is_stateful:
+        func = conversation
+    else:
+        func = (
+            state.function_type(payload)
+            if order == 1
+            else state.conversation_type(file_link=payload, auto_print=False)
+        )
+    if is_stateful:
+        if order == 1:
+            func.store(payload)
+        elif order == 2:
+            for file in payload:
+                func.store_file(file)
+    return func, base_query
+
+
+def _select_function_for_query(query, conversation, state):
+    if '|' in query:
+        return _handle_piped_query(query, conversation, state)
+    if _is_stateful_query(query):
+        return conversation, query
+    return state.function_type(SHELL_CONTEXT), query
+
+
+def _should_save_conversation(conversation, query):
+    if conversation is None:
+        return False
+    return _is_stateful_query(query)
+
+
 def query_language_model(query: str, res=None, *args, **kwargs):
-    global stateful_conversation, previous_kwargs
+    state = _shell_state
+    conversation = state.stateful_conversation
+    previous_kwargs = state.previous_kwargs
+    conversation_cls = state.conversation_type
     home_path = HOME_PATH
-    symai_path = os.path.join(home_path, '.conversation_state')
+    symai_path = home_path / '.conversation_state'
     plugin = SYMSH_CONFIG.get('plugin_prefix')
 
-    # check and extract kwargs from query if any
-    # format --kwargs key1=value1,key2=value2,key3=value3,...keyN=valueN
-    if '--kwargs' in query or '-kw' in query:
-        splitter = '--kwargs' if '--kwargs' in query else '-kw'
-        # check if kwargs format is last in query otherwise raise error
-        splits = query.split(f'{splitter}')
-        if previous_kwargs is None and '=' not in splits[-1] and ',' not in splits[-1]:
-            raise ValueError('Kwargs format must be last in query.')
-        elif previous_kwargs is not None and '=' not in splits[-1] and ',' not in splits[-1]:
-            # use previous kwargs
-            cmd_kwargs = previous_kwargs
-        else:
-            # remove kwargs from query
-            query = splits[0].strip()
-            # extract kwargs
-            kwargs_str = splits[-1].strip()
-            cmd_kwargs = dict([kw.split('=') for kw in kwargs_str.split(',')])
-            cmd_kwargs = {k.strip(): Symbol(v.strip()).ast() for k, v in cmd_kwargs.items()}
-
-        previous_kwargs = cmd_kwargs
-        # unpack cmd_kwargs to kwargs
-        kwargs = {**kwargs, **cmd_kwargs}
-
-    # Handle stateful conversations:
-    # 1. If query starts with !" (new conversation), create new conversation state
-    # 2. If query starts with ." (follow-up), either:
-    #    - Load existing conversation state if it exists
-    #    - Create new conversation state if none exists
-    if (query.startswith('!"') or query.startswith("!'") or query.startswith('!`')):
-        os.makedirs(os.path.dirname(symai_path), exist_ok=True)
-        stateful_conversation = ConversationType(auto_print=False)
-        ConversationType.save_conversation_state(stateful_conversation, symai_path)
-        # Special case: if query starts with !" and has a prefix, run the prefix command and store the output
-        if plugin is not None:
-            with Loader(desc="Inference ...", end=""):
-                cmd = query[1:].strip('\'"')
-                cmd = f"symrun {plugin} '{cmd}' --disable-pbar"
-                cmd_out = run_shell_command(cmd, auto_query_on_error=True)
-                stateful_conversation.store(cmd_out)
-                ConversationType.save_conversation_state(stateful_conversation, symai_path)
-                return cmd_out
-    elif query.startswith('."') or query.startswith(".'") or query.startswith('.`'):
-        try:
-            stateful_conversation = stateful_conversation.load_conversation_state(symai_path)
-        except Exception:
-            with ConsoleStyle('error') as console:
-                console.print('No conversation state found. Please start a new conversation.')
-            return
-        if plugin is not None:
-            with Loader(desc="Inference ...", end=""):
-                query = query[1:].strip('\'"')
-                answer = stateful_conversation(query).value
-                cmd = f"symrun {plugin} '{answer}' --disable-pbar"
-                cmd_out = run_shell_command(cmd, auto_query_on_error=True)
-                stateful_conversation.store(cmd_out)
-                ConversationType.save_conversation_state(stateful_conversation, symai_path)
-                return cmd_out
-    cmd = None
-    if '|' in query:
-        cmds = query.split('|')
-        if len(cmds) > 2:
-            raise ValueError(('Cannot disambiguate commands that have more than 1 pipes. Please provide correct order of commands. '
-                              'Supported are: '
-                              'query | file [file ...] (e.g. "what do these files have in common?" | file1 [file2 ...]) '
-                              'and '
-                              'query | cmd (e.g. "what flags can I use with rg?" | rg --help)'))
-        query = cmds[0]
-        payload, order = disambiguate(cmds[1].strip())
-        # check if we're in a stateful conversation
-        is_stateful = query.startswith(('.', '!')) and any(query.startswith(f"{prefix}{quote}")
-                     for prefix in ['.', '!']
-                     for quote in ['"', "'", '`'])
-
-        if is_stateful:
-            func = stateful_conversation
-        else:
-            func = FunctionType(payload) if order == 1 else ConversationType(file_link=payload, auto_print=False)
-
-        if is_stateful:
-            if order == 1:
-                func.store(payload)
-            elif order == 2:
-                for file in payload:
-                    func.store_file(file)
-    else:
-        if  query.startswith('."') or query.startswith(".'") or query.startswith('.`') or\
-            query.startswith('!"') or query.startswith("!'") or query.startswith('!`'):
-            func = stateful_conversation
-        else:
-            func = FunctionType(SHELL_CONTEXT)
-
+    query, kwargs, previous_kwargs = _extract_query_kwargs(query, previous_kwargs, kwargs)
+
+    if _is_new_conversation_query(query):
+        conversation, previous_kwargs, result, should_return = _process_new_conversation(
+            query, conversation_cls, symai_path, plugin, previous_kwargs, state
+        )
+        if should_return:
+            return result
+    elif _is_followup_conversation_query(query):
+        conversation, previous_kwargs, result, should_return = _process_followup_conversation(
+            query, conversation, conversation_cls, symai_path, plugin, previous_kwargs, state
+        )
+        if should_return:
+            return result
+    func, query = _select_function_for_query(query, conversation, state)
     with Loader(desc="Inference ...", end=""):
+        query_to_execute = query
+        if res is not None:
+            query_to_execute = f"[Context]\n{res}\n\n[Query]\n{query}"
+        msg = func(query_to_execute, *args, **kwargs)
         if res is not None:
-            query = f"[Context]\n{res}\n\n[Query]\n{query}"
-        msg = func(query, *args, **kwargs)
+            query = query_to_execute
 
-    if stateful_conversation is not None and (
-        query.startswith('."') or query.startswith(".'") or query.startswith('.`') or
-        query.startswith('!"') or query.startswith("!'") or query.startswith('!`')
-    ):
-        ConversationType.save_conversation_state(stateful_conversation, symai_path)
+    if _should_save_conversation(conversation, query):
+        conversation_cls.save_conversation_state(conversation, symai_path)
 
+    state.stateful_conversation = conversation
+    state.previous_kwargs = previous_kwargs
     return msg
 
-def retrieval_augmented_indexing(query: str, index_name = None, *args, **kwargs):
-    global stateful_conversation
+def retrieval_augmented_indexing(query: str, index_name = None, *_args, **_kwargs):
+    state = _shell_state
     sep = os.path.sep
     path = query
+    home_path = HOME_PATH
 
     # check if path contains overwrite flag
     overwrite = False
@@ -468,16 +540,17 @@ def retrieval_augmented_indexing(query: str, index_name = None, *args, **kwargs)
         # check if path contains git flag
         if path.startswith('git@'):
             overwrite = True
-            repo_path = os.path.join(home_path, 'temp')
-            cloner = RepositoryCloner(repo_path=repo_path)
-            url = path[4:]
-            if 'http' not in url:
-                url = 'https://' + url
-            url = url.replace('.com:', '.com/')
-            # if ends with '.git' then remove it
-            if url.endswith('.git'):
-                url = url[:-4]
-            path = cloner(url)
+            repo_path = home_path / 'temp'
+            with Loader(desc="Cloning repo ...", end=""):
+                cloner = RepositoryCloner(repo_path=str(repo_path))
+                url = path[4:]
+                if 'http' not in url:
+                    url = 'https://' + url
+                url = url.replace('.com:', '.com/')
+                # if ends with '.git' then remove it
+                if url.endswith('.git'):
+                    url = url[:-4]
+                path = cloner(url)
 
         # merge files
         merger = FileMerger()
@@ -491,36 +564,35 @@ def retrieval_augmented_indexing(query: str, index_name = None, *args, **kwargs)
 
         index_name = path.split(sep)[-1] if index_name is None else index_name
         index_name = Indexer.replace_special_chars(index_name)
-        print(f'Indexing {index_name} ...')
+        UserMessage(f'Indexing {index_name} ...', style="extensity")
 
         # creates index if not exists
         DocumentRetriever(index_name=index_name, file=file, overwrite=overwrite)
 
-    home_path = HOME_PATH
-    symai_path = os.path.join(home_path, '.conversation_state')
-    os.makedirs(os.path.dirname(symai_path), exist_ok=True)
-    stateful_conversation = RetrievalConversationType(auto_print=False, index_name=index_name)
+    symai_path = home_path / '.conversation_state'
+    symai_path.parent.mkdir(parents=True, exist_ok=True)
+    stateful_conversation = state.retrieval_conversation_type(auto_print=False, index_name=index_name)
+    state.stateful_conversation = stateful_conversation
     Conversation.save_conversation_state(stateful_conversation, symai_path)
     if use_index_name:
         message = 'New session '
     else:
         message = f'Repository {url} cloned and ' if query.startswith('git@') or query.startswith('git:') else f'Directory {path} '
-    msg = f'{message}successfully indexed: {index_name}'
-    return msg
+    return f'{message}successfully indexed: {index_name}'
 
-def search_engine(query: str, res=None, *args, **kwargs):
+def search_engine(query: str, res=None, *_args, **_kwargs):
     search = Interface('serpapi')
     with Loader(desc="Searching ...", end=""):
         search_query = Symbol(query).extract('search engine optimized query')
         res = search(search_query)
     with Loader(desc="Inference ...", end=""):
-        func = FunctionType(query)
+        func = _shell_state.function_type(query)
         msg = func(res, payload=res)
         # write a temp dump file with the query and results
         home_path = HOME_PATH
-        symai_path = os.path.join(home_path, '.search_dump')
-        os.makedirs(os.path.dirname(symai_path), exist_ok=True)
-        with open(symai_path, 'w') as f:
+        symai_path = home_path / '.search_dump'
+        symai_path.parent.mkdir(parents=True, exist_ok=True)
+        with symai_path.open('w') as f:
             f.write(f'[SEARCH_QUERY]:\n{search_query}\n[RESULTS]\n{res}\n[MESSAGE]\n{msg}')
     return msg
 
@@ -528,12 +600,12 @@ def set_default_module(cmd: str):
     if cmd.startswith('set-plugin'):
         module = cmd.split('set-plugin')[-1].strip()
         SYMSH_CONFIG['plugin_prefix'] = module
-        with open(config_path, 'w') as f:
+        with config_path.open('w') as f:
             json.dump(SYMSH_CONFIG, f, indent=4)
         msg = f"Default plugin set to '{module}'"
     elif cmd == 'unset-plugin':
         SYMSH_CONFIG['plugin_prefix'] = None
-        with open(config_path, 'w') as f:
+        with config_path.open('w') as f:
             json.dump(SYMSH_CONFIG, f, indent=4)
         msg = "Default plugin unset"
     elif cmd == 'get-plugin':
@@ -543,35 +615,33 @@ def set_default_module(cmd: str):
         console.print(msg)
 
 def handle_error(cmd, res, message, auto_query_on_error):
-    msg = Symbol(cmd) | f'\n{str(res)}'
+    msg = Symbol(cmd) | f'\n{res!s}'
     if 'command not found' in str(res) or 'not recognized as an internal or external command' in str(res):
         return res.stderr.decode('utf-8')
-    else:
-        stderr = res.stderr
-        if stderr and auto_query_on_error:
-            rsp = stderr.decode('utf-8')
-            print(rsp)
-            msg = msg | f"\n{rsp}"
-            if 'usage:' in rsp:
-                try:
-                    cmd = cmd.split('usage: ')[-1].split(' ')[0]
-                    # get man page result for command
-                    res = subprocess.run('man -P cat %s' % cmd,
-                                            shell=True,
-                                            stdout=subprocess.PIPE)
-                    stdout = res.stdout
-                    if stdout:
-                        rsp = stdout.decode('utf-8')[:500]
-                        msg = msg | f"\n{rsp}"
-                except Exception:
-                    pass
-
-            return query_language_model(msg)
-        else:
-            stdout = res.stdout
-            if stdout:
-                message = stderr.decode('utf-8')
-            return message
+    stderr = res.stderr
+    if stderr and auto_query_on_error:
+        rsp = stderr.decode('utf-8')
+        UserMessage(rsp, style="alert")
+        msg = msg | f"\n{rsp}"
+        if 'usage:' in rsp:
+            try:
+                cmd = cmd.split('usage: ')[-1].split(' ')[0]
+                # get man page result for command
+                res = subprocess.run(f'man -P cat {cmd}',
+                                        check=False, shell=True,
+                                        stdout=subprocess.PIPE)
+                stdout = res.stdout
+                if stdout:
+                    rsp = stdout.decode('utf-8')[:500]
+                    msg = msg | f"\n{rsp}"
+            except Exception:
+                pass
+
+        return query_language_model(msg)
+    stdout = res.stdout
+    if stdout:
+        message = stderr.decode('utf-8')
+    return message
 
 # run shell command
 def run_shell_command(cmd: str, prev=None, auto_query_on_error: bool=False, stdout=None, stderr=None):
@@ -581,14 +651,14 @@ def run_shell_command(cmd: str, prev=None, auto_query_on_error: bool=False, stdo
     conda_env = get_exec_prefix()
     # copy default_env
     new_env = default_env.copy()
-    if exec_prefix != 'default':
+    if _shell_state.exec_prefix != 'default':
         # remove current env from PATH
         new_env["PATH"] = new_env["PATH"].replace(sys.exec_prefix, conda_env)
     # Execute the command
     try:
         stdout = subprocess.PIPE if auto_query_on_error else stdout
         stderr = subprocess.PIPE if auto_query_on_error else stderr
-        res = subprocess.run(cmd, shell=True, stdout=stdout, stderr=stderr, env=new_env)
+        res = subprocess.run(cmd, check=False, shell=True, stdout=stdout, stderr=stderr, env=new_env)
         if res and stdout and res.stdout:
             message = res.stdout.decode('utf-8')
         elif res and stderr and res.stderr:
@@ -602,8 +672,7 @@ def run_shell_command(cmd: str, prev=None, auto_query_on_error: bool=False, stdo
     if res.returncode == 0:
         return message
     # If command not found, then try to query language model
-    else:
-        return handle_error(cmd, res, message, auto_query_on_error)
+    return handle_error(cmd, res, message, auto_query_on_error)
 
 def is_llm_request(cmd: str):
     return cmd.startswith('"') or cmd.startswith('."') or cmd.startswith('!"') or cmd.startswith('?"') or\
@@ -655,185 +724,238 @@ def map_nt_cmd(cmd: str, map_nt_cmd_enabled: bool = True):
             original_cmd = cmd
             cmd = re.sub(linux_cmd, windows_cmd, cmd)
             if cmd != original_cmd:
-                print(f'symsh >> command "{original_cmd}" mapped to "{cmd}"\n')
+                UserMessage(f'symsh >> command "{original_cmd}" mapped to "{cmd}"\n', style="extensity")
 
     return cmd
 
-def process_command(cmd: str, res=None, auto_query_on_error: bool=False):
-    global exec_prefix, previous_prefix
 
-    # map commands to windows if needed
-    cmd = map_nt_cmd(cmd)
+def _handle_plugin_commands(cmd: str):
     if cmd.startswith('set-plugin') or cmd == 'unset-plugin' or cmd == 'get-plugin':
         return set_default_module(cmd)
+    return None
 
-    sep = os.path.sep
-    # check for '&&' to also preserve pipes '|' in normal shell commands
-    if '" && ' in cmd or "' && " in cmd or '` && ' in cmd:
-        if is_llm_request(cmd):
-            # Process each command (the ones involving the LLM) separately
-            cmds = cmd.split(' && ')
-            if not is_llm_request(cmds[0]):
-                return ValueError('The first command must be a LLM request.')
-            # Process the first command as an LLM request
-            res = query_language_model(cmds[0], res=res)
-            rest = ' && '.join(cmds[1:])
-            if '$1' in cmds[1]:
-                res  = str(res).replace('\n', r'\\n')
-                rest = rest.replace('$1', '"%s"' % res)
-                res  = None
-            cmd = rest
-        # If it's a normal shell command with pipes or &&, pass it whole
-        res = run_shell_command(cmd, prev=res, auto_query_on_error=auto_query_on_error)
-        return res
 
+def _handle_chained_llm_commands(cmd: str, res, auto_query_on_error: bool):
+    if '" && ' not in cmd and "' && " not in cmd and '` && ' not in cmd:
+        return None
+    if not is_llm_request(cmd):
+        return run_shell_command(cmd, prev=res, auto_query_on_error=auto_query_on_error)
+    cmds = cmd.split(' && ')
+    if not is_llm_request(cmds[0]):
+        return ValueError('The first command must be a LLM request.')
+    first_res = query_language_model(cmds[0], res=res)
+    rest = ' && '.join(cmds[1:])
+    if len(cmds) > 1 and '$1' in cmds[1]:
+        first_res_str = str(first_res).replace('\n', r'\\n')
+        rest = rest.replace('$1', f'"{first_res_str}"')
+        first_res = None
+    return run_shell_command(rest, prev=first_res, auto_query_on_error=auto_query_on_error)
+
+
+def _handle_llm_or_search(cmd: str, res):
     if cmd.startswith('?"') or cmd.startswith("?'") or cmd.startswith('?`'):
-        cmd = cmd[1:]
-        return search_engine(cmd, res=res)
-
-    elif  is_llm_request(cmd) or '...' in cmd:
+        query = cmd[1:]
+        return search_engine(query, res=res)
+    if is_llm_request(cmd) or '...' in cmd:
         return query_language_model(cmd, res=res)
+    return None
+
+
+def _handle_retrieval_commands(cmd: str):
+    if cmd.startswith('*'):
+        return retrieval_augmented_indexing(cmd[1:])
+    return None
+
+
+def _handle_man_command(cmd: str):
+    if cmd.startswith('man symsh'):
+        pkg_path = Path(__file__).resolve().parent
+        symsh_path = pkg_path / 'symsh.md'
+        with symsh_path.open(encoding="utf8") as file_ptr:
+            return file_ptr.read()
+    return None
+
 
-    elif cmd.startswith('*'):
-        cmd = cmd[1:]
-        return retrieval_augmented_indexing(cmd)
-
-    elif cmd.startswith('man symsh'):
-        # read symsh.md file and print it
-        # get symsh path
-        pkg_path = os.path.dirname(os.path.abspath(__file__))
-        symsh_path = os.path.join(pkg_path, 'symsh.md')
-        with open(symsh_path, 'r', encoding="utf8") as f:
-            return f.read()
-
-    elif cmd.startswith('conda activate'):
-        # check conda execution prefix and verify if environment exists
-        env = sys.exec_prefix
-        path_ = sep.join(env.split(sep)[:-1])
-        env_base = os.path.join(sep, path_)
+def _handle_conda_commands(cmd: str, state, res, auto_query_on_error: bool):
+    if cmd.startswith('conda activate'):
+        env = Path(sys.exec_prefix)
+        env_base = env.parent
         req_env = cmd.split(' ')[2]
-        # check if environment exists
-        env_path = os.path.join(env_base, req_env)
-        if not os.path.exists(env_path):
+        env_path = env_base / req_env
+        if not env_path.exists():
             return f'Environment {req_env} does not exist!'
-        previous_prefix = exec_prefix
-        exec_prefix = os.path.join(env_base, req_env)
-        return exec_prefix
-
-    elif cmd.startswith('conda deactivate'):
-        if previous_prefix is not None:
-            exec_prefix = previous_prefix
-        if previous_prefix == 'default':
-            previous_prefix = None
+        state.previous_prefix = state.exec_prefix
+        state.exec_prefix = str(env_path)
+        return state.exec_prefix
+    if cmd.startswith('conda deactivate'):
+        prev_prefix = state.previous_prefix
+        if prev_prefix is not None:
+            state.exec_prefix = prev_prefix
+        if prev_prefix == 'default':
+            state.previous_prefix = None
         return get_exec_prefix()
+    if cmd.startswith('conda'):
+        env = Path(get_exec_prefix())
+        try:
+            env_base = env.parents[1]
+        except IndexError:
+            env_base = env.parent
+        cmd_rewritten = cmd.replace('conda', str(env_base / "condabin" / "conda"))
+        return run_shell_command(cmd_rewritten, prev=res, auto_query_on_error=auto_query_on_error)
+    return None
 
-    elif cmd.startswith('conda'):
-        env = get_exec_prefix()
-        env_base = os.path.join(sep, *env.split(sep)[:-2])
-        cmd = cmd.replace('conda', os.path.join(env_base, "condabin", "conda"))
-        return run_shell_command(cmd, prev=res, auto_query_on_error=auto_query_on_error)
 
-    elif cmd.startswith('cd'):
+def _handle_directory_navigation(cmd: str):
+    sep = os.path.sep
+    if cmd.startswith('cd'):
         try:
-            # replace ~ with home directory
-            cmd = FileReader.expand_user_path(cmd)
-            # Change directory
-            path = ' '.join(cmd.split(' ')[1:])
+            cmd_expanded = FileReader.expand_user_path(cmd)
+            path = ' '.join(cmd_expanded.split(' ')[1:])
             if path.endswith(sep):
                 path = path[:-1]
             return os.chdir(path)
-        except FileNotFoundError as e:
-            return e
-        except PermissionError as e:
-            return e
-
-    elif os.path.isdir(cmd):
+        except FileNotFoundError as err:
+            return err
+        except PermissionError as err:
+            return err
+    cmd_path = FileReader.expand_user_path(cmd)
+    if Path(cmd).is_dir():
         try:
-            # replace ~ with home directory
-            cmd = FileReader.expand_user_path(cmd)
-            # Change directory
-            os.chdir(cmd)
-        except FileNotFoundError as e:
-            return e
-        except PermissionError as e:
-            return e
-
-    elif cmd.startswith('ll'):
-
-        if os.name == 'nt':
-            cmd = cmd.replace('ll', 'dir')
-            return run_shell_command(cmd, prev=res)
-        else:
-            cmd = cmd.replace('ll', 'ls -la')
-            return run_shell_command(cmd, prev=res)
+            os.chdir(cmd_path)
+        except FileNotFoundError as err:
+            return err
+        except PermissionError as err:
+            return err
+    return None
 
-    else:
-        return run_shell_command(cmd, prev=res, auto_query_on_error=auto_query_on_error)
+
+def _handle_ll_alias(cmd: str, res):
+    if not cmd.startswith('ll'):
+        return None
+    if os.name == 'nt':
+        rewritten = cmd.replace('ll', 'dir')
+        return run_shell_command(rewritten, prev=res)
+    rewritten = cmd.replace('ll', 'ls -la')
+    return run_shell_command(rewritten, prev=res)
+
+
+def process_command(cmd: str, res=None, auto_query_on_error: bool=False):
+    state = _shell_state
+
+    # map commands to windows if needed
+    cmd = map_nt_cmd(cmd)
+    plugin_result = _handle_plugin_commands(cmd)
+    if plugin_result is not None:
+        return plugin_result
+
+    chained_result = _handle_chained_llm_commands(cmd, res, auto_query_on_error)
+    if chained_result is not None:
+        return chained_result
+
+    llm_or_search = _handle_llm_or_search(cmd, res)
+    if llm_or_search is not None:
+        return llm_or_search
+
+    retrieval_result = _handle_retrieval_commands(cmd)
+    if retrieval_result is not None:
+        return retrieval_result
+
+    man_result = _handle_man_command(cmd)
+    if man_result is not None:
+        return man_result
+
+    conda_result = _handle_conda_commands(cmd, state, res, auto_query_on_error)
+    if conda_result is not None:
+        return conda_result
+
+    directory_result = _handle_directory_navigation(cmd)
+    if directory_result is not None:
+        return directory_result
+
+    ll_result = _handle_ll_alias(cmd, res, auto_query_on_error)
+    if ll_result is not None:
+        return ll_result
+
+    return run_shell_command(cmd, prev=res, auto_query_on_error=auto_query_on_error)
 
 def save_conversation():
     home_path = HOME_PATH
-    symai_path = os.path.join(home_path, '.conversation_state')
-    Conversation.save_conversation_state(stateful_conversation, symai_path)
+    symai_path = home_path / '.conversation_state'
+    Conversation.save_conversation_state(_shell_state.stateful_conversation, symai_path)
+
+
+def _is_exit_command(cmd: str) -> bool:
+    return cmd in ['quit', 'exit', 'q']
+
+
+def _format_working_directory():
+    sep = os.path.sep
+    cur_working_dir = Path.cwd()
+    cur_working_dir_str = str(cur_working_dir)
+    if cur_working_dir_str.startswith(sep):
+        cur_working_dir_str = FileReader.expand_user_path(cur_working_dir_str)
+    paths = cur_working_dir_str.split(sep)
+    prev_paths = sep.join(paths[:-1])
+    last_path = paths[-1]
+    if len(paths) > 1:
+        return f'{prev_paths}{sep}<b>{last_path}</b>'
+    return f'<b>{last_path}</b>'
+
+
+def _build_prompt(git_branch, conda_env, cur_working_dir_str):
+    if git_branch:
+        return HTML(
+            f"<ansiblue>{cur_working_dir_str}</ansiblue><ansiwhite> on git:[</ansiwhite>"
+            f"<ansigreen>{git_branch}</ansigreen><ansiwhite>]</ansiwhite> <ansiwhite>conda:[</ansiwhite>"
+            f"<ansimagenta>{conda_env}</ansimagenta><ansiwhite>]</ansiwhite> <ansicyan><b>symsh:</b> ></ansicyan> "
+        )
+    return HTML(
+        f"<ansiblue>{cur_working_dir_str}</ansiblue> <ansiwhite>conda:[</ansiwhite>"
+        f"<ansimagenta>{conda_env}</ansimagenta><ansiwhite>]</ansiwhite> <ansicyan><b>symsh:</b> ></ansicyan> "
+    )
+
+
+def _handle_exit(state):
+    if state.stateful_conversation is not None:
+        save_conversation()
+    if not state.use_styles:
+        UserMessage('Goodbye!', style="extensity")
+    else:
+        func = _shell_state.function_type('Give short goodbye')
+        UserMessage(func('bye'), style="extensity")
+    os._exit(0)
+
 
 # Function to listen for user input and execute commands
 def listen(session: PromptSession, word_comp: WordCompleter, auto_query_on_error: bool=False, verbose: bool=False):
+    state = _shell_state
     with patch_stdout():
         while True:
             try:
                 git_branch = get_git_branch()
                 conda_env = get_conda_env()
-                # get directory from the shell
-                cur_working_dir = os.getcwd()
-                sep = os.path.sep
-                if cur_working_dir.startswith(sep):
-                    cur_working_dir = FileReader.expand_user_path(cur_working_dir)
-                paths = cur_working_dir.split(sep)
-                prev_paths = sep.join(paths[:-1])
-                last_path = paths[-1]
-
-                # Format the prompt
-                if len(paths) > 1:
-                    cur_working_dir = f'{prev_paths}{sep}<b>{last_path}</b>'
-                else:
-                    cur_working_dir = f'<b>{last_path}</b>'
-
-                if git_branch:
-                    prompt = HTML(f"<ansiblue>{cur_working_dir}</ansiblue><ansiwhite> on git:[</ansiwhite><ansigreen>{git_branch}</ansigreen><ansiwhite>]</ansiwhite> <ansiwhite>conda:[</ansiwhite><ansimagenta>{conda_env}</ansimagenta><ansiwhite>]</ansiwhite> <ansicyan><b>symsh:</b> ❯</ansicyan> ")
-                else:
-                    prompt = HTML(f"<ansiblue>{cur_working_dir}</ansiblue> <ansiwhite>conda:[</ansiwhite><ansimagenta>{conda_env}</ansimagenta><ansiwhite>]</ansiwhite> <ansicyan><b>symsh:</b> ❯</ansicyan> ")
-
-                # Read user input
+                cur_working_dir_str = _format_working_directory()
+                prompt = _build_prompt(git_branch, conda_env, cur_working_dir_str)
                 cmd = session.prompt(prompt)
                 if cmd.strip() == '':
                     continue
 
-                if cmd == 'quit' or cmd == 'exit' or cmd == 'q':
-                    if stateful_conversation is not None:
-                        save_conversation()
-                    if not use_styles:
-                        print('Goodbye!')
-                    else:
-                        func = FunctionType('Give short goodbye')
-                        print(func('bye'))
-                    os._exit(0)
-                else:
-                    msg = process_command(cmd, auto_query_on_error=auto_query_on_error)
-                    if msg is not None:
-                        with ConsoleStyle('code') as console:
-                            console.print(msg)
+                if _is_exit_command(cmd):
+                    _handle_exit(state)
+                msg = process_command(cmd, auto_query_on_error=auto_query_on_error)
+                if msg is not None:
+                    with ConsoleStyle('code') as console:
+                        console.print(msg)
 
                 # Append the command to the word completer list
                 word_comp.words.append(cmd)
 
             except KeyboardInterrupt:
-                print()
-                pass
-
+                UserMessage('', style="alert")
             except Exception as e:
-                print(e)
+                UserMessage(str(e), style="alert")
                 if verbose:
                     traceback.print_exc()
-                pass
 
 def create_session(history, merged_completer):
     colors = SYMSH_CONFIG['colors']
@@ -842,14 +964,12 @@ def create_session(history, merged_completer):
     style = Style.from_dict(colors)
 
     # Session for the auto-completion
-    session = PromptSession(history=history,
-                            completer=merged_completer,
-                            complete_style=CompleteStyle.MULTI_COLUMN,
-                            reserve_space_for_menu=5,
-                            style=style,
-                            key_bindings=bindings)
-
-    return session
+    return PromptSession(history=history,
+                         completer=merged_completer,
+                         complete_style=CompleteStyle.MULTI_COLUMN,
+                         reserve_space_for_menu=5,
+                         style=style,
+                         key_bindings=bindings)
 
 def create_completer():
     # Load history
@@ -864,20 +984,24 @@ def create_completer():
     return history, word_comp, merged_completer
 
 def run(auto_query_on_error=False, conversation_style=None, verbose=False):
-    global FunctionType, ConversationType, RetrievalConversationType, use_styles
+    state = _shell_state
     if conversation_style is not None and conversation_style != '':
-        print('Loading style:', conversation_style)
+        UserMessage(f'Loading style: {conversation_style}', style="extensity")
         styles_ = Import.load_module_class(conversation_style)
-        FunctionType, ConversationType, RetrievalConversationType = styles_
-        use_styles = True
+        (
+            state.function_type,
+            state.conversation_type,
+            state.retrieval_conversation_type,
+        ) = styles_
+        state.use_styles = True
 
     if SYMSH_CONFIG['show-splash-screen']:
         show_intro_menu()
         # set show splash screen to false
         SYMSH_CONFIG['show-splash-screen'] = False
         # save config
-        _config_path =  HOME_PATH / 'symsh.config.json'
-        with open(_config_path, 'w') as f:
+        _config_path = HOME_PATH / 'symsh.config.json'
+        with _config_path.open('w') as f:
             json.dump(SYMSH_CONFIG, f, indent=4)
     if 'plugin_prefix' not in SYMSH_CONFIG:
         SYMSH_CONFIG['plugin_prefix'] = None