slots-cli 0.1.0__py3-none-any.whl

slots/__init__.py

@@ -0,0 +1,3 @@
+from slots.slots import Slots
+
+__all__ = ["Slots"]

slots/__main__.py

@@ -0,0 +1,66 @@
+import argparse
+from slots.slots import Slots
+
+def main():
+    slots = Slots()
+
+    parser = argparse.ArgumentParser(description="Slots - Save slots for coding projects.")
+
+    subparsers = parser.add_subparsers(title="Commands", dest="command")
+
+    init_parser = subparsers.add_parser("init", help="Initialize slots")
+    init_parser.add_argument("--refresh", action="store_true", help="Update base to current repository state.")
+
+    save_parser = subparsers.add_parser("save", help="Save current repository.")
+    save_parser.add_argument("name")
+
+    reset_parser = subparsers.add_parser("reset", help="Destroys all slot-related files and folders.")
+
+    load_parser = subparsers.add_parser("load", help="Load a save slot.")
+    load_parser.add_argument("name")
+    load_parser.add_argument("--remove-files", action="store_true", help="Remove files that were deleted in the slot.")
+
+    delete_parser = subparsers.add_parser("delete", help="Delete a save slot.")
+    delete_parser.add_argument("name")
+
+    list_parser = subparsers.add_parser("list", help="List save slots.")
+
+    revert_parser = subparsers.add_parser("revert", help="Revert the last load.")
+
+    status_parser = subparsers.add_parser("status", help="View differences between current repository and base state.")
+    status_parser.add_argument("--latest", action="store_true", help="Compare current repository to the most recent save.")
+
+    args = parser.parse_args()
+
+    match args.command:
+        case "init":
+            slots.init(args)
+        
+        case "save":
+            slots.save(args)
+        
+        case "reset":
+            slots.reset()
+
+        case "load":
+            slots.load(args)
+        
+        case "list":
+            slots.list()
+
+        case "delete":
+            slots.delete(args)
+
+        case "revert":
+            slots.revert()
+        
+        case "status":
+            slots.status(args)
+
+        case _:
+            print("Command not found. Use --help for list of commands.")
+
+
+if __name__ == "__main__":
+    main()
+

slots/load.py

@@ -0,0 +1,214 @@
+import json
+import shutil
+from datetime import datetime, timezone
+
+from colorama import Fore
+
+from slots.save import save_current_directory
+from slots.utils import atomic_json, copy_to_destination, remove_file_path, safe_project_path, safe_storage_path
+
+def read_slot_layout(path):
+    with open(path, "r", encoding="utf-8") as file:
+        try:
+            layout = json.load(file)
+        except json.JSONDecodeError:
+            print(Fore.RED + f"Cannot load slot: {path.name} is malformed.")
+            return None
+
+    for key in ("added", "modified", "removed"):
+        if not isinstance(layout.get(key), list):
+            print(Fore.RED + f"Cannot load slot: layout.json missing '{key}' list.")
+            return None
+
+    return layout
+
+def create_load_backup(root, base_dir, backups_dir, slot_name, touched_paths):
+    backups_dir.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S-%f")
+
+    backup_name = f"pre-load-{slot_name}-{timestamp}"
+    if not save_current_directory(root, backup_name, base_dir, backups_dir):
+        return None
+
+    restore_path = backups_dir / backup_name / "restore.json"
+
+    atomic_json(restore_path, {"touched": sorted(set(touched_paths))})
+    
+
+    return backup_name
+
+def load_save(name, saves_dir, base_dir, backups_dir, root, removeFiles=False):
+    save_dir = saves_dir / name
+    layout_path = save_dir / "layout.json"
+
+    if not layout_path.exists() or not (base_dir / "layout.json").exists():
+        print(Fore.RED + f"Cannot load slot '{name}': layout.json missing.")
+        return False
+
+    layout = read_slot_layout(layout_path)
+    if layout is None:
+        return False
+
+    paths_to_copy = layout["added"] + layout["modified"]
+    paths_to_remove = layout["removed"] if removeFiles else []
+
+    try:
+        copy_operations = []
+        saved_files_dir = save_dir / "files"
+        for file_path in paths_to_copy:
+            destination = safe_project_path(root, file_path)
+            source = safe_storage_path(saved_files_dir, file_path)
+            copy_operations.append((source, destination))
+
+        remove_operations = [safe_project_path(root, file_path) for file_path in paths_to_remove]
+    except ValueError as error:
+        print(Fore.RED + str(error))
+        return False
+
+    for source, _ in copy_operations:
+        if not source.exists():
+            print(Fore.RED + f"Cannot load slot: saved file missing: {source}")
+            return False
+
+    for path in remove_operations:
+        if path.exists() and path.is_dir():
+            print(Fore.RED + f"Refusing to remove directory during load: {path}")
+            return False
+
+    try:
+        backup_name = create_load_backup(root, base_dir, backups_dir, name, paths_to_copy + paths_to_remove)
+    except (OSError, json.JSONDecodeError) as error:
+        print(Fore.RED + f"Cannot create pre-load backup: {error}")
+        return False
+
+    if backup_name is None:
+        return False
+
+    try:
+        for source, destination in copy_operations:
+            copy_to_destination(source, destination)
+
+        for path in sorted(remove_operations, key=lambda item: len(item.parts), reverse=True):
+            remove_file_path(path)
+
+    except (OSError, shutil.Error) as error:
+        print(Fore.RED + f"Load failed: {error}")
+        print(Fore.YELLOW + f"Run 'slots revert' to restore backup '{backup_name}'.")
+        return False
+
+    return True
+
+def find_latest_backup(backups_dir):
+    latest_backup = None
+    latest_time = None
+
+    for backup in backups_dir.iterdir():
+        info_path = backup / "info.json"
+
+        if not backup.is_dir() or not info_path.exists():
+            continue
+
+        with open(info_path, "r", encoding="utf-8") as file:
+            try:
+                info = json.load(file)
+            except json.JSONDecodeError:
+                continue
+
+        try:
+            saved_time = datetime.fromisoformat(info["time"])
+        except (KeyError, TypeError, ValueError):
+            continue
+
+        if latest_time is None or saved_time > latest_time:
+            latest_backup = backup
+            latest_time = saved_time
+
+    return latest_backup
+
+def read_restore_manifest(path):
+    if not path.exists():
+        print(Fore.RED + "Cannot revert: restore.json missing.")
+        return None
+
+    with open(path, "r", encoding="utf-8") as file:
+        try:
+            manifest = json.load(file)
+        except json.JSONDecodeError:
+            print(Fore.RED + "Cannot revert: restore.json is malformed.")
+            return None
+
+    if not isinstance(manifest.get("touched"), list):
+        print(Fore.RED + "Cannot revert: restore.json missing 'touched' list.")
+        return None
+
+    return manifest
+
+def revert_latest(root, base_dir, backups_dir):
+    backup = find_latest_backup(backups_dir)
+
+    if backup is None:
+        print(Fore.RED + "No load backup found.")
+        return False
+
+    layout = read_slot_layout(backup / "layout.json")
+    if layout is None:
+        return False
+
+    manifest = read_restore_manifest(backup / "restore.json")
+    if manifest is None:
+        return False
+
+    try:
+        with open(base_dir / "layout.json", "r", encoding="utf-8") as file:
+            base_layout = json.load(file)
+    except (OSError, json.JSONDecodeError) as error:
+        print(Fore.RED + f"Cannot revert: base layout unavailable: {error}")
+        return False
+
+    backup_paths = set(layout["added"] + layout["modified"])
+    removed_before_load = set(layout["removed"])
+
+    try:
+        copy_operations = []
+        remove_operations = []
+        backup_files_dir = backup / "files"
+        base_files_dir = base_dir / "files"
+
+        for file_path in manifest["touched"]:
+            destination = safe_project_path(root, file_path)
+
+            if file_path in backup_paths:
+                source = safe_storage_path(backup_files_dir, file_path)
+                copy_operations.append((source, destination))
+            elif file_path in removed_before_load or file_path not in base_layout:
+                remove_operations.append(destination)
+            else:
+                source = safe_storage_path(base_files_dir, file_path)
+                copy_operations.append((source, destination))
+
+    except ValueError as error:
+        print(Fore.RED + str(error))
+        return False
+
+    for source, _ in copy_operations:
+        if not source.exists():
+            print(Fore.RED + f"Cannot revert: backup file missing: {source}")
+            return False
+
+    for path in remove_operations:
+        if path.exists() and path.is_dir():
+            print(Fore.RED + f"Refusing to remove directory during revert: {path}")
+            return False
+
+    try:
+        for source, destination in copy_operations:
+            copy_to_destination(source, destination)
+
+        for path in sorted(remove_operations, key=lambda item: len(item.parts), reverse=True):
+            remove_file_path(path)
+
+    except OSError as error:
+        print(Fore.RED + f"Revert failed: {error}")
+        return False
+
+    return True

slots/save.py

@@ -0,0 +1,108 @@
+import json
+import shutil
+from datetime import datetime, timezone
+
+from colorama import Fore
+
+from slots.utils import (
+    copy_to_destination,
+    create_layout,
+    safe_project_path,
+    safe_storage_path,
+    should_ignore,
+    slots_dir_name,
+    atomic_json
+)
+
+def create_base(root):
+    base_dir = root / slots_dir_name / "base"
+    base_files_dir = base_dir / "files"
+
+    for item in root.iterdir():
+        if should_ignore(item, root) or item.is_symlink():
+            continue
+
+        destination = base_files_dir / item.name
+
+        if destination.exists():
+            continue
+
+        try:
+            copy_to_destination(item, destination)
+        except PermissionError:
+            print(Fore.RED + f"Skipped {item} - Currently in use or no permission.")
+
+def refresh_base(root):
+    base_dir = root / slots_dir_name / "base"
+    base_files_dir = base_dir / "files"
+
+    if base_dir.exists():
+        shutil.rmtree(base_dir)
+
+    base_files_dir.mkdir(parents=True, exist_ok=True)
+    create_base(root)
+
+    base_layout = create_layout(base_files_dir)
+
+    atomic_json(base_dir / "layout.json", base_layout)
+
+def save_current_directory(root, name, base_dir, saves_dir):
+    current_layout = create_layout(root)
+
+    with open(base_dir / "layout.json", "r", encoding="utf-8") as base_layout_file:
+        base_layout = json.load(base_layout_file)
+
+    try:
+        for file_path in base_layout:
+            safe_project_path(root, file_path)
+    except ValueError as error:
+        print(Fore.RED + f"Cannot save: {error}")
+        return False
+
+    base_paths = set(base_layout)
+    current_paths = set(current_layout)
+
+    added = current_paths - base_paths
+    removed = base_paths - current_paths
+    shared = base_paths & current_paths
+
+    modified_files = []
+
+    for file_path in shared:
+        if base_layout[file_path]["hash"] != current_layout[file_path]["hash"]:
+            modified_files.append(file_path)
+
+    current_save_dir = saves_dir / name
+    saved_files_dir = current_save_dir / "files"
+    current_save_dir.mkdir(parents=True, exist_ok=True)
+    saved_files_dir.mkdir(parents=True, exist_ok=True)
+
+    atomic_json(current_save_dir / "info.json", {
+            "name": name,
+            "time": datetime.now(timezone.utc).isoformat()
+        })
+    
+    atomic_json(current_save_dir / "layout.json", {
+            "added": sorted(added),
+            "removed": sorted(removed),
+            "modified": sorted(modified_files)
+        })
+
+    # TODO: switch to diff saving instead of saving entire files
+    for file_path in list(modified_files) + list(added):
+        try:
+            source = safe_project_path(root, file_path)
+            destination = safe_storage_path(saved_files_dir, file_path)
+        except ValueError as error:
+            print(Fore.RED + f"Cannot save: {error}")
+            return False
+
+        if not source.exists():
+            continue
+
+        try:
+            copy_to_destination(source, destination)
+        except PermissionError:
+            print(Fore.RED + f"Skipped {source} - Currently in use or no permission.")
+
+    return True

slots/slots.py

@@ -0,0 +1,311 @@
+from pathlib import Path
+import json
+import shutil
+from datetime import datetime, timezone
+
+from colorama import Fore, init
+
+from slots.load import load_save, revert_latest
+from slots.save import create_base, refresh_base, save_current_directory
+from slots.utils import (
+    create_layout,
+    ensure_folders,
+    pluralize,
+    remove_path,
+    slots_dir_name,
+    validate_slot_name,
+    atomic_json
+)
+
+init(autoreset=True)
+
+def list_difference(base_dir, root, saves_dir, latest):
+    current_layout = create_layout(root)
+
+    with open(base_dir / "layout.json", "r", encoding="utf-8") as file:
+        base_layout = json.load(file)
+
+    if latest:
+        latest_save = None
+        latest_time = None
+
+        for save in saves_dir.iterdir():
+            info_path = save / "info.json"
+
+            if not save.is_dir() or not info_path.exists():
+                continue
+
+            try:
+                with open(info_path, "r", encoding="utf-8") as file:
+                    info = json.load(file)
+                saved_time = datetime.fromisoformat(info["time"])
+            except (OSError, json.JSONDecodeError, KeyError, TypeError, ValueError):
+                continue
+
+            if latest_time is None or saved_time > latest_time:
+                latest_save = save
+                latest_time = saved_time
+
+        if latest_save is None:
+            print(Fore.RED + "Cannot show latest diff: no save slots found.")
+            return
+
+        with open(latest_save / "layout.json", "r", encoding="utf-8") as file:
+            save_layout = json.load(file)
+
+        saved_files_layout = create_layout(latest_save / "files")
+        source_layout = dict(base_layout)
+
+        for file_path in save_layout["removed"]:
+            source_layout.pop(file_path, None)
+
+        for file_path in save_layout["added"] + save_layout["modified"]:
+            if file_path in saved_files_layout:
+                source_layout[file_path] = saved_files_layout[file_path]
+
+        source_name = f"latest save '{latest_save.name}'"
+    else:
+        source_name = "base state"
+        source_layout = base_layout
+
+    source_paths = set(source_layout)
+    current_paths = set(current_layout)
+    added = sorted(current_paths - source_paths)
+    removed = sorted(source_paths - current_paths)
+    modified = sorted(
+        file_path
+        for file_path in source_paths & current_paths
+        if source_layout[file_path] != current_layout[file_path]
+    )
+    total = len(added) + len(modified) + len(removed)
+
+    print(Fore.CYAN + f"Difference from {source_name}")
+    print(Fore.WHITE + f"{total} changed: {len(added)} added, {len(modified)} modified, {len(removed)} removed")
+
+    if total == 0:
+        print(Fore.GREEN + "No differences found.")
+        return
+
+    if added:
+        print(Fore.GREEN + f"\nAdded ({len(added)})")
+        for path in added:
+            print(Fore.GREEN + f"  + {path}")
+
+    if modified:
+        print(Fore.YELLOW + f"\nModified ({len(modified)})")
+        for path in modified:
+            print(Fore.YELLOW + f"  ~ {path}")
+
+    if removed:
+        print(Fore.RED + f"\nRemoved ({len(removed)})")
+        for path in removed:
+            print(Fore.RED + f"  - {path}")
+
+def clear_saves(saves_dir):
+    for item in saves_dir.iterdir():
+        remove_path(item)
+
+def format_time_since(saved_time):
+    now = datetime.now(saved_time.tzinfo or timezone.utc)
+    seconds_since_save = max(0, round((now - saved_time).total_seconds()))
+
+    if seconds_since_save < 60:
+        return f"{pluralize(seconds_since_save, 'second')} ago"
+
+    minutes_since_save = round(seconds_since_save / 60)
+
+    if minutes_since_save < 60:
+        return f"{pluralize(minutes_since_save, 'minute')} ago"
+
+    hours = minutes_since_save // 60
+    minutes = minutes_since_save % 60
+
+    if minutes == 0:
+        return f"{pluralize(hours, 'hour')} ago"
+
+    return f"{pluralize(hours, 'hour')} {pluralize(minutes, 'minute')} ago"
+
+def format_saved_time(saved_time):
+    return saved_time.astimezone().strftime("%H:%M")
+
+def list_saves(saves_dir):
+    saves = []
+    for save in saves_dir.iterdir():
+        info_path = save / "info.json"
+
+        if not save.is_dir():
+            continue
+
+        if not info_path.exists():
+            print(Fore.YELLOW + f"Skipping save '{save.name}', missing info.json")
+            continue
+
+        with open(info_path, "r", encoding="utf-8") as file:
+            try:
+                info = json.load(file)
+            except json.JSONDecodeError:
+                print(Fore.YELLOW + f"Skipping save '{save.name}', malformed info.json")
+                continue
+
+        saved_time_value = info.get("time") or info.get("saved_at")
+
+        try:
+            saved_time = datetime.fromisoformat(saved_time_value)
+        except (TypeError, ValueError):
+            print(Fore.YELLOW + f"Skipping save '{save.name}', missing or invalid save time")
+            continue
+
+        saves.append({
+            "name": info.get("name", save.name),
+            "time": saved_time
+        })
+
+    saves.sort(
+        key=lambda save: save["time"],
+        reverse=True
+    )
+
+    print(Fore.GREEN + "Save slots: ")
+    for save in saves:
+        time_since_save = format_time_since(save["time"])
+        saved_at = format_saved_time(save["time"])
+        print(f"{save['name']} - {time_since_save} (Saved at {saved_at})")
+
+class Slots:
+    def __init__(self):
+        self.root = Path.cwd()
+        self.slots_dir = self.root / slots_dir_name
+        self.base_dir = self.slots_dir / "base"
+        self.saves_dir = self.slots_dir / "saves"
+        self.backups_dir = self.slots_dir / "backups"
+
+    def init(self, args):
+        self.root = Path.cwd()
+
+        if args.refresh:
+            print(Fore.YELLOW + "Are you sure you want to refresh the base repository state? (This will clear all save slots.)")
+            confirmation = input("[y/n]: ")
+
+            if confirmation.lower().strip() == "y":
+                if not Path.exists(self.slots_dir):
+                    print(Fore.RED + "Cannot refresh base state: Slots not initialized.")
+                    return
+                refresh_base(self.root)
+                clear_saves(self.saves_dir)
+                print(Fore.GREEN + "Refreshed base repository to reflect current state.")
+            else:
+                print(Fore.WHITE + "Operation canceled.")
+            return
+
+        if Path.exists(self.root / slots_dir_name):
+            print(Fore.RED + "Slots already initialized.")
+            return
+
+        ensure_folders([self.slots_dir, self.base_dir / "files", self.saves_dir, self.backups_dir])
+        create_base(self.root)
+        base_layout = create_layout(self.base_dir / "files")
+
+        atomic_json(self.base_dir / "layout.json", base_layout)
+
+        print(Fore.GREEN + "Initialized Slots.")
+
+    def save(self, args):
+        if not Path.exists(self.root / slots_dir_name):
+            print(Fore.RED + "Cannot save: Slots not initialized.")
+            return
+
+        if Path.exists(self.saves_dir / args.name):
+            print(Fore.RED + f"Cannot save: Slot with the name '{args.name}' already exists.")
+            return
+
+        error = validate_slot_name(args.name)
+        if error:
+            print(Fore.RED + f"Invalid slot name: {error}")
+            return
+
+        saved = save_current_directory(self.root, args.name.strip(), self.base_dir, self.saves_dir)
+
+        if saved:
+            print(Fore.GREEN + f"Created save slot '{args.name}'.")
+
+    def load(self, args):
+        if not Path.exists(self.root / slots_dir_name):
+            print(Fore.RED + "Cannot load: Slots not initialized.")
+            return
+
+        error = validate_slot_name(args.name)
+        if error:
+            print(Fore.RED + f"Invalid slot name: {error}")
+            return
+
+        if not Path.exists(self.saves_dir / args.name):
+            print(Fore.RED + f"No slot with name '{args.name}' found.")
+            return
+
+        removeFiles = getattr(args, "remove_files", False)
+        loaded = load_save(args.name.strip(), self.saves_dir, self.base_dir, self.backups_dir, self.root, removeFiles)
+
+        if loaded:
+            print(Fore.GREEN + f"Loaded save slot '{args.name}'.")
+
+    def list(self):
+        if not Path.exists(self.root / slots_dir_name):
+            print(Fore.RED + "Cannot list: Slots not initialized.")
+            return
+
+        list_saves(self.saves_dir)
+
+    def delete(self, args):
+        if not Path.exists(self.root / slots_dir_name):
+            print(Fore.RED + "Cannot delete: Slots not initialized.")
+            return
+
+        error = validate_slot_name(args.name)
+        if error:
+            print(Fore.RED + f"Invalid slot name: {error}")
+            return
+
+        if not Path.exists(self.saves_dir / args.name):
+            print(Fore.RED + f"No slot with name '{args.name}' found.")
+            return
+
+        slot_path = self.saves_dir / args.name.strip()
+
+        remove_path(slot_path)
+        print(Fore.GREEN + f"Deleted slot '{args.name.strip()}'")
+
+    def reset(self):
+        print(Fore.YELLOW + "Are you sure you want to reset all slots configuration?")
+        confirmation = input("[y/n]: ")
+
+        if confirmation.lower().strip() != "y":
+            return
+
+        print(Fore.RED + "This action is irreversible. Please make sure this is what you want to do.")
+        confirmation = input("[y/n]: ")
+
+        if confirmation.lower().strip() != "y":
+            return
+
+        shutil.rmtree(self.slots_dir)
+        print(Fore.GREEN + "Cleared all slots data. Use 'slots init' to reinitialize slots.")
+
+    
+    def revert(self):
+        if not Path.exists(self.root / slots_dir_name):
+            print(Fore.RED + "Cannot revert: Slots not initialized.")
+            return
+        
+        reverted = revert_latest(self.root, self.base_dir, self.backups_dir)
+
+        if reverted:
+            print(Fore.GREEN + "Reverted last load.")
+
+    
+    def status(self, args=None):
+        if not Path.exists(self.root / slots_dir_name):
+            print(Fore.RED + "Cannot show status: Slots not initialized.")
+            return
+
+        latest = getattr(args, "latest", False)
+        list_difference(self.base_dir, self.root, self.saves_dir, latest)

slots/slots_mcp.py

@@ -0,0 +1,82 @@
+import io
+import os
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+
+from mcp.server.fastmcp import FastMCP
+
+from slots.slots import Slots
+
+mcp = FastMCP("Slots")
+
+
+def slots_cmd(project, command):
+    original_cwd = Path.cwd()
+    output = io.StringIO()
+
+    try:
+        os.chdir(Path(project).expanduser().resolve())
+        slots = Slots()
+
+        with redirect_stdout(output):
+            command(slots)
+        return output.getvalue().strip() or "Done."
+    finally:
+        os.chdir(original_cwd)
+
+
+@mcp.tool()
+def slots_init(project_path: str = ".") -> str:
+    """Initialize Slots in a project."""
+    return slots_cmd(
+        project_path,
+        lambda slots: slots.init(SimpleNamespace(refresh=False)),
+    )
+
+
+@mcp.tool()
+def slots_status(project_path: str = ".", latest: bool = False) -> str:
+    """Show differences in a Slots project."""
+    return slots_cmd(
+        project_path,
+        lambda slots: slots.status(SimpleNamespace(latest=latest)),
+    )
+
+
+@mcp.tool()
+def slots_list(project_path: str = ".") -> str:
+    """List save slots in a project."""
+    return slots_cmd(project_path, lambda slots: slots.list())
+
+
+@mcp.tool()
+def slots_save(project_path: str, name: str) -> str:
+    """Create a named save slot for a project."""
+    return slots_cmd(
+        project_path,
+        lambda slots: slots.save(SimpleNamespace(name=name)),
+    )
+
+
+@mcp.tool()
+def slots_load(project_path: str, name: str, remove_files: bool = False) -> str:
+    """Load a named save slot into a project."""
+    return slots_cmd(
+        project_path,
+        lambda slots: slots.load(SimpleNamespace(name=name, remove_files=remove_files)),
+    )
+
+
+@mcp.tool()
+def slots_revert(project_path: str = ".") -> str:
+    """Revert the most recent slot load."""
+    return slots_cmd(project_path, lambda slots: slots.revert())
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

slots/utils.py

@@ -0,0 +1,178 @@
+from pathlib import Path
+import hashlib
+import re
+import shutil
+import os
+import tempfile
+import json
+
+slots_dir_name = ".slots"
+IGNORE_LIST = [".slots", ".git", "node_modules", ".venv", "venv", "__pycache__"]
+
+WINDOWS_RESERVED_NAMES = {
+    "CON", "PRN", "AUX", "NUL",
+    "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
+    "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
+}
+
+def validate_slot_name(name):
+    if not name or not name.strip():
+        return "Slot name cannot be empty."
+
+    name = name.strip()
+
+    if name in {".", ".."}:
+        return "Slot name cannot be '.' or '..'."
+
+    if Path(name).is_absolute() or "/" in name or "\\" in name:
+        return "Slot name cannot be a path."
+
+    if name.upper() in WINDOWS_RESERVED_NAMES:
+        return f"'{name}' is a reserved system name."
+
+    if len(name) > 64:
+        return "Slot name must be 64 characters or fewer."
+
+    if not re.fullmatch(r"[A-Za-z0-9 _-]+", name):
+        return "Slot name can only contain letters, numbers, spaces, underscores, and hyphens."
+
+    return None
+
+def ensure_folders(dirs_paths):
+    for dir_path in dirs_paths:
+        dir_path.mkdir(parents=True, exist_ok=True)
+
+def should_ignore(item, root):
+    relative = item.relative_to(root)
+    return any(part in IGNORE_LIST for part in relative.parts)
+
+def hash_file(path):
+    sha = hashlib.sha256()
+
+    with open(path, "rb") as f:
+        while chunk := f.read(8192):
+            sha.update(chunk)
+
+    return sha.hexdigest()
+
+def create_layout(path):
+    layout = {}
+
+    for item in path.rglob("*"):
+        if should_ignore(item, path) or item.is_symlink():
+            continue
+
+        relative = item.relative_to(path)
+
+        layout[str(relative)] = {
+            "type": "dir" if item.is_dir() else "file",
+            "hash": hash_file(item) if item.is_file() else None
+        }
+
+    return layout
+
+def remove_path(path):
+    if not path.exists():
+        return
+
+    if path.is_dir():
+        shutil.rmtree(path)
+    else:
+        path.unlink()
+
+def remove_file_path(path):
+    if not path.exists():
+        return
+
+    if path.is_dir():
+        raise IsADirectoryError(f"Refusing to remove directory: {path}")
+
+    path.unlink()
+
+def safe_project_path(root, relative_path):
+    if not isinstance(relative_path, str):
+        raise ValueError(f"Unsafe path in slot metadata: {relative_path}")
+
+    path = Path(relative_path)
+
+    if not path.parts or path.is_absolute() or ".." in path.parts:
+        raise ValueError(f"Unsafe path in slot metadata: {relative_path}")
+
+    if path.parts and path.parts[0] in {".git", slots_dir_name}:
+        raise ValueError(f"Refusing to touch protected path: {relative_path}")
+
+    root = root.resolve()
+    destination = (root / path).resolve()
+
+    if destination != root and root not in destination.parents:
+        raise ValueError(f"Path escapes project root: {relative_path}")
+
+    return destination
+
+def safe_storage_path(root, relative_path):
+    if not isinstance(relative_path, str):
+        raise ValueError(f"Unsafe path in slot metadata: {relative_path}")
+
+    path = Path(relative_path)
+
+    if not path.parts or path.is_absolute() or ".." in path.parts:
+        raise ValueError(f"Unsafe path in slot metadata: {relative_path}")
+
+    root = root.resolve()
+    destination = (root / path).resolve()
+
+    if destination != root and root not in destination.parents:
+        raise ValueError(f"Path escapes slot storage: {relative_path}")
+
+    return destination
+
+def copy_to_destination(source, destination):
+    if source.is_symlink():
+        return
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+
+    if destination.is_symlink():
+        destination.unlink()
+
+    if source.is_dir():
+        if destination.exists() and not destination.is_dir():
+            destination.unlink()
+
+        destination.mkdir(parents=True, exist_ok=True)
+
+        for item in source.iterdir():
+            copy_to_destination(item, destination / item.name)
+
+        return
+
+    if destination.exists() and destination.is_dir():
+        shutil.rmtree(destination)
+
+    shutil.copy2(source, destination)
+
+def pluralize(value, unit):
+    if value == 1:
+        return f"{value} {unit}"
+
+    return f"{value} {unit}s"
+
+def atomic_json(path, data):
+    path = Path(path)
+    temp_path = None
+
+    try:
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", dir=path.parent, delete=False) as file:
+            temp_path = Path(file.name)
+
+            json.dump(data, file, indent=4, sort_keys=True)
+            file.write("\n")
+            file.flush()
+            os.fsync(file.fileno())
+
+        os.replace(temp_path, path)
+        
+    except OSError:
+        if temp_path is not None and temp_path.exists():
+            temp_path.unlink()
+        raise

slots_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: slots-cli
+Version: 0.1.0
+Summary: Save slots for coding projects.
+Home-page: https://slots.hohohocch.com
+Author: hohohocch
+Requires-Python: >=3.10
+Requires-Dist: colorama
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Provides-Extra: mcp
+Requires-Dist: mcp[cli]; extra == "mcp"
+Dynamic: author
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

slots_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+slots/__init__.py,sha256=-2AJDkE_B3X6ziPuj_rtw8E1ecPI4idjglRokppmG3A,51
+slots/__main__.py,sha256=aKWuyB9qq5GCT5YgBIUJ4zMXE9eWqO1HTfVZPkIzJss,2100
+slots/load.py,sha256=XVdNe7XWiB1qjkf3hKq7Fse5d5yUNs37RhSAMushw84,7085
+slots/save.py,sha256=YcbHTjfWbHxm2i4dIZCgb4UoCGn3QczJ5G6NUyM--r0,3116
+slots/slots.py,sha256=QCx2Axsl_rUpKwEXQGCu4Syj2cRiiw_F28ILIB9r3QQ,10261
+slots/slots_mcp.py,sha256=wr1M7Zi6qw8M98gQVpXBxjbfPO8uLFVzrpYtrKPGcqU,1944
+slots/utils.py,sha256=0hpkbD_vDxtLQqW65AaTF3LFHwEQEnWEp67NOSdJg7E,4817
+slots_cli-0.1.0.dist-info/METADATA,sha256=2B0gthwdY0GQvPEfUyAVtBh-mqboCL3WeYiqxivIR7M,459
+slots_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+slots_cli-0.1.0.dist-info/entry_points.txt,sha256=Y2svdyeHZUFzHRnRrT6LdNOgYGmWss2n2fEnkCSzp9o,79
+slots_cli-0.1.0.dist-info/top_level.txt,sha256=i2OhezRJlgfmhWJr_M5_16fPi80KyTU9JAbkmrOphCQ,6
+slots_cli-0.1.0.dist-info/RECORD,,

slots_cli-0.1.0.dist-info/WHEEL

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

slots_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+slots = slots.__main__:main
+slots-mcp = slots.slots_mcp:main

slots_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+slots