snapshot-cli 1.0.0__tar.gz

snapshot_cli-1.0.0/.gitignore

@@ -0,0 +1,23 @@
+# Virtual environments
+/env/
+/test_env/
+.venv/
+
+# Snap data
+.snapignore
+/.snap/
+
+# Python bytecode
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+*.egg
+
+# IDE
+.vscode/
+.idea/

snapshot_cli-1.0.0/LICENSE

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

snapshot_cli-1.0.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: snapshot-cli
+Version: 1.0.0
+Summary: A lightweight project snapshot & versioning tool for developers.
+Project-URL: Homepage, https://github.com/Sparkleeop/snapshot
+Project-URL: Repository, https://github.com/Sparkleeop/snapshot
+Project-URL: Issues, https://github.com/Sparkleeop/snapshot/issues
+Author: Sparkleeop
+License-Expression: MIT
+License-File: LICENSE
+Keywords: backup,cli,developer-tools,snapshot,versioning
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: System :: Archiving :: Backup
+Requires-Python: >=3.10
+Requires-Dist: rich>=13.0
+Description-Content-Type: text/markdown
+
+# Snapshot
+
+Snapshot is a lightweight code snapshotting tool that allows you to save and restore your entire project at any point in time.
+
+Think of it as a simpler alternative to Git when you just want quick save points without branches, commits, remotes, or repositories.
+
+## Features
+
+* Save snapshots of your entire project
+* Restore previous snapshots at any time
+* Ignore files and directories using `.snapignore`
+* View snapshot history
+* View detailed snapshot information
+* Clean restore mode for exact project restoration
+* Rich terminal interface
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install snapshot-cli
+```
+
+### From source (development)
+
+```bash
+git clone https://github.com/Sparkleeop/snapshot.git
+cd snapshot
+pip install -e .
+```
+
+This installs the `snap` command globally in your environment.
+
+## Usage
+
+Initialize Snapshot in your project root:
+
+```bash
+snap init
+```
+
+Create a snapshot:
+
+```bash
+snap save "before authentication rewrite"
+```
+
+List all snapshots, you can also find <snap id> here:
+
+```bash
+snap list
+```
+
+View information about a snapshot:
+
+```bash
+snap info <snap id>
+```
+
+Restore a snapshot:
+
+```bash
+snap restore <snap id>
+```
+
+Perform a clean restore (removes existing project files before restoring):
+
+```bash
+snap restore <snap id> --clean
+```
+
+Perform a restore to the latest snap:
+
+```bash
+snap restorelatest <--clean>
+```
+
+Delete a snapshot:
+
+```bash
+snap del <snap id>
+```
+
+Get the overall project statistics:
+
+```bash
+snap stats
+```
+
+## .snapignore
+
+Use a `.snapignore` file in your project root to exclude files and directories from snapshots.
+
+Example:
+
+```text
+.env
+venv
+__pycache__
+node_modules
+```
+
+## Publishing to PyPI
+
+Build and publish:
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+## Roadmap
+
+* [ ] Compare snapshots (`snap diff <id1> <id2>`)
+* [ ] Snapshot export/import
+* [ ] Automatic snapshots
+* [ ] Head snapshot

snapshot_cli-1.0.0/README.md

@@ -0,0 +1,119 @@
+# Snapshot
+
+Snapshot is a lightweight code snapshotting tool that allows you to save and restore your entire project at any point in time.
+
+Think of it as a simpler alternative to Git when you just want quick save points without branches, commits, remotes, or repositories.
+
+## Features
+
+* Save snapshots of your entire project
+* Restore previous snapshots at any time
+* Ignore files and directories using `.snapignore`
+* View snapshot history
+* View detailed snapshot information
+* Clean restore mode for exact project restoration
+* Rich terminal interface
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install snapshot-cli
+```
+
+### From source (development)
+
+```bash
+git clone https://github.com/Sparkleeop/snapshot.git
+cd snapshot
+pip install -e .
+```
+
+This installs the `snap` command globally in your environment.
+
+## Usage
+
+Initialize Snapshot in your project root:
+
+```bash
+snap init
+```
+
+Create a snapshot:
+
+```bash
+snap save "before authentication rewrite"
+```
+
+List all snapshots, you can also find <snap id> here:
+
+```bash
+snap list
+```
+
+View information about a snapshot:
+
+```bash
+snap info <snap id>
+```
+
+Restore a snapshot:
+
+```bash
+snap restore <snap id>
+```
+
+Perform a clean restore (removes existing project files before restoring):
+
+```bash
+snap restore <snap id> --clean
+```
+
+Perform a restore to the latest snap:
+
+```bash
+snap restorelatest <--clean>
+```
+
+Delete a snapshot:
+
+```bash
+snap del <snap id>
+```
+
+Get the overall project statistics:
+
+```bash
+snap stats
+```
+
+## .snapignore
+
+Use a `.snapignore` file in your project root to exclude files and directories from snapshots.
+
+Example:
+
+```text
+.env
+venv
+__pycache__
+node_modules
+```
+
+## Publishing to PyPI
+
+Build and publish:
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+## Roadmap
+
+* [ ] Compare snapshots (`snap diff <id1> <id2>`)
+* [ ] Snapshot export/import
+* [ ] Automatic snapshots
+* [ ] Head snapshot

snapshot_cli-1.0.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "snapshot-cli"
+version = "1.0.0"
+description = "A lightweight project snapshot & versioning tool for developers."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Sparkleeop" },
+]
+keywords = ["snapshot", "versioning", "backup", "cli", "developer-tools"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Version Control",
+    "Topic :: System :: Archiving :: Backup",
+]
+
+dependencies = [
+    "rich>=13.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Sparkleeop/snapshot"
+Repository = "https://github.com/Sparkleeop/snapshot"
+Issues = "https://github.com/Sparkleeop/snapshot/issues"
+
+[project.scripts]
+snap = "snapshot.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/snapshot"]

snapshot_cli-1.0.0/src/snapshot/__init__.py

@@ -0,0 +1,3 @@
+"""Snapshot — lightweight project snapshot & versioning tool."""
+
+__version__ = "1.0.0"

snapshot_cli-1.0.0/src/snapshot/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running Snapshot as `python -m snapshot`."""
+
+from snapshot.cli import main
+
+main()

snapshot_cli-1.0.0/src/snapshot/cli.py

@@ -0,0 +1,75 @@
+import argparse
+
+from snapshot.commands.init import init
+from snapshot.commands.list_snap import list_snap
+from snapshot.commands.save_snap import snapshot
+from snapshot.commands.restore_snap import restore
+from snapshot.commands.restore_latest import restore_latest
+from snapshot.commands.info_snap import show_info
+from snapshot.commands.delete_snap import delete
+from snapshot.commands.stats_snap import stats
+
+from snapshot.utils.console import print_help
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="snap",
+        description="Project snapshot manager",
+        add_help=False,
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    subparsers.add_parser("init")
+    subparsers.add_parser("list")
+    subparsers.add_parser("stats")
+
+    save_parser = subparsers.add_parser("save")
+    save_parser.add_argument("message")
+
+    restore_parser = subparsers.add_parser("restore")
+    restore_parser.add_argument("snap_id", type=int)
+    restore_parser.add_argument("--clean", action="store_true")
+
+    restore_latest_parser = subparsers.add_parser("restorelatest")
+    restore_latest_parser.add_argument("--clean", action="store_true")
+
+    info_parser = subparsers.add_parser("info")
+    info_parser.add_argument("snap_id", type=int)
+
+    del_parser = subparsers.add_parser("del")
+    del_parser.add_argument("snap_id", type=int)
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        init()
+
+    elif args.command == "save":
+        snapshot(args.message)
+
+    elif args.command == "restore":
+        restore(args.snap_id, clean=args.clean)
+
+    elif args.command == "restorelatest":
+        restore_latest(is_clean=args.clean)
+
+    elif args.command == "del":
+        delete(args.snap_id)
+
+    elif args.command == "info":
+        show_info(args.snap_id)
+
+    elif args.command == "stats":
+        stats()
+
+    elif args.command == "list":
+        list_snap()
+
+    else:
+        print_help()
+
+
+if __name__ == "__main__":
+    main()

snapshot_cli-1.0.0/src/snapshot/commands/__init__.py

@@ -0,0 +1 @@
+# Commands sub-package

snapshot_cli-1.0.0/src/snapshot/commands/delete_snap.py

@@ -0,0 +1,64 @@
+from snapshot.config import snap_dir, os
+from snapshot.utils.metadata_loader import load_metadata, save_metadata
+from snapshot.utils.console import (
+    console, success, error, warning, info,
+    PRIMARY, WARNING, ERROR, MUTED,
+)
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+def delete(snap_id):
+    if not os.path.exists(snap_dir):
+        error("Project not initialized.")
+        return
+
+    metadata = load_metadata()
+
+    snapshot = next(
+        (
+            item
+            for item in metadata["snapshots"]
+            if item["save_id"] == snap_id
+        ),
+        None,
+    )
+
+    if snapshot is None:
+        error(f"Snapshot #{snap_id} not found.")
+        return
+    
+    console.print(
+        Panel(
+            "[bold]This will permanently delete the selected snapshot.[/bold]\n"
+            "The snapshot archive and its metadata entry will be removed.",
+            title="[bold]! Snapshot Deletion[/bold]",
+            title_align="left",
+            border_style=WARNING,
+            padding=(1, 2),
+        )
+    )
+    console.print()
+
+    confirmed = Confirm.ask(
+        f"Delete snapshot #{snap_id}?",
+        default=False,
+    )
+
+    if not confirmed:
+        info("Deletion cancelled.")
+        return
+
+    zip_path = snapshot["file"]
+
+    if os.path.exists(zip_path):
+        os.remove(zip_path)
+
+    metadata["snapshots"] = [
+        item
+        for item in metadata["snapshots"]
+        if item["save_id"] != snap_id
+    ]
+
+    save_metadata(metadata)
+
+    success(f"Deleted snapshot #{snap_id}")

snapshot_cli-1.0.0/src/snapshot/commands/info_snap.py

@@ -0,0 +1,44 @@
+from snapshot.config import snap_dir, os
+from snapshot.utils.metadata_loader import load_metadata
+from snapshot.utils.console import (
+    console,
+    error,
+    info,
+    PRIMARY, INFO, MUTED,
+)
+from rich.panel import Panel
+
+
+def show_info(snap_id):
+    if not os.path.exists(snap_dir):
+        error("Project not initialized. Run [bold]snap init[/bold] first.")
+        return
+
+    metadata = load_metadata()
+
+    snapshot = next(
+        (
+            item
+            for item in metadata["snapshots"]
+            if item["save_id"] == snap_id
+        ),
+        None,
+    )
+
+    if snapshot is None:
+        error(f"Snapshot [bold]#{snap_id}[/bold] not found.")
+        return
+
+    console.print()
+    console.print(
+        Panel(
+            f"[bold]Message:[/bold]  [{INFO}]{snapshot['snap_message']}[/{INFO}]\n"
+            f"[bold]Created:[/bold]  [{INFO}]{snapshot['created_on'][:19]}[/{INFO}]\n"
+            f"[bold]Archive:[/bold]  [{MUTED}]{snapshot['file']}[/{MUTED}]",
+            title=f"[bold {PRIMARY}]Snapshot #{snapshot['save_id']}[/bold {PRIMARY}]",
+            border_style=MUTED,
+            padding=(1, 2),
+            expand=False,
+        )
+    )
+    console.print()

snapshot_cli-1.0.0/src/snapshot/commands/init.py

@@ -0,0 +1,17 @@
+from snapshot.config import os, snap_dir, snapshots_dir, metadata_default
+from snapshot.utils.console import success, warning
+import json
+
+def init():
+
+    # Snap directory creation
+    if os.path.exists(snap_dir):
+        warning("Project already initialized.")
+        return
+
+    os.makedirs(snapshots_dir)
+
+    with open(f"{snap_dir}/metadata.json", "w") as file:
+        json.dump(metadata_default, file, indent=4)
+
+    success("Project initialized successfully!")

snapshot_cli-1.0.0/src/snapshot/commands/list_snap.py

@@ -0,0 +1,58 @@
+from snapshot.config import snap_dir, os
+from snapshot.utils.metadata_loader import load_metadata
+from snapshot.utils.console import (
+    console, error, info, print_header,
+    PRIMARY, SUCCESS, MUTED, INFO,
+)
+from rich.table import Table
+from rich.panel import Panel
+
+def list_snap():
+    if not os.path.exists(snap_dir):
+        error("Project not initialized. Run [bold]snap init[/bold] first.")
+        return
+
+    metadata = load_metadata()
+    snapshots = metadata["snapshots"]
+
+    print_header()
+
+    if not snapshots:
+        info("No snapshots found. Run [bold]snap save <message>[/bold] to create one.")
+        return
+
+    table = Table(
+        show_header=True,
+        header_style=f"bold {PRIMARY}",
+        border_style=MUTED,
+        padding=(0, 2),
+        show_edge=False,
+        show_lines=True,
+        row_styles=["", "dim"],
+    )
+
+    table.add_column("#",            style=f"bold {PRIMARY}", justify="right", min_width=4)
+    table.add_column("Message",      style="bold white",      min_width=20)
+    table.add_column("Created",      style=INFO,              min_width=20)
+    table.add_column("Archive Path", style=MUTED,             min_width=16)
+
+    for snap in snapshots:
+        # Truncate the datetime for cleaner display
+        created = snap["created_on"][:19]
+        table.add_row(
+            str(snap["save_id"]),
+            snap["snap_message"],
+            created,
+            snap.get("file", "—"),
+        )
+
+    console.print(
+        Panel(
+            table,
+            title=f"[bold {PRIMARY}]Snapshots[/bold {PRIMARY}]",
+            subtitle=f"[dim]{len(snapshots)} snapshot{'s' if len(snapshots) != 1 else ''}[/dim]",
+            border_style=MUTED,
+            padding=(1, 1),
+        )
+    )
+    console.print()

snapshot_cli-1.0.0/src/snapshot/commands/restore_latest.py

@@ -0,0 +1,21 @@
+from snapshot.config import snap_dir, os
+from snapshot.utils.metadata_loader import load_metadata
+from snapshot.commands.restore_snap import restore
+
+from snapshot.utils.console import error
+
+def restore_latest(is_clean=False):
+    if not os.path.exists(snap_dir):
+        error("Project not initialized. Run [bold]snap init[/bold] first.")
+        return
+
+    metadata = load_metadata()
+    snapshots = metadata["snapshots"]
+
+    if not snapshots:
+        error("No snapshots found.")
+        return
+
+    latest_snap = snapshots[-1]
+    
+    restore(snap_id=latest_snap["save_id"], clean=is_clean)

snapshot_cli-1.0.0/src/snapshot/commands/restore_snap.py

@@ -0,0 +1,73 @@
+from snapshot.config import snap_dir, current_dir, os
+from snapshot.utils.file_manager import unzip_dir, clear_contents
+from snapshot.utils.metadata_loader import load_metadata
+from snapshot.utils.console import (
+    console, success, error, warning, info,
+    PRIMARY, WARNING, ERROR, MUTED,
+)
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+def restore(snap_id, clean=False):
+    if not os.path.exists(snap_dir):
+        error("Project not initialized. Run [bold]snap init[/bold] first.")
+        return
+
+    metadata = load_metadata()
+
+    snapshot = next(
+        (item for item in metadata["snapshots"] if item["save_id"] == snap_id),
+        None,
+    )
+
+    if snapshot is None:
+        error(f"Snapshot [bold]#{snap_id}[/bold] not found.")
+        return
+
+
+    console.print()
+    info(f"Snapshot [bold]#{snapshot['save_id']}[/bold] — \"{snapshot['snap_message']}\"")
+    info(f"Created: {snapshot['created_on'][:19]}")
+    console.print()
+
+
+    if clean:
+        console.print(
+            Panel(
+                "[bold]This is a clean restore.[/bold]\n"
+                "All current project files will be [bold]permanently deleted[/bold]\n"
+                "before extracting the snapshot.",
+                title="[bold]!  Destructive Operation[/bold]",
+                title_align="left",
+                border_style=WARNING,
+                padding=(1, 2),
+            )
+        )
+    else:
+        warning(
+            "Restoring will overwrite any conflicting files in the project directory."
+        )
+
+    console.print()
+
+    confirmed = Confirm.ask(
+        f"  [{PRIMARY}]Restore snapshot #{snap_id}?[/{PRIMARY}]",
+        default=False,
+    )
+
+    if not confirmed:
+        info("Restore cancelled.")
+        return
+
+    with console.status(
+        f"[{PRIMARY}]  Restoring snapshot #{snap_id}…[/{PRIMARY}]",
+        spinner="dots",
+        spinner_style=PRIMARY,
+    ):
+        if clean:
+            clear_contents(current_dir)
+
+        zip_path = snapshot["file"]
+        unzip_dir(zip_path)
+
+    success(f"Snapshot [bold]#{snap_id}[/bold] restored successfully!")

snapshot_cli-1.0.0/src/snapshot/commands/save_snap.py

@@ -0,0 +1,36 @@
+from snapshot.config import snap_dir, current_dir, os, snapshots_dir
+from snapshot.utils.metadata_loader import save_metadata, load_metadata
+from snapshot.utils.file_manager import zip_dir
+from snapshot.utils.console import console, success, error, info, PRIMARY, MUTED
+from datetime import datetime
+
+def snapshot(snap_message):
+    if not os.path.exists(snap_dir):
+        error("Project not initialized. Run [bold]snap init[/bold] first.")
+        return
+
+    metadata = load_metadata()
+
+    save_no = len(metadata["snapshots"]) + 1
+    zip_path = f"{snapshots_dir}/{save_no}.zip"
+
+    with console.status(
+        f"[{PRIMARY}]  Creating snapshot #{save_no}…[/{PRIMARY}]",
+        spinner="dots",
+        spinner_style=PRIMARY,
+    ):
+        zip_dir(current_dir, zip_path)
+
+    created_on = str(datetime.now())
+
+    metadata["snapshots"].append({
+        "snap_message": snap_message,
+        "save_id": save_no,
+        "file": zip_path,
+        "created_on": created_on
+    })
+
+    save_metadata(metadata)
+
+    success(f"Snapshot [bold]#{save_no}[/bold] saved — \"{snap_message}\"")
+    info(f"Archive: [{MUTED}]{zip_path}[/{MUTED}]")

snapshot_cli-1.0.0/src/snapshot/commands/stats_snap.py

@@ -0,0 +1,83 @@
+from snapshot.config import snap_dir, os
+from snapshot.utils.metadata_loader import load_metadata
+from snapshot.utils.file_manager import get_directory_size, human_size
+
+from snapshot.utils.console import (
+    console,
+    error,
+    PRIMARY,
+    MUTED,
+)
+from rich.table import Table
+from rich.panel import Panel
+
+def stats():
+
+    if not os.path.exists(snap_dir):
+        error("Project not initialized. Run [bold]snap init[/bold] first.")
+        return
+
+    metadata = load_metadata()
+    snapshots = metadata["snapshots"]
+
+    snap_count = len(snapshots)
+    snap_size = get_directory_size(snap_dir)
+
+    latest_snap = snapshots[-1] if snapshots else None
+    oldest_snap = snapshots[0] if snapshots else None
+
+    table = Table(
+        show_header=True,
+        header_style=f"bold {PRIMARY}",
+        border_style=MUTED,
+        padding=(0, 2),
+        show_edge=False,
+        show_lines=True,
+    )
+
+    table.add_column("Metric", style=f"bold {PRIMARY}")
+    table.add_column("Value", style="bold white")
+
+    table.add_row(
+        "Total Snapshots",
+        str(snap_count)
+    )
+
+    table.add_row(
+        "Storage Used",
+        human_size(snap_size)
+    )
+
+    if oldest_snap:
+        table.add_row(
+            "Oldest Snapshot",
+            f"#{oldest_snap['save_id']}"
+        )
+
+    if latest_snap:
+        table.add_row(
+            "Latest Snapshot",
+            f"#{latest_snap['save_id']}"
+        )
+
+        table.add_row(
+            "Latest Message",
+            latest_snap["snap_message"]
+        )
+
+        table.add_row(
+            "Created",
+            latest_snap["created_on"][:19]
+        )
+
+    console.print(
+        Panel(
+            table,
+            title=f"[bold {PRIMARY}]Statistics[/bold {PRIMARY}]",
+            subtitle=f"[dim]{snap_count} snapshot{'s' if snap_count != 1 else ''}[/dim]",
+            border_style=MUTED,
+            padding=(1, 1),
+        )
+    )
+
+    console.print()

snapshot_cli-1.0.0/src/snapshot/config.py

@@ -0,0 +1,8 @@
+import os
+
+current_dir = os.getcwd()
+snap_dir = ".snap"
+snapshots_dir = f"{snap_dir}/snapshots"
+metadata_default = {
+    "snapshots": []
+}

snapshot_cli-1.0.0/src/snapshot/utils/__init__.py

@@ -0,0 +1 @@
+# Utils sub-package

snapshot_cli-1.0.0/src/snapshot/utils/console.py

@@ -0,0 +1,102 @@
+
+
+from rich.console import Console
+from rich.theme import Theme
+from rich.panel import Panel
+from rich.text import Text
+from rich.table import Table
+import sys, io
+
+
+if sys.platform == "win32":
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
+
+
+PRIMARY   = "#3B82F6"
+SUCCESS   = "#10B981"
+WARNING   = "#F59E0B"
+ERROR     = "#EF4444"
+INFO      = "#06B6D4"
+MUTED     = "#6B7280"
+
+
+snap_theme = Theme({
+    "primary":  PRIMARY,
+    "success":  f"bold {SUCCESS}",
+    "warning":  f"bold {WARNING}",
+    "error":    f"bold {ERROR}",
+    "info":     INFO,
+    "muted":    MUTED,
+    "header":   f"bold {PRIMARY}",
+})
+
+console = Console(theme=snap_theme)
+
+
+
+def success(message: str) -> None:
+
+    console.print(f"  [success]+[/success]  {message}")
+
+def error(message: str) -> None:
+
+    console.print(f"  [error]x[/error]  [error]{message}[/error]")
+
+def warning(message: str) -> None:
+
+    console.print(f"  [warning]![/warning]  [warning]{message}[/warning]")
+
+def info(message: str) -> None:
+
+    console.print(f"  [info]>[/info]  [info]{message}[/info]")
+
+
+
+SNAP_LOGO = Text.from_markup(
+    f"[bold {PRIMARY}]Snap[/bold {PRIMARY}]  [dim]- Local Project Snapshots[/dim]"
+)
+
+def print_header() -> None:
+
+    console.print()
+    console.print(
+        Panel(
+            SNAP_LOGO,
+            border_style=PRIMARY,
+            padding=(0, 2),
+        )
+    )
+    console.print()
+
+
+
+def print_help() -> None:
+
+    print_header()
+
+    table = Table(
+        show_header=True,
+        header_style=f"bold {PRIMARY}",
+        border_style=MUTED,
+        padding=(0, 2),
+        show_edge=False,
+        show_lines=False,
+    )
+    table.add_column("Command", style="bold white", min_width=28)
+    table.add_column("Description", style="dim")
+
+    table.add_row("snap init",                    "Initialize a new Snap project")
+    table.add_row("snap save <message>",          "Save a snapshot with a message")
+    table.add_row("snap list",                    "List all saved snapshots")
+    table.add_row("snap restore <id>",            "Restore a snapshot by ID")
+    table.add_row("snap restore <id> --clean",    "Restore & remove current files first")
+
+    console.print(
+        Panel(
+            table,
+            title=f"[bold {PRIMARY}]Available Commands[/bold {PRIMARY}]",
+            border_style=MUTED,
+            padding=(1, 1),
+        )
+    )
+    console.print()

snapshot_cli-1.0.0/src/snapshot/utils/file_manager.py

@@ -0,0 +1,62 @@
+from snapshot.config import current_dir, snap_dir, os
+from snapshot.utils.snapignore import load_ignore_patterns, should_ignore
+import zipfile, shutil
+from pathlib import Path
+
+SYSTEM_PRESERVE = {
+    ".snap",
+    ".git"
+}
+
+def zip_dir(dir_path, zip_name):
+
+    ignore_patterns = load_ignore_patterns()
+
+    with zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        for root, dirs, files in os.walk(dir_path):
+            dirs[:] = [d for d in dirs if d != ".snap"]
+            dirs[:] = [d for d in dirs if d != ".git"]
+            dirs[:] = [d for d in dirs if not should_ignore(os.path.join(root, d), ignore_patterns)]
+            for file in files:
+                file_path = os.path.join(root, file)
+                if should_ignore(file_path, ignore_patterns):
+                    continue
+                # arcname preserves directory structure relative to dir_path
+                arcname = os.path.relpath(file_path, start=dir_path)
+                zipf.write(file_path, arcname)
+
+def unzip_dir(zip_path):
+    # Extract all files to a directory
+    with zipfile.ZipFile(f'{zip_path}', 'r') as zip_ref:
+        zip_ref.extractall(current_dir)
+
+def clear_contents(dir_path):
+    folder = Path(dir_path)
+
+    for item in folder.iterdir():
+
+        if item.name in SYSTEM_PRESERVE:
+            continue
+
+        if item.is_file() or item.is_symlink():
+            item.unlink()
+
+        elif item.is_dir():
+            shutil.rmtree(item)
+
+def get_directory_size(path):
+    total_size = 0
+    for dirpath, dirnames, filenames in os.walk(path):
+        for f in filenames:
+            fp = os.path.join(dirpath, f)
+            # Skip symbolic links to avoid infinite loops or errors
+            if not os.path.islink(fp):
+                total_size += os.path.getsize(fp)
+    return total_size
+
+def human_size(size):
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} PB"

snapshot_cli-1.0.0/src/snapshot/utils/metadata_loader.py

@@ -0,0 +1,11 @@
+from snapshot.config import snap_dir
+import json
+
+
+def load_metadata():
+    with open(f"{snap_dir}/metadata.json", "r") as file:
+        return json.load(file)
+    
+def save_metadata(data):
+    with open(f"{snap_dir}/metadata.json", "w") as file:
+        json.dump(data, file, indent=4)

snapshot_cli-1.0.0/src/snapshot/utils/snapignore.py

@@ -0,0 +1,36 @@
+from snapshot.config import current_dir, os
+from fnmatch import fnmatch
+
+def load_ignore_patterns():
+    snap_ignore_file = f"{current_dir}/.snapignore"
+
+    if not os.path.exists(snap_ignore_file):
+        return []
+
+    with open(snap_ignore_file, "r") as file:
+        patterns = file.readlines()
+
+    return [
+        line.strip()
+        for line in patterns
+        if line.strip() and not line.strip().startswith("#")
+    ]
+
+def should_ignore(file_path, ignore_patterns):
+    relative_path = os.path.relpath(file_path, current_dir)
+    relative_path = relative_path.replace("\\", "/")
+
+    for pattern in ignore_patterns:
+        pattern = pattern.strip()
+
+        # Folder ignore
+        if pattern.endswith("/"):
+            folder = pattern.rstrip("/")
+            if relative_path.startswith(folder + "/"):
+                return True
+
+        # Wildcard/file ignore
+        if fnmatch(relative_path, pattern):
+            return True
+
+    return False