twd-m4sc0 1.5.4__py3-none-any.whl → 2.0.1__py3-none-any.whl

twd/crud.py

@@ -0,0 +1,104 @@
+import os
+import json
+import hashlib
+import time
+import logging
+from collections import OrderedDict
+
+log = logging.getLogger("log")
+error_log = logging.getLogger("error")
+
+
+def create_alias_id():
+    data = str(time.time()) + str(os.urandom(16))
+    return hashlib.sha256(data.encode()).hexdigest()[:12]
+
+
+def get_data_file(config):
+    return os.path.expanduser(config.get("data_file", "~/.twd/data"))
+
+
+def ensure_data_file_exists(config):
+    data_file = get_data_file(config)
+    if not os.path.exists(data_file):
+        try:
+            with open(data_file, "w") as f:
+                json.dump({}, f)
+            log.info(f"Created data file at {data_file}")
+        except OSError as e:
+            error_log.error(f"Error creating data file: {e}")
+
+
+def load_data(config):
+    data_file = get_data_file(config)
+    if not os.path.exists(data_file):
+        ensure_data_file_exists(config)
+    try:
+        with open(data_file, "r") as f:
+            data = json.load(f)
+            log.info(f"Loaded data from {data_file}")
+            return data
+    except json.JSONDecodeError as e:
+        error_log.error(f"Error reading data file: {e}")
+        return {}
+    except OSError as e:
+        error_log.error(f"Error reading data file: {e}")
+        return {}
+
+
+def save_data(config, data):
+    data_file = get_data_file(config)
+    try:
+        sorted_data = OrderedDict(
+            sorted(data.items(), key=lambda item: item[1]["alias"])
+        )
+        with open(data_file, "w") as f:
+            json.dump(sorted_data, f, indent=4)
+        log.info(f"Saved data to {data_file}")
+    except OSError as e:
+        error_log.error(f"Error writing to data file: {e}")
+
+
+def create_entry(config, data, path, alias=None):
+    alias_id = create_alias_id()
+    data[alias_id] = {
+        "path": path,
+        "alias": alias if alias else "no_alias",
+        "created_at": time.time(),
+    }
+    save_data(config, data)
+    log.info(f"Created new entry with alias_id '{alias_id}' and path '{path}'")
+    return alias_id
+
+
+def delete_entry(config, data, entry_id):
+    if entry_id in data:
+        del data[entry_id]
+        save_data(config, data)
+        log.info(f"Deleted entry with alias_id '{entry_id}'")
+    else:
+        error_log.error(f"Entry ID '{entry_id}' not found")
+        raise KeyError(f"Entry ID {entry_id} not found")
+
+
+def update_entry(config, data, entry_id, entry):
+    if entry_id in data:
+        data[entry_id] = entry
+        save_data(config, data)
+        log.info(f"Updated entry with alias_id '{entry_id}'")
+    else:
+        error_log.error(f"Entry ID '{entry_id}' not found")
+        raise KeyError(f"Entry ID {entry_id} not found")
+
+
+def delete_data_file(config):
+    data_file = get_data_file(config)
+    if os.path.exists(data_file):
+        try:
+            os.remove(data_file)
+            log.info(f"Deleted data file at {data_file}")
+        except OSError as e:
+            error_log.error(f"Error deleting data file: {e}")
+            raise
+    else:
+        error_log.error("No data file found to delete")

twd/logger.py

@@ -1,47 +1,47 @@
+import logging
 import os
-import time
+from logging.handlers import RotatingFileHandler
 
 
-def format_message(message, config):
-    """Format the log message according to the provided config."""
-    result = config.get("log_format", "[$T]: $M")
-    result = result.replace("$T", time.strftime("%Y-%m-%d %H:%M:%S"))
-    result = result.replace("$M", message)
-    return result
-
-
-def ensure_directory_exists(file_path):
-    """Ensure the directory for the given file path exists."""
-    directory = os.path.dirname(file_path)
-    if not os.path.exists(directory):
-        os.makedirs(directory, exist_ok=True)
-
-
-def write_log(message, config):
-    """Write log message to the log file specified in the config."""
+def setup_logger(config):
+    """Set up loggers based on the configuration provided."""
     log_file = os.path.expanduser(config.get("log_file"))
-    log_file = os.path.abspath(log_file)
-    ensure_directory_exists(log_file)  # Ensure the directory exists
-    with open(log_file, "a+") as f:
-        f.write(message + "\n")
-
-
-def write_error(message, config):
-    """Write error message to the error file specified in the config."""
     error_file = os.path.expanduser(config.get("error_file"))
-    error_file = os.path.abspath(error_file)
-    ensure_directory_exists(error_file)  # Ensure the directory exists
-    with open(error_file, "a+") as f:
-        f.write(message + "\n")
-
-
-def log(message, config):
-    """Log the message using the provided config."""
-    formatted_message = format_message(message, config)
-    write_log(formatted_message, config)
-
+    log_level = config.get("log_level", "INFO").upper()
+    max_bytes = config.get("log_max_bytes", 5 * 1024 * 1024)  # Default 5MB
+    backup_count = config.get("log_backup_count", 3)  # Default 3 backup files
+
+    os.makedirs(os.path.dirname(log_file), exist_ok=True)
+    os.makedirs(os.path.dirname(error_file), exist_ok=True)
+
+    # General log configuration
+    log_formatter = logging.Formatter(
+        config.get("log_format", "%(asctime)s - %(levelname)s - %(message)s")
+    )
+
+    # Avoid duplicate handlers
+    logger = logging.getLogger("log")
+    if not logger.hasHandlers():
+        logger.setLevel(log_level)
+        log_handler = RotatingFileHandler(
+            log_file, maxBytes=max_bytes, backupCount=backup_count
+        )
+        log_handler.setFormatter(log_formatter)
+        logger.addHandler(log_handler)
+
+    # Error log configuration
+    error_logger = logging.getLogger("error")
+    if not error_logger.hasHandlers():
+        error_logger.setLevel(logging.ERROR)
+        error_handler = RotatingFileHandler(
+            error_file, maxBytes=max_bytes, backupCount=backup_count
+        )
+        error_handler.setFormatter(log_formatter)
+        error_logger.addHandler(error_handler)
+
+    return logger, error_logger
+
+
+def initialize_logging(config):
+    setup_logger(config)
 
-def error(message, config):
-    """Log the error using the provided config."""
-    formatted_message = format_message(message, config)
-    write_error(formatted_message, config)

twd/screen.py

@@ -0,0 +1,201 @@
+import curses
+import time
+import os
+from . import crud
+import logging
+
+log = logging.getLogger("log")
+error_log = logging.getLogger("error")
+
+CONFIG = None
+DIRS = None
+filtered_DIRS = None
+search_query = ""
+original_DIRS = None
+
+
+def draw_hr(stdscr, y, mode=None):
+    _, max_cols = stdscr.getmaxyx()
+    mode = mode if mode is not None else curses.A_NORMAL
+    stdscr.addstr(y, 1, "─" * (max_cols - 2), mode)
+
+
+def filter_dirs_by_search(query):
+    global filtered_DIRS
+    filtered_DIRS = (
+        {k: v for k, v in DIRS.items() if query.lower() in v["alias"].lower()}
+        if query
+        else DIRS
+    )
+
+
+def display_select_screen(stdscr):
+    global search_query, filtered_DIRS, original_DIRS
+    selected_entry = 0
+    pre_selected_path = None
+    confirm_mode = False
+    action = None
+    search_mode = False
+    post_search_mode = False
+
+    running = True
+
+    while running:
+        max_items = len(filtered_DIRS)
+        stdscr.clear()
+
+        # Border setup
+        height, width = stdscr.getmaxyx()
+        stdscr.addstr(0, 0, "╭")
+        stdscr.addstr(0, 1, "─" * (width - 2))
+        stdscr.addstr(0, width - 1, "╮")
+        stdscr.addstr(height - 1, 0, "╰")
+        stdscr.addstr(height - 1, 1, "─" * (width - 2))
+        stdscr.addstr(height - 2, width - 1, "╯")
+        for i in range(1, height - 1):
+            stdscr.addstr(i, 0, "│")
+            stdscr.addstr(i, width - 1, "│")
+
+        inner_height = height - 2
+        inner_width = width - 2
+        stdscr.addstr(1, 1, f"Current directory: {os.getcwd()}")
+
+        draw_hr(stdscr, 2)
+
+        # Header
+        max_alias_len = max(
+            max(len(entry["alias"]) for entry in filtered_DIRS.values()), 5
+        )
+        max_path_len = max(
+            max(len(entry["path"]) for entry in filtered_DIRS.values()), 4
+        )
+        max_id_len = max(max(len(alias_id) for alias_id in filtered_DIRS.keys()), 2)
+
+        alias_col = max_alias_len + 2
+        id_col = max_id_len + 2
+        path_col = max_path_len
+
+        header_text = f"{'ALIAS'.ljust(alias_col)}{'ID'.ljust(id_col)}{'PATH'.ljust(path_col)}  CREATED AT"
+        stdscr.addstr(3, 1, header_text[:inner_width])
+
+        draw_hr(stdscr, 4)
+
+        # List entries
+        line_start = 5
+        for entry_id, entry in enumerate(filtered_DIRS.values()):
+            if line_start >= inner_height - 5:
+                break
+            alias = entry["alias"].ljust(max_alias_len)
+            path = entry["path"].ljust(max_path_len)
+            alias_id = list(filtered_DIRS.keys())[entry_id].ljust(max_id_len)
+            created_at = time.strftime(
+                "%Y-%m-%d %H:%M:%S", time.localtime(entry["created_at"])
+            )
+
+            line_text = f"{alias}  {alias_id}  {path}  {created_at}"
+            if entry_id == selected_entry:
+                stdscr.addstr(line_start, 1, line_text[:inner_width], curses.A_REVERSE)
+                pre_selected_path = entry["path"]
+            else:
+                stdscr.addstr(line_start, 1, line_text[:inner_width])
+
+            line_start += 1
+
+        # Controls
+        controls_y = height - 5
+        draw_hr(stdscr, controls_y, curses.A_DIM)
+        controls_text = (
+            "ctrls: enter=select"
+            if search_mode
+            else "ctrls: ↑/k=up  ↓/j=down  enter=select  d/backspace=delete  q=exit search  s=search"
+            if post_search_mode
+            else "ctrls: ↑/k=up  ↓/j=down  enter=select  d/backspace=delete  q=quit  s=search"
+        )
+        stdscr.addstr(controls_y + 1, 1, controls_text, curses.A_DIM)
+
+        # Action area
+        action_area_y = height - 3
+        draw_hr(stdscr, action_area_y)
+
+        if search_mode:
+            stdscr.addstr(action_area_y + 1, 1, f"Search: {search_query}")
+        elif confirm_mode and action == "delete":
+            entry = filtered_DIRS[list(filtered_DIRS.keys())[selected_entry]]
+            stdscr.addstr(
+                action_area_y + 1,
+                1,
+                f"Delete entry '{entry['alias']}' ({entry['path']})? [enter/q]",
+            )
+        elif pre_selected_path:
+            stdscr.addstr(
+                action_area_y + 1,
+                1,
+                f"Command: cd {os.path.abspath(os.path.expanduser(pre_selected_path))}",
+            )
+
+        stdscr.refresh()
+
+        # Handle key events
+        key = stdscr.getch()
+
+        if search_mode:
+            if key == ord("\n"):
+                search_mode = False
+                post_search_mode = True
+            elif key == curses.KEY_BACKSPACE or key == 127:
+                search_query = search_query[:-1]
+                filter_dirs_by_search(search_query)
+            else:
+                search_query += chr(key)
+                filter_dirs_by_search(search_query)
+        elif post_search_mode:
+            if key == ord("q") or key == 27:  # 'q' or 'esc'
+                filtered_DIRS = original_DIRS
+                post_search_mode = False
+            elif key == curses.KEY_UP or key == ord("k"):
+                selected_entry = max(0, selected_entry - 1)
+            elif key == curses.KEY_DOWN or key == ord("j"):
+                selected_entry = min(max_items - 1, selected_entry + 1)
+            elif key == ord("\n"):
+                selected_entry_id = list(filtered_DIRS.keys())[selected_entry]
+                return filtered_DIRS[selected_entry_id]
+        elif confirm_mode:
+            if key == ord("\n") and action == "delete":
+                selected_entry_id = list(filtered_DIRS.keys())[selected_entry]
+                data = crud.load_data(CONFIG)
+                try:
+                    crud.delete_entry(CONFIG, data, selected_entry_id)
+                except KeyError:
+                    error_log.error(f"Entry ID {selected_entry_id} not found")
+                del filtered_DIRS[selected_entry_id]
+                if selected_entry >= len(filtered_DIRS):
+                    selected_entry = max(len(filtered_DIRS) - 1, 0)
+                confirm_mode = False
+            else:
+                confirm_mode = False
+        else:
+            if key == curses.KEY_UP or key == ord("k"):
+                selected_entry = (selected_entry - 1) % max_items
+            elif key == curses.KEY_DOWN or key == ord("j"):
+                selected_entry = (selected_entry + 1) % max_items
+            elif key == ord("\n"):
+                selected_entry_id = list(filtered_DIRS.keys())[selected_entry]
+                return filtered_DIRS[selected_entry_id]
+            elif key == ord("q"):
+                return None
+            elif key == ord("d") or key == curses.KEY_BACKSPACE:
+                confirm_mode = True
+                action = "delete"
+            elif key == ord("s"):
+                search_mode = True
+                selected_entry = 0
+
+
+def display_select(config, dirs):
+    global CONFIG, DIRS, filtered_DIRS, search_query, original_DIRS
+    CONFIG = config
+    DIRS = dirs
+    filtered_DIRS = DIRS
+    original_DIRS = DIRS
+    search_query = ""
+    return curses.wrapper(display_select_screen)

twd/twd.py

@@ -1,11 +1,16 @@
 import os
 import argparse
 import json
-import hashlib
 import time
 import re
+import logging
 from importlib.metadata import version, PackageNotFoundError
-from .logger import log, error
+from .logger import initialize_logging
+from .screen import display_select
+from . import crud
+
+log = logging.getLogger("log")
+error_log = logging.getLogger("error")
 
 TWD_DIR = os.path.join(os.path.expanduser("~"), ".twd")
 CONFIG_FILE = os.path.join(TWD_DIR, "config")
@@ -15,19 +20,16 @@ DEFAULT_CONFIG = {
     "output_behaviour": 2,
     "log_file": os.path.expanduser("~/.twd/log"),
     "error_file": os.path.expanduser("~/.twd/error"),
-    "log_format": "[$T]: $M",
+    "log_format": "%(asctime)s - %(levelname)s - %(message)s",
+    "log_level": "INFO",
+    "log_max_bytes": 5 * 1024 * 1024,  # 5 MB log rotation
+    "log_backup_count": 3,
 }
 
-# os.makedirs(TWD_DIR, exist_ok=True)
-
-
-def create_alias_id():
-    data = str(time.time()) + str(os.urandom(16))
-    return hashlib.sha256(data.encode()).hexdigest()[:12]
-
 
 def load_config():
     if not os.path.exists(CONFIG_FILE):
+        os.makedirs(TWD_DIR, exist_ok=True)
         with open(CONFIG_FILE, "w") as file:
             json.dump(DEFAULT_CONFIG, file, indent=4)
         return DEFAULT_CONFIG
@@ -36,23 +38,18 @@ def load_config():
             try:
                 return json.load(file)
             except json.JSONDecodeError as e:
-                error(f"Error loading config: {e}", DEFAULT_CONFIG)
+                error_log.error(f"Error loading config: {e}")
                 return DEFAULT_CONFIG
 
 
 CONFIG = load_config()
+initialize_logging(CONFIG)
 
-TWD_FILE = os.path.expanduser(CONFIG.get("data_file", "~/.twd/data"))
-
+crud.ensure_data_file_exists(CONFIG)
 
-def ensure_data_file_exists():
-    if not os.path.exists(TWD_FILE):
-        try:
-            with open(TWD_FILE, "w") as f:
-                json.dump({}, f)
-        except OSError as e:
-            error(f"Error creating data file: {e}", CONFIG)
 
+def ensure_log_error_files():
+    """Ensure that log and error files exist based on configuration settings."""
     log_file = os.path.expanduser(CONFIG.get("log_file"))
     error_file = os.path.expanduser(CONFIG.get("error_file"))
 
@@ -61,31 +58,31 @@ def ensure_data_file_exists():
             with open(log_file, "w+") as f:
                 f.write("")
         except OSError as e:
-            error(f"Error creating log file: {e}", CONFIG)
+            error_log.error(f"Error creating log file: {e}")
 
     if not os.path.exists(error_file):
         try:
             with open(error_file, "w+") as f:
                 f.write("")
         except OSError as e:
-            error(f"Error creating error file: {e}", CONFIG)
+            error_log.error(f"Error creating error file: {e}")
 
 
-ensure_data_file_exists()
+ensure_log_error_files()
 
 
 def get_absolute_path(path):
     try:
         return os.path.abspath(path)
     except Exception as e:
-        error(f"Error getting absolute path for {path}: {e}", CONFIG)
+        error_log.error(f"Error getting absolute path for {path}: {e}")
         raise
 
 
 def validate_alias(alias):
     """Ensure the alias contains only valid characters."""
     if not re.match(r"^[\w-]+$", alias):
-        error(f"Invalid alias provided: {alias}", CONFIG)
+        error_log.error(f"Invalid alias provided: {alias}")
         raise ValueError(
             f"Invalid alias: '{alias}'. Aliases can only contain alphanumeric characters, dashes, and underscores."
         )
@@ -95,21 +92,20 @@ def validate_alias(alias):
 def output_handler(
     message=None, path=None, output=True, simple_output=False, message_type=0
 ):
-    log(f"Type: {message_type}, Msg: {message or path}", CONFIG)
-
-    if not output or CONFIG["output_behaviour"] == 0:
-        return
-
-    if not message and not path:
-        return
-
-    if message_type == 1:
-        print(f"1;{message}")
-    elif message_type == 0:
-        if simple_output and path:
-            print(f"0;{path}")
-        elif not simple_output and message:
-            print(f"0;{message}")
+    log.info(f"Type: {message_type}, Msg: {message or path}")
+
+    if CONFIG["output_behaviour"] == 1 or simple_output:
+        if path:
+            with open("/tmp/twd_path", "w") as f:
+                f.write(path)
+            if output:
+                print(path)
+    elif CONFIG["output_behaviour"] == 2:
+        if path:
+            with open("/tmp/twd_path", "w") as f:
+                f.write(path)
+        if output:
+            print(message)
 
 
 def save_directory(path=None, alias=None, output=True, simple_output=False):
@@ -121,26 +117,8 @@ def save_directory(path=None, alias=None, output=True, simple_output=False):
     if alias:
         alias = validate_alias(alias)
 
-    try:
-        with open(TWD_FILE, "r") as f:
-            data = json.load(f)
-    except json.JSONDecodeError as e:
-        error(f"Error reading TWD file: {e}", CONFIG)
-        data = {}
-
-    alias_id = create_alias_id()
-    data[alias_id] = {
-        "path": path,
-        "alias": alias if alias else alias_id,
-        "created_at": time.time(),
-    }
-
-    try:
-        with open(TWD_FILE, "w") as f:
-            json.dump(data, f, indent=4)
-    except OSError as e:
-        error(f"Error writing to TWD file: {e}", CONFIG)
-        raise
+    data = crud.load_data(CONFIG)
+    alias_id = crud.create_entry(CONFIG, data, path, alias)
 
     output_handler(
         f"Saved TWD to {path} with alias '{alias or alias_id}'",
@@ -151,47 +129,79 @@ def save_directory(path=None, alias=None, output=True, simple_output=False):
 
 
 def load_directory():
-    if not os.path.exists(TWD_FILE):
-        return None
-
-    try:
-        with open(TWD_FILE, "r") as f:
-            return json.load(f)
-    except json.JSONDecodeError as e:
-        error(f"Error loading TWD file: {e}", CONFIG)
-        return None
+    data = crud.load_data(CONFIG)
+    return data if data else None
 
 
-def go_to_directory(alias=None, output=True, simple_output=False):
+def show_main(alias=None, output=True, simple_output=False):
     dirs = load_directory()
-
-    if not dirs:
+    if dirs is None:
         output_handler("No TWD found", None, output, simple_output)
         return 1
     else:
-        for entry_id, entry in dirs.items():
-            if "alias" in entry and entry["alias"] and entry["alias"] == alias:
-                TWD = entry["path"]
-
+        if alias:
+            matched_dirs = []
+
+            for entry_id, entry in dirs.items():
+                if (
+                    "alias" in entry
+                    and entry["alias"]
+                    and entry["alias"].startswith(alias)
+                ):
+                    entry["id"] = entry_id
+                    matched_dirs.append(entry)
+                elif entry_id.startswith(alias):
+                    entry["id"] = entry_id
+                    matched_dirs.append(entry)
+
+            if len(matched_dirs) == 1:
+                TWD = matched_dirs[0]["path"]
                 if os.path.exists(TWD):
                     output_handler(
                         f"cd {TWD}", TWD, output, simple_output, message_type=1
                     )
                     return 0
                 else:
-                    error(f"Directory does not exist: {TWD}", CONFIG)
+                    error_log.error(f"Directory does not exist: {TWD}")
                     output_handler(
                         f"Directory does not exist: {TWD}", None, output, simple_output
                     )
                     return 1
-
-        output_handler("No TWD with alias found", None, output, simple_output)
-        return 1
+            elif len(matched_dirs) > 1:
+                output_handler(
+                    f"Multiple TWDs match for '{alias}':", None, output, simple_output
+                )
+                for match in matched_dirs:
+                    output_handler(
+                        f"{match['alias']}  {match['id']}  {match['path']}",
+                        None,
+                        output,
+                        simple_output,
+                    )
+                return 1
+            else:
+                output_handler("No TWD with alias found", None, output, simple_output)
+                return 1
+
+        selected_dir = display_select(CONFIG, dirs)
+        if selected_dir is None:
+            output_handler("No TWD selected", None, output, simple_output)
+            return 0
+        else:
+            TWD = selected_dir["path"]
+            if os.path.exists(TWD):
+                output_handler(f"cd {TWD}", TWD, output, simple_output, message_type=1)
+                return 0
+            else:
+                error_log.error(f"Directory does not exist: {TWD}")
+                output_handler(
+                    f"Directory does not exist: {TWD}", None, output, simple_output
+                )
+                return 1
 
 
 def show_directory(output=True, simple_output=False):
     dirs = load_directory()
-
     if not dirs:
         output_handler("No TWD set", None, output, simple_output)
         return
@@ -220,50 +230,41 @@ def show_directory(output=True, simple_output=False):
 
 
 def unset_directory(output=True, simple_output=False, force=False):
-    if not os.path.exists(TWD_FILE):
-        output_handler(f"No TWD file found", None, output, simple_output)
-    else:
-        if not force:
-            output_handler(
-                r"""If you want to execute deleting and therefore unsetting all set TWD's, please use "--force" or "-f" and run again.
-                           
+    if not force:
+        output_handler(
+            r"""If you want to execute deleting and therefore unsetting all set TWD's, please use "--force" or "-f" and run again.
 
 This feature is to prevent accidental execution.""",
-                None,
-                True,
-                False,
-            )
-            return
-        try:
-            os.remove(TWD_FILE)
-        except OSError as e:
-            error(f"Error deleting TWD file: {e}", CONFIG)
-            raise
-        output_handler(f"TWD File deleted and TWD unset", None, output, simple_output)
+            None,
+            True,
+            False,
+        )
+        return
+    try:
+        crud.delete_data_file(CONFIG)
+    except OSError as e:
+        error_log.error(f"Error deleting TWD file: {e}")
+        raise
+    output_handler("TWD File deleted and TWD unset", None, output, simple_output)
 
 
 def get_package_version():
     try:
         return version("twd_m4sc0")
     except PackageNotFoundError as e:
-        error(f"Package version not found: {e}", CONFIG)
+        error_log.error(f"Package version not found: {e}")
         return "Unknown version"
 
 
 def main():
-    global TWD_FILE
-
     parser = argparse.ArgumentParser(
         description="Temporarily save and navigate to working directories."
     )
 
-    # Positional arguments
     parser.add_argument("directory", nargs="?", help="Directory to save")
     parser.add_argument(
         "alias", nargs="?", help="Alias for the saved directory (optional)"
     )
-
-    # Optional Arguments/Flags
     parser.add_argument(
         "-s",
         "--save",
@@ -273,7 +274,7 @@ def main():
     parser.add_argument("-d", "--dir", nargs="?", help="Directory to save")
     parser.add_argument("-a", "--ali", nargs="?", help="Alias for the saved directory")
     parser.add_argument(
-        "-g", "--go", nargs="?", const=None, help="Go to the saved directory"
+        "-g", "--go", nargs="?", const=" ", help="Go to the saved directory"
     )
     parser.add_argument("-l", "--list", action="store_true", help="Show saved TWD")
     parser.add_argument(
@@ -283,66 +284,49 @@ def main():
         "-v",
         "--version",
         action="version",
-        version=f"TWD Version: {get_package_version()}",
-        help="Show the current version of TWD installed",
+        version=f"TWD Version: v{get_package_version()}",
     )
     parser.add_argument("-f", "--force", action="store_true", help="Force an action")
     parser.add_argument(
         "--shell", nargs="?", const="twd", help="Output shell function for integration"
     )
     parser.add_argument(
-        "--simple-output",
-        action="store_true",
-        help="Only print essential output (new directory, absolute path, etc.)",
+        "--simple-output", action="store_true", help="Only print essential output"
     )
     parser.add_argument(
         "--no-output",
         action="store_true",
         help="Prevents the console from sending output",
     )
-    args = parser.parse_args()
 
+    args = parser.parse_args()
     output = not args.no_output
     simple_output = args.simple_output
 
     if args.shell:
-        print(rf"""
-        function {args.shell}() {{
-            output=$(python3 -m twd "$@");
-            while IFS= read -r line; do
-                if [[ -z "$line" ]]; then
-                    continue;
-                fi;
-                type=$(echo "$line" | cut -d';' -f1);
-                message=$(echo "$line" | cut -d';' -f2-);
-                if [[ "$type" == "1" ]]; then
-                    eval "$message";
-                else
-                    echo "$message";
-                fi;
-            done <<< "$output";
-        }}
-        """)
+        print(rf"""function {args.shell}() {{
+            python3 -m twd "$@";
+            if [ -f /tmp/twd_path ]; then
+                cd "$(cat /tmp/twd_path)";
+                /bin/rm -f /tmp/twd_path;
+            fi;
+        }}""")
         return 0
 
     directory = args.directory or args.dir
     alias = args.alias or args.ali
 
     if args.save:
-        if not directory:
-            directory = args.directory or os.getcwd()
-
-        alias = args.alias or args.ali
-
         save_directory(directory, alias, output, simple_output)
     elif args.go:
-        alias = args.go
-        return go_to_directory(alias, output, simple_output)
+        show_main(alias, output, simple_output)
     elif args.list:
         show_directory(output, simple_output)
     elif args.unset:
-        force = args.force
-        unset_directory(output, simple_output, force)
+        unset_directory(output, simple_output, force=args.force)
     else:
-        parser.print_help()
-        return 1
+        show_main(None, output, simple_output)
+
+
+if __name__ == "__main__":
+    main()

{twd_m4sc0-1.5.4.dist-info → twd_m4sc0-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: twd_m4sc0
-Version: 1.5.4
+Version: 2.0.1
 Summary: A tool to temporarily save and go to a working directory
 Home-page: https://github.com/m4sc0/twd
 Author: m4sc0
@@ -16,6 +16,8 @@ License-File: LICENSE
 
 `twd-m4sc0` is a command-line tool that allows you to temporarily save a working directory and easily navigate back to it. It's designed for developers and users who frequently need to switch between directories in the terminal.
 
+> All Versions `< v1.5` are considered deprecated and should not be used anymore because of the `config` file that was introduced in that version. This file is incompatible with newer versions and might cause issues or break the program. 
+
 ## Features
 
 - Save the current or specified working directory.
@@ -23,6 +25,7 @@ License-File: LICENSE
 - List all saved directories with metadata.
 - Unset and delete saved directories.
 - Integrates with your shell for seamless directory management.
+- Some options can be configured using the `config` file. For more information please visit the [Config](CONFIG.md) documentation.
 
 ## Installation
 

twd_m4sc0-2.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_twd.py,sha256=XrxOo99oqida_7qZ48pA6BCazZekDmG5syw9NvjZWDU,484
+twd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+twd/__main__.py,sha256=gM_Py51pQFH3CXdDIuPzBW6eNlFH1UHeRAmgAPWQyik,61
+twd/crud.py,sha256=QTruLgK9aBorJ1VKpeBS-joeD1DZbK2JfQm9tl3v5Bc,3057
+twd/logger.py,sha256=WG-JBbkdizR2KMODGcxREj1N--CgY-PdIC_agyZ5PHU,1590
+twd/screen.py,sha256=vQFNtast5-P_XrdvbY7XyIx2MGoNR7TUoVHHkXUTbvc,7066
+twd/twd.py,sha256=m-wad_GY6plzaatBKatkd5vp4UTV_fjXdHJauzInPYQ,10488
+twd_m4sc0-2.0.1.dist-info/LICENSE,sha256=eQSDjcD_fvOwfjmrzxKJhtZsSI39seMawuvsgeD_dfw,1062
+twd_m4sc0-2.0.1.dist-info/METADATA,sha256=BhP5_39Pb76v64cvxgDrsbauBCB4MYO5tfQdigh5LJg,3528
+twd_m4sc0-2.0.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+twd_m4sc0-2.0.1.dist-info/entry_points.txt,sha256=QfYDHHjipkVN4oalpACFmIeYHb7GQCJY4SC12bTsiQQ,37
+twd_m4sc0-2.0.1.dist-info/top_level.txt,sha256=PXToru2Yr2Xh3F_F-pHXtuOQVp5x7KKCPFf94P_VI5U,10
+twd_m4sc0-2.0.1.dist-info/RECORD,,

{twd_m4sc0-1.5.4.dist-info → twd_m4sc0-2.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

twd_m4sc0-1.5.4.dist-info/RECORD

@@ -1,12 +0,0 @@
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_twd.py,sha256=XrxOo99oqida_7qZ48pA6BCazZekDmG5syw9NvjZWDU,484
-twd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-twd/__main__.py,sha256=gM_Py51pQFH3CXdDIuPzBW6eNlFH1UHeRAmgAPWQyik,61
-twd/logger.py,sha256=Pmhh4sOB-HyJAVBSwiESGRJElJoJ4Anhn-HVF8vxXzY,1595
-twd/twd.py,sha256=EUsAOweKNl3zV2QnITkEjdG6Nv6UQjaUu3w7RaR__nQ,10344
-twd_m4sc0-1.5.4.dist-info/LICENSE,sha256=eQSDjcD_fvOwfjmrzxKJhtZsSI39seMawuvsgeD_dfw,1062
-twd_m4sc0-1.5.4.dist-info/METADATA,sha256=Mg_V_ltMMGp2hBInKxtZf8bokIpNJUDS1wBKJgR_F7s,3157
-twd_m4sc0-1.5.4.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-twd_m4sc0-1.5.4.dist-info/entry_points.txt,sha256=QfYDHHjipkVN4oalpACFmIeYHb7GQCJY4SC12bTsiQQ,37
-twd_m4sc0-1.5.4.dist-info/top_level.txt,sha256=PXToru2Yr2Xh3F_F-pHXtuOQVp5x7KKCPFf94P_VI5U,10
-twd_m4sc0-1.5.4.dist-info/RECORD,,