shiggles 0.2.0__py3-none-any.whl

shiggles/__init__.py

@@ -0,0 +1,3 @@
+"""Shiggles - for git and shiggles. A simple content-addressed VCS."""
+
+__version__ = "0.2.0"

shiggles/__main__.py

@@ -0,0 +1,4 @@
+from shiggles.cli import main
+
+if __name__ == "__main__":
+    main()

shiggles/cli.py

@@ -0,0 +1,67 @@
+"""CLI entry point for shig."""
+
+import sys
+
+from shiggles import __version__
+from shiggles.commands import (
+    cmd_bring,
+    cmd_changes,
+    cmd_download,
+    cmd_history,
+    cmd_load,
+    cmd_save,
+    cmd_start,
+    cmd_tab,
+    cmd_timeline,
+    cmd_undo,
+    cmd_untab,
+    cmd_upload,
+)
+from shiggles.util import die
+
+COMMANDS = {
+    "start": cmd_start,
+    "save": cmd_save,
+    "load": cmd_load,
+    "changes": cmd_changes,
+    "history": cmd_history,
+    "undo": cmd_undo,
+    "tab": cmd_tab,
+    "untab": cmd_untab,
+    "bring": cmd_bring,
+    "download": cmd_download,
+    "upload": cmd_upload,
+    "timeline": cmd_timeline,
+}
+
+HELP = f"""Shiggles v{__version__} - for git and shiggles.
+
+Commands:
+  shig start                 set up this folder
+  shig save "message"        snapshot current tab
+  shig save --yes "message"  save even if remote is ahead (skip nudge)
+  shig load ["message"]      put files back to a save (becomes current)
+  shig changes               what's different since last save
+  shig history               saves on current tab
+  shig tab [name]            list tabs, or switch / create
+  shig untab <name>          remove a tab (history kept)
+  shig bring <tab>           land current tab into another (usually main)
+  shig download [path]       get latest current tab (folder or URL)
+  shig upload [path]         send current tab (folder or URL)
+  shig undo                  discard unsaved changes, restore last save
+  shig timeline              operation log
+"""
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help", "help"):
+        print(HELP)
+        return
+    cmd = sys.argv[1]
+    if cmd not in COMMANDS:
+        die(f"Unknown command: {cmd}\n  -> shig help")
+    COMMANDS[cmd](sys.argv[2:])
+
+
+if __name__ == "__main__":
+    main()

shiggles/commands.py

@@ -0,0 +1,414 @@
+"""All shig commands."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from shiggles.conflicts import (
+    find_conflicts,
+    format_conflict_message,
+    merge_indices,
+    park_files,
+)
+from shiggles.ignore import ensure_shignore
+from shiggles.paths import DEFAULT_TAB, SHIG
+from shiggles.repo import (
+    current_tab,
+    get_tab_commit,
+    init_repo,
+    list_saves_for_tab,
+    list_tabs,
+    log_event,
+    merge_timeline_lines,
+    merged_timeline_for_remote,
+    read_timeline_lines,
+    require_repo,
+    set_current_tab,
+    set_tab_commit,
+    tab_fork,
+    tab_ref,
+)
+from shiggles.store import parse_commit, write_commit
+from shiggles.remote import LocalRemote, Remote, get_remote, is_ancestor, resolve_remote_arg
+from shiggles.trees import (
+    build_tree_index,
+    commit_preview,
+    load_tree,
+    working_tree_index,
+    write_tree,
+    write_tree_from_index,
+)
+from shiggles.util import author_name, die, human_ago, load_config, save_config
+
+ROOT = Path(".")
+
+
+def _fork_index(tab: str) -> dict[str, str]:
+    fork = tab_fork(tab)
+    if not fork.exists():
+        return {}
+    commit = fork.read_text(encoding="utf-8").strip()
+    if not commit:
+        return {}
+    info = parse_commit(commit)
+    return build_tree_index(info["tree"])
+
+
+def _maybe_autosave(message: str):
+    head = get_tab_commit()
+    current = working_tree_index(ROOT)
+    previous = build_tree_index(parse_commit(head)["tree"]) if head else {}
+    if current == previous:
+        return
+    _do_save(message, quiet=True)
+
+
+def _do_save(message: str, *, quiet: bool = False):
+    tree = write_tree(ROOT)
+    tab = current_tab()
+    parent = get_tab_commit(tab)
+
+    if parent:
+        if parse_commit(parent)["tree"] == tree:
+            die("Nothing changed since last save.\n  -> shig changes")
+
+    commit_hash = write_commit(tree, parent, message, author_name(), int(time.time()))
+    set_tab_commit(tab, commit_hash)
+    log_event(f"save [{tab}] {commit_hash[:10]} {message!r}")
+    if not quiet:
+        print(f'Saved on {tab}: "{message}"')
+
+
+def cmd_start(_args):
+    if SHIG.exists():
+        die("Already a Shiggles repo here.\n  -> nothing to do.")
+    init_repo()
+    ensure_shignore()
+    log_event("start")
+    print("Watching this folder.")
+    print('  -> shig save "your first version"')
+
+
+def _maybe_nudge_download(*, force: bool):
+    cfg = load_config()
+    if "remote" not in cfg:
+        return
+    try:
+        remote = get_remote(cfg["remote"])
+    except SystemExit:
+        return
+    tab = current_tab()
+    local_commit = get_tab_commit(tab)
+    remote_commit = remote.read_tab_commit(tab)
+    if not remote_commit or remote_commit == local_commit:
+        return
+    if local_commit:
+        remote.sync_objects_from(remote_commit)
+        if is_ancestor(local_commit, remote_commit):
+            print(f"Someone else saved to {tab} since your last download.")
+            print("  -> shig download   first")
+            if force:
+                return
+            try:
+                answer = input("Save anyway? [y/N] ").strip().lower()
+            except EOFError:
+                die("Cancelled.")
+            if answer != "y":
+                die("Cancelled. Run shig download first.")
+
+
+def cmd_save(args):
+    require_repo()
+    force = False
+    if args and args[0] == "--yes":
+        force = True
+        args = args[1:]
+    if not args:
+        die('Save needs a message.\n  -> shig save "what you did"')
+    _maybe_nudge_download(force=force)
+    _do_save(args[0])
+
+
+def cmd_load(args):
+    require_repo()
+    tab = current_tab()
+    head = get_tab_commit()
+    saves = list_saves_for_tab(tab)
+    if not saves:
+        die('No saves yet.\n  -> shig save "first version"')
+
+    target = None
+    if args:
+        needle = args[0].lower()
+        for h, msg in saves:
+            if needle in msg.lower() or h.startswith(needle):
+                target = h
+                break
+        if not target:
+            die(f'No save matching "{args[0]}".\n  -> shig load')
+    else:
+        print("Pick a save to load:")
+        for i, (ch, msg) in enumerate(saves, 1):
+            preview = commit_preview(ch)
+            print(f"  {i}) {msg}  - {preview}")
+        try:
+            choice = input("> ").strip()
+            idx = int(choice) - 1
+            target = saves[idx][0]
+        except (ValueError, IndexError, EOFError):
+            die("Pick a number from the list.")
+
+    info = parse_commit(target)
+    load_tree(info["tree"], ROOT)
+    set_tab_commit(tab, target)
+    log_event(f"load {target[:10]}")
+    print(f'Loaded: "{info["message"]}"')
+
+
+def cmd_changes(_args):
+    require_repo()
+    head = get_tab_commit()
+    current = working_tree_index(ROOT)
+    previous = build_tree_index(parse_commit(head)["tree"]) if head else {}
+
+    added = [p for p in current if p not in previous]
+    removed = [p for p in previous if p not in current]
+    changed = [p for p in current if p in previous and current[p] != previous[p]]
+
+    tab = current_tab()
+    if not (added or removed or changed):
+        print(f"Clean on {tab}. Nothing changed since last save.")
+        return
+    print(f"Changes on {tab}:")
+    for p in added:
+        print(f"  + {p}")
+    for p in changed:
+        print(f"  ~ {p}")
+    for p in removed:
+        print(f"  - {p}")
+    print('\n  -> shig save "..."  to snapshot these')
+
+
+def cmd_history(_args):
+    require_repo()
+    tab = current_tab()
+    saves = list_saves_for_tab(tab)
+    if not saves:
+        print(f"No saves on {tab} yet.\n  -> shig save \"first version\"")
+        return
+    head = get_tab_commit(tab)
+    print(f"History on {tab}:")
+    for i, (h, msg) in enumerate(saves):
+        info = parse_commit(h)
+        when = human_ago(info["time"]) if info["time"] else "?"
+        who = info["author"] or "?"
+        mark = " *" if h == head else ""
+        print(f"* {msg}{mark}  ({who}, {when})")
+        if i < len(saves) - 1:
+            print("|")
+
+
+def cmd_undo(_args):
+    require_repo()
+    tab = current_tab()
+    head = get_tab_commit(tab)
+    if not head:
+        die('Nothing to undo.\n  -> shig save "first version"')
+
+    info = parse_commit(head)
+    current = working_tree_index(ROOT)
+    saved = build_tree_index(info["tree"])
+
+    if current == saved:
+        print(f"Clean on {tab}. Already matches last save.")
+        return
+
+    load_tree(info["tree"], ROOT)
+    log_event(f"undo [{tab}]")
+    print(f'Undone. Restored last save: "{info["message"]}"')
+
+
+def cmd_tab(args):
+    require_repo()
+    tabs = list_tabs()
+    if not args:
+        cur = current_tab()
+        print("Tabs:")
+        for t in tabs:
+            mark = " *" if t == cur else ""
+            head = get_tab_commit(t)
+            note = " (no saves yet)" if not head else ""
+            print(f"  {t}{mark}{note}")
+        print("\n  -> shig tab <name>  to switch or create")
+        return
+
+    name = args[0]
+    if name == DEFAULT_TAB and name not in tabs:
+        tabs.append(name)
+
+    cur = current_tab()
+    if name != cur:
+        _maybe_autosave(f"before switching to {name}")
+
+    if name not in tabs:
+        from shiggles.paths import REFS_TABS
+
+        fork = get_tab_commit(cur) or ""
+        REFS_TABS.mkdir(parents=True, exist_ok=True)
+        if fork:
+            set_tab_commit(name, fork)
+            tab_fork(name).parent.mkdir(parents=True, exist_ok=True)
+            tab_fork(name).write_text(fork + "\n", encoding="utf-8")
+        else:
+            tab_ref(name).touch()
+        log_event(f"tab new {name} from {cur}")
+
+    set_current_tab(name)
+    head = get_tab_commit(name)
+    if head:
+        info = parse_commit(head)
+        load_tree(info["tree"], ROOT)
+
+    print(f"On tab: {name}")
+
+
+def cmd_untab(args):
+    require_repo()
+    if not args:
+        die("Which tab?\n  -> shig untab <name>")
+    name = args[0]
+    if name == DEFAULT_TAB:
+        die("Can't remove the main tab.")
+    if name not in list_tabs():
+        die(f"No tab named {name!r}.")
+    if name == current_tab():
+        die(f"Switch off {name} first.\n  -> shig tab main")
+
+    tab_ref(name).unlink(missing_ok=True)
+    fork = tab_fork(name)
+    if fork.exists():
+        fork.unlink()
+    log_event(f"untab {name}")
+    print(f"Removed tab: {name}")
+    print("  (saves still in .shig/ - nothing deleted)")
+
+
+def cmd_bring(args):
+    require_repo()
+    if not args:
+        die("Bring into which tab?\n  -> shig bring main")
+    target = args[0]
+    source = current_tab()
+    if source == target:
+        die(f"Already on {target}.\n  -> shig tab <name> first")
+
+    if target not in list_tabs():
+        die(f"No tab named {target!r}.\n  -> shig tab {target}")
+
+    ours_commit = get_tab_commit(source)
+    theirs_commit = get_tab_commit(target)
+    if not ours_commit:
+        die(f"Nothing on {source} to bring.\n  -> shig save first")
+
+    ours = build_tree_index(parse_commit(ours_commit)["tree"])
+    theirs = build_tree_index(parse_commit(theirs_commit)["tree"]) if theirs_commit else {}
+    base = _fork_index(source) if source != DEFAULT_TAB else theirs
+
+    conflicts = find_conflicts(ours, theirs)
+    if conflicts:
+        park_files(theirs, conflicts, target)
+        die(format_conflict_message("bring", target, source, conflicts, target))
+
+    merged = merge_indices(base, ours, theirs)
+    merged_tree = write_tree_from_index(merged)
+    parent = theirs_commit
+    msg = f"brought {source} into {target}"
+    commit_hash = write_commit(merged_tree, parent, msg, author_name(), int(time.time()))
+    set_tab_commit(target, commit_hash)
+    load_tree(merged_tree, ROOT)
+    set_current_tab(target)
+    log_event(f"bring {source} -> {target} {commit_hash[:10]}")
+    print(f"Brought {source} -> {target}.")
+    print(f"  Now on {target}.")
+    print("  -> shig upload")
+
+
+def _apply_download(tab: str, local_commit: str | None, remote_commit: str, remote: Remote):
+    remote.sync_objects_from(remote_commit)
+    remote.copy_tab_meta_from(tab)
+    merge_timeline_lines(remote.read_timeline_lines())
+
+    if remote_commit == local_commit:
+        print(f"{tab} is up to date.")
+        return
+
+    if local_commit and is_ancestor(local_commit, remote_commit):
+        set_tab_commit(tab, remote_commit)
+        load_tree(parse_commit(remote_commit)["tree"], ROOT)
+        log_event(f"download [{tab}] {remote_commit[:10]}")
+        print(f"Downloaded latest {tab}.")
+        return
+
+    remote_index = build_tree_index(parse_commit(remote_commit)["tree"])
+    local_index = build_tree_index(parse_commit(local_commit)["tree"]) if local_commit else {}
+
+    conflicts = find_conflicts(local_index, remote_index)
+    if conflicts:
+        park_files(remote_index, conflicts, "remote")
+        die(format_conflict_message("download", tab, "remote", conflicts, "remote"))
+
+    set_tab_commit(tab, remote_commit)
+    load_tree(parse_commit(remote_commit)["tree"], ROOT)
+    log_event(f"download [{tab}] {remote_commit[:10]}")
+    print(f"Downloaded latest {tab}.")
+
+
+def cmd_download(args):
+    require_repo()
+    remote, _ = resolve_remote_arg(args)
+    if isinstance(remote, LocalRemote) and not Path(remote.path).exists():
+        die(f"Can't find: {remote.path}")
+
+    tab = current_tab()
+    remote_commit = remote.read_tab_commit(tab)
+    local_commit = get_tab_commit(tab)
+
+    if not remote_commit:
+        print(f"No {tab} on remote yet. Nothing to download.")
+        return
+
+    _apply_download(tab, local_commit, remote_commit, remote)
+
+
+def cmd_upload(args):
+    require_repo()
+    remote, _ = resolve_remote_arg(args)
+    remote.ensure_upload_ready()
+
+    tab = current_tab()
+    local_commit = get_tab_commit(tab)
+    if not local_commit:
+        die("Nothing to upload.\n  -> shig save first")
+
+    remote.sync_objects_to(local_commit)
+    remote.copy_tab_meta_to(tab)
+    remote.write_tab_commit(tab, local_commit)
+    log_event(f"upload [{tab}] {local_commit[:10]}")
+    local_lines = read_timeline_lines()
+    remote.write_timeline_lines(
+        merged_timeline_for_remote(local_lines, remote.read_timeline_lines())
+    )
+    print(f"Uploaded {tab} to {remote.label()}.")
+
+
+def cmd_timeline(_args):
+    require_repo()
+    from shiggles.paths import TIMELINE
+
+    if not TIMELINE.exists() or TIMELINE.stat().st_size == 0:
+        print("Timeline empty.")
+        return
+    for line in TIMELINE.read_text(encoding="utf-8").splitlines():
+        ts, text = line.split("\t", 1)
+        print(f"  {human_ago(int(ts)):>10}   {text}")

shiggles/conflicts.py

@@ -0,0 +1,98 @@
+import shutil
+from pathlib import Path
+
+from shiggles.paths import COLLISIONS
+from shiggles.store import read_object
+from shiggles.trees import build_tree_index
+
+
+def find_conflicts(ours: dict[str, str], theirs: dict[str, str]) -> list[str]:
+    """Paths where both sides have different blob hashes."""
+    conflicts = []
+    for path in sorted(set(ours) & set(theirs)):
+        if ours[path] != theirs[path]:
+            conflicts.append(path)
+    return conflicts
+
+
+def park_files(index: dict[str, str], paths: list[str], source: str):
+    """Write copies of *theirs* into .shig/collisions/<source>/."""
+    dest_root = COLLISIONS / source
+    for path in paths:
+        bh = index[path]
+        _, data = read_object(bh)
+        dest = dest_root / path
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_bytes(data)
+
+
+def clear_collision_dir(source: str):
+    root = COLLISIONS / source
+    if root.exists():
+        shutil.rmtree(root)
+
+
+def merge_indices(
+    base: dict[str, str],
+    ours: dict[str, str],
+    theirs: dict[str, str],
+) -> dict[str, str]:
+    """
+    Merge ours (current tab) into theirs (main/remote).
+    - Non-overlapping changes from ours apply.
+    - theirs wins for unchanged paths.
+    - Deletions from ours (in base, not in ours) apply.
+    """
+    merged = dict(theirs)
+    for path, bh in ours.items():
+        if path not in theirs:
+            merged[path] = bh
+        elif ours[path] == theirs[path]:
+            continue
+        else:
+            # conflict - caller must abort before calling merge
+            merged[path] = bh
+    for path in base:
+        if path in ours:
+            continue
+        if path in merged:
+            del merged[path]
+    return merged
+
+
+def format_conflict_message(
+    action: str,
+    target: str,
+    source: str,
+    conflicts: list[str],
+    collision_source: str,
+) -> str:
+    lines = [
+        f"Can't {action} {source} -> {target}.",
+        "",
+        "  Changed on BOTH sides:",
+    ]
+    for p in conflicts:
+        lines.append(f"    {p}")
+    lines.append("")
+    lines.append(f"  {target.capitalize()}'s copies (for comparison):")
+    for p in conflicts:
+        lines.append(f"    .shig/collisions/{collision_source}/{p}")
+    lines.append("")
+    lines.append("  Your files are unchanged in the project folder.")
+    lines.append("")
+    lines.append("  Next steps:")
+    if action == "bring":
+        lines.append("    1) Open the collision copies and your files side by side")
+        if source != target:
+            lines.append(f"    2) shig tab {target}")
+        lines.append("    3) shig download          (if using a shared folder)")
+        lines.append('    4) Fix the files, then shig save "..."')
+        lines.append("    5) shig upload")
+    elif action == "download":
+        lines.append("    1) Open .shig/collisions/remote/ files and your copies")
+        lines.append('    2) Fix the files, then shig save "..."')
+        lines.append("    3) shig download")
+    else:
+        lines.append("    Compare, fix, save, then try again.")
+    return "\n".join(lines)

shiggles/ignore.py

@@ -0,0 +1,52 @@
+import fnmatch
+import os
+from pathlib import Path, PurePosixPath
+
+from shiggles.paths import BUILTIN_IGNORE, DEFAULT_SHIGNORE, SHIGNORE
+
+
+def ensure_shignore():
+    if not SHIGNORE.exists():
+        SHIGNORE.write_text(DEFAULT_SHIGNORE, encoding="utf-8")
+
+
+def _read_patterns() -> list[str]:
+    if not SHIGNORE.exists():
+        return []
+    patterns = []
+    for line in SHIGNORE.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        patterns.append(line)
+    return patterns
+
+
+def _rel_path(path: Path, root: Path) -> str | None:
+    rel = os.path.relpath(path.resolve(), root.resolve())
+    if rel.startswith(".."):
+        return None
+    return Path(rel).as_posix()
+
+
+def _matches(rel: str, patterns: list[str]) -> bool:
+    name = PurePosixPath(rel).name
+    for pat in patterns:
+        if pat.endswith("/"):
+            dirpat = pat.rstrip("/")
+            if rel == dirpat or rel.startswith(dirpat + "/"):
+                return True
+            if dirpat in PurePosixPath(rel).parts:
+                return True
+        elif fnmatch.fnmatch(rel, pat) or fnmatch.fnmatch(name, pat):
+            return True
+    return False
+
+
+def ignored(path: Path, root: Path) -> bool:
+    if path.name in BUILTIN_IGNORE:
+        return True
+    rel = _rel_path(path, root)
+    if rel is None:
+        return True
+    return _matches(rel, _read_patterns())

shiggles/paths.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+SHIG = Path(".shig")
+OBJECTS = SHIG / "objects"
+REFS_TABS = SHIG / "refs" / "tabs"
+TAB_META = SHIG / "tabs"
+HEAD = SHIG / "HEAD"
+TIMELINE = SHIG / "timeline.log"
+CONFIG = SHIG / "config.json"
+COLLISIONS = SHIG / "collisions"
+SHIGNORE = Path(".shignore")
+
+DEFAULT_TAB = "main"
+
+BUILTIN_IGNORE = {".shig", ".git", "__pycache__", ".idea", ".vscode", "node_modules"}
+
+DEFAULT_SHIGNORE = """\
+# Shiggles - files and folders we never snapshot
+.shig/
+.git/
+__pycache__/
+*.pyc
+.DS_Store
+Thumbs.db
+release/
+build/
+dist/
+bin/
+obj/
+node_modules/
+"""